@cimplify/sdk 0.16.3 → 0.18.0

package/dist/chunk-DYKFSV77.js

@@ -0,0 +1,2837 @@
+'use strict';
+
+var chunkRYQ5IPWX_js = require('./chunk-RYQ5IPWX.js');
+
+// src/types/result.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+function isOk(result) {
+  return result.ok === true;
+}
+function isErr(result) {
+  return result.ok === false;
+}
+function mapResult(result, fn) {
+  return result.ok ? ok(fn(result.value)) : result;
+}
+function mapError(result, fn) {
+  return result.ok ? result : err(fn(result.error));
+}
+function flatMap(result, fn) {
+  return result.ok ? fn(result.value) : result;
+}
+function getOrElse(result, defaultFn) {
+  return result.ok ? result.value : defaultFn();
+}
+function unwrap(result) {
+  if (result.ok) {
+    return result.value;
+  }
+  throw result.error;
+}
+function toNullable(result) {
+  return result.ok ? result.value : void 0;
+}
+async function fromPromise(promise, mapError2) {
+  try {
+    const value = await promise;
+    return ok(value);
+  } catch (error) {
+    return err(mapError2(error));
+  }
+}
+function tryCatch(fn, mapError2) {
+  try {
+    return ok(fn());
+  } catch (error) {
+    return err(mapError2(error));
+  }
+}
+function combine(results) {
+  const values = [];
+  for (const result of results) {
+    if (!result.ok) {
+      return result;
+    }
+    values.push(result.value);
+  }
+  return ok(values);
+}
+function combineObject(results) {
+  const values = {};
+  for (const [key, result] of Object.entries(results)) {
+    if (!result.ok) {
+      return result;
+    }
+    values[key] = result.value;
+  }
+  return ok(values);
+}
+
+// src/internal/safe.ts
+function toCimplifyError(error) {
+  if (error instanceof chunkRYQ5IPWX_js.CimplifyError) return chunkRYQ5IPWX_js.enrichError(error);
+  if (error instanceof Error) {
+    return chunkRYQ5IPWX_js.enrichError(new chunkRYQ5IPWX_js.CimplifyError(chunkRYQ5IPWX_js.ErrorCode.UNKNOWN_ERROR, error.message, false));
+  }
+  return chunkRYQ5IPWX_js.enrichError(new chunkRYQ5IPWX_js.CimplifyError(chunkRYQ5IPWX_js.ErrorCode.UNKNOWN_ERROR, String(error), false));
+}
+async function safe(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError(error));
+  }
+}
+
+// src/catalogue.ts
+function withQuery(path, params) {
+  const query = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0) continue;
+    query.set(key, String(value));
+  }
+  const queryString = query.toString();
+  return queryString ? `${path}?${queryString}` : path;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function readFinalPrice(value) {
+  if (!isRecord(value)) return void 0;
+  const finalPrice = value.final_price;
+  if (typeof finalPrice === "string" || typeof finalPrice === "number") {
+    return finalPrice;
+  }
+  return void 0;
+}
+function needsDefaultPriceNormalization(value) {
+  return value === void 0 || value === null || value === "";
+}
+function optionNeedsNormalization(option) {
+  return isRecord(option) && needsDefaultPriceNormalization(option["default_price"]);
+}
+function addOnNeedsNormalization(addOn) {
+  if (!isRecord(addOn)) return false;
+  const options = addOn["options"];
+  return Array.isArray(options) && options.some((option) => optionNeedsNormalization(option));
+}
+function normalizeAddOnPayload(addOn) {
+  if (!isRecord(addOn)) return addOn;
+  const options = addOn["options"];
+  if (!Array.isArray(options)) return addOn;
+  if (!options.some((option) => optionNeedsNormalization(option))) return addOn;
+  const normalizedAddOn = { ...addOn };
+  normalizedAddOn["options"] = options.map((option) => {
+    if (!isRecord(option)) return option;
+    if (!optionNeedsNormalization(option)) return option;
+    const normalizedOption = { ...option };
+    const optionPrice = normalizedOption["default_price"];
+    if (needsDefaultPriceNormalization(optionPrice)) {
+      normalizedOption["default_price"] = readFinalPrice(normalizedOption["default_price_info"]) || readFinalPrice(normalizedOption["price_info"]) || "0";
+    }
+    return normalizedOption;
+  });
+  return normalizedAddOn;
+}
+function normalizeCatalogueProductPayload(product) {
+  const productRecord = product;
+  const defaultPrice = productRecord["default_price"];
+  const addOns = productRecord["add_ons"];
+  const needsPriceFix = needsDefaultPriceNormalization(defaultPrice);
+  const needsAddOnFix = Array.isArray(addOns) && addOns.some((addOn) => addOnNeedsNormalization(addOn));
+  if (!needsPriceFix && !needsAddOnFix) {
+    return product;
+  }
+  const normalized = { ...productRecord };
+  if (needsPriceFix) {
+    const derivedDefaultPrice = readFinalPrice(normalized["default_price_info"]) || readFinalPrice(normalized["price_info"]) || (typeof normalized["final_price"] === "string" || typeof normalized["final_price"] === "number" ? normalized["final_price"] : void 0);
+    normalized["default_price"] = derivedDefaultPrice ?? "0";
+  }
+  if (needsAddOnFix && Array.isArray(addOns)) {
+    normalized["add_ons"] = addOns.map((addOn) => normalizeAddOnPayload(addOn));
+  }
+  return normalized;
+}
+function toFiniteNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
+  }
+  return void 0;
+}
+function normalizePagination(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const totalCount = toFiniteNumber(value.total_count);
+  const currentPage = toFiniteNumber(value.current_page);
+  const pageSize = toFiniteNumber(value.page_size);
+  const totalPages = toFiniteNumber(value.total_pages);
+  if (totalCount === void 0 || currentPage === void 0 || pageSize === void 0 || totalPages === void 0) {
+    return void 0;
+  }
+  return {
+    total_count: totalCount,
+    current_page: currentPage,
+    page_size: pageSize,
+    total_pages: totalPages,
+    has_more: value.has_more === true,
+    next_cursor: typeof value.next_cursor === "string" ? value.next_cursor : void 0
+  };
+}
+function normalizeCatalogueResult(payload) {
+  if (Array.isArray(payload)) {
+    return {
+      items: payload.map((product) => normalizeCatalogueProductPayload(product)),
+      is_complete: true
+    };
+  }
+  if (!isRecord(payload)) {
+    return {
+      items: [],
+      is_complete: true
+    };
+  }
+  const rawItems = Array.isArray(payload.products) ? payload.products : Array.isArray(payload.items) ? payload.items : [];
+  return {
+    items: rawItems.map((product) => normalizeCatalogueProductPayload(product)),
+    is_complete: typeof payload.is_complete === "boolean" ? payload.is_complete : true,
+    total_available: toFiniteNumber(payload.total_available),
+    pagination: normalizePagination(payload.pagination)
+  };
+}
+function normalizeCatalogueSnapshot(payload) {
+  if (Array.isArray(payload)) {
+    return {
+      categories: [],
+      products: payload.map((product) => normalizeCatalogueProductPayload(product)),
+      add_ons: [],
+      is_complete: true
+    };
+  }
+  if (!isRecord(payload)) {
+    return {
+      categories: [],
+      products: [],
+      add_ons: [],
+      is_complete: true
+    };
+  }
+  const rawProducts = Array.isArray(payload.products) ? payload.products : Array.isArray(payload.items) ? payload.items : [];
+  const rawCategories = Array.isArray(payload.categories) ? payload.categories : [];
+  const rawAddOns = Array.isArray(payload.add_ons) ? payload.add_ons : [];
+  return {
+    categories: rawCategories,
+    products: rawProducts.map((product) => normalizeCatalogueProductPayload(product)),
+    add_ons: rawAddOns.map((addOn) => normalizeAddOnPayload(addOn)),
+    is_complete: typeof payload.is_complete === "boolean" ? payload.is_complete : true,
+    total_available: toFiniteNumber(payload.total_available),
+    pagination: normalizePagination(payload.pagination)
+  };
+}
+var CatalogueQueries = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getCatalogue() {
+    const result = await safe(this.client.get("/api/v1/catalogue"));
+    if (!result.ok) return result;
+    return ok(normalizeCatalogueSnapshot(result.value));
+  }
+  async getProducts(options) {
+    const path = withQuery("/api/v1/catalogue/products", {
+      category_id: options?.category,
+      taxonomy_id: options?.taxonomy,
+      search: options?.search,
+      page: options?.page,
+      tags: options?.tags?.join(","),
+      featured: options?.featured,
+      in_stock: options?.in_stock,
+      min_price: options?.min_price,
+      max_price: options?.max_price,
+      sort_by: options?.sort_by,
+      sort_order: options?.sort_order,
+      limit: options?.limit,
+      offset: options?.offset,
+      cursor: options?.cursor,
+      properties: options?.properties ? JSON.stringify(options.properties) : void 0
+    });
+    const result = await safe(this.client.get(path));
+    if (!result.ok) return result;
+    return ok(normalizeCatalogueResult(result.value));
+  }
+  async getProduct(id) {
+    const encodedId = encodeURIComponent(id);
+    const result = await safe(this.client.get(`/api/v1/catalogue/products/${encodedId}`));
+    if (!result.ok) return result;
+    return ok(normalizeCatalogueProductPayload(result.value));
+  }
+  async getProductBySlug(slug) {
+    const encodedSlug = encodeURIComponent(slug);
+    const result = await safe(this.client.get(`/api/v1/catalogue/products/slug/${encodedSlug}`));
+    if (!result.ok) return result;
+    return ok(normalizeCatalogueProductPayload(result.value));
+  }
+  async getVariants(productId) {
+    const encodedId = encodeURIComponent(productId);
+    return safe(this.client.get(`/api/v1/catalogue/products/${encodedId}/variants`));
+  }
+  async getVariantAxes(productId) {
+    const encodedId = encodeURIComponent(productId);
+    return safe(this.client.get(`/api/v1/catalogue/products/${encodedId}/variant-axes`));
+  }
+  async getVariantByAxisSelections(productId, selections) {
+    const encodedId = encodeURIComponent(productId);
+    return safe(
+      this.client.post(
+        `/api/v1/catalogue/products/${encodedId}/variants/find`,
+        { axis_selections: selections }
+      )
+    );
+  }
+  async getVariantById(productId, variantId) {
+    const encodedProductId = encodeURIComponent(productId);
+    const encodedVariantId = encodeURIComponent(variantId);
+    return safe(
+      this.client.get(
+        `/api/v1/catalogue/products/${encodedProductId}/variants/${encodedVariantId}`
+      )
+    );
+  }
+  async getAddOns(productId) {
+    const encodedId = encodeURIComponent(productId);
+    return safe(this.client.get(`/api/v1/catalogue/products/${encodedId}/add-ons`));
+  }
+  async getCategories() {
+    return safe(this.client.get("/api/v1/catalogue/categories"));
+  }
+  async getCategory(id) {
+    const encodedId = encodeURIComponent(id);
+    return safe(this.client.get(`/api/v1/catalogue/categories/${encodedId}`));
+  }
+  async getCategoryBySlug(slug) {
+    const encodedSlug = encodeURIComponent(slug);
+    return safe(this.client.get(`/api/v1/catalogue/categories/slug/${encodedSlug}`));
+  }
+  async getCategoryProducts(categoryId, options) {
+    const encodedId = encodeURIComponent(categoryId);
+    const path = withQuery(`/api/v1/catalogue/categories/${encodedId}/products`, {
+      limit: options?.limit,
+      offset: options?.offset
+    });
+    return safe(this.client.get(path));
+  }
+  async getCollections() {
+    return safe(this.client.get("/api/v1/catalogue/collections"));
+  }
+  async getCollection(id) {
+    const encodedId = encodeURIComponent(id);
+    return safe(this.client.get(`/api/v1/catalogue/collections/${encodedId}`));
+  }
+  async getCollectionBySlug(slug) {
+    const encodedSlug = encodeURIComponent(slug);
+    return safe(this.client.get(`/api/v1/catalogue/collections/slug/${encodedSlug}`));
+  }
+  async getCollectionProducts(collectionId, options) {
+    const encodedId = encodeURIComponent(collectionId);
+    const path = withQuery(`/api/v1/catalogue/collections/${encodedId}/products`, {
+      limit: options?.limit,
+      offset: options?.offset
+    });
+    return safe(this.client.get(path));
+  }
+  async searchCollections(query, limit = 20) {
+    const path = withQuery("/api/v1/catalogue/collections", { search: query, limit });
+    return safe(this.client.get(path));
+  }
+  async getBundles() {
+    return safe(this.client.get("/api/v1/catalogue/bundles"));
+  }
+  async searchBundles(query, limit = 20) {
+    const path = withQuery("/api/v1/catalogue/bundles", { search: query, limit });
+    return safe(this.client.get(path));
+  }
+  async getComposites(options) {
+    const path = withQuery("/api/v1/catalogue/composites", { limit: options?.limit });
+    return safe(this.client.get(path));
+  }
+  async calculateCompositePrice(compositeId, selections, locationId) {
+    const encodedId = encodeURIComponent(compositeId);
+    return safe(
+      this.client.post(
+        `/api/v1/catalogue/composites/${encodedId}/calculate-price`,
+        {
+          selections,
+          location_id: locationId
+        }
+      )
+    );
+  }
+  async fetchQuote(input) {
+    return safe(this.client.post("/api/v1/catalogue/quotes", input));
+  }
+  async getQuote(quoteId) {
+    const encodedQuoteId = encodeURIComponent(quoteId);
+    return safe(this.client.get(`/api/v1/catalogue/quotes/${encodedQuoteId}`));
+  }
+  async refreshQuote(input) {
+    const encodedQuoteId = encodeURIComponent(input.quote_id);
+    return safe(
+      this.client.post(
+        `/api/v1/catalogue/quotes/${encodedQuoteId}/refresh`,
+        input
+      )
+    );
+  }
+  async getTaxonomies(parentId) {
+    const path = withQuery("/api/v1/catalogue/taxonomies", { parent_id: parentId });
+    return safe(this.client.get(path));
+  }
+  async getTaxonomy(id) {
+    const encodedId = encodeURIComponent(id);
+    return safe(this.client.get(`/api/v1/catalogue/taxonomies/${encodedId}`));
+  }
+  async getTaxonomyPath(id) {
+    const encodedId = encodeURIComponent(id);
+    return safe(this.client.get(`/api/v1/catalogue/taxonomies/${encodedId}/path`));
+  }
+  async searchTaxonomies(query, limit) {
+    const path = withQuery("/api/v1/catalogue/taxonomies/search", { q: query, limit });
+    return safe(this.client.get(path));
+  }
+  async getProductSchedules(productId) {
+    const encodedId = encodeURIComponent(productId);
+    return safe(this.client.get(`/api/v1/catalogue/products/${encodedId}/schedules`));
+  }
+  async checkProductAvailableNow(productId, locationId) {
+    const encodedId = encodeURIComponent(productId);
+    const path = withQuery(`/api/v1/catalogue/products/${encodedId}/available-now`, { location_id: locationId });
+    return safe(this.client.get(path));
+  }
+  async getDeals(locationId) {
+    const path = withQuery("/api/v1/catalogue/deals", { location_id: locationId });
+    return safe(this.client.get(path));
+  }
+  async getProductsOnSale() {
+    return safe(this.client.get("/api/v1/catalogue/deals/on-sale"));
+  }
+  async getProductDeals(productId) {
+    const encodedId = encodeURIComponent(productId);
+    return safe(this.client.get(`/api/v1/catalogue/products/${encodedId}/deals`));
+  }
+  async getCategoryDeals(categoryId) {
+    const encodedId = encodeURIComponent(categoryId);
+    return safe(this.client.get(`/api/v1/catalogue/categories/${encodedId}/deals`));
+  }
+  async getCollectionDeals(collectionId) {
+    const encodedId = encodeURIComponent(collectionId);
+    return safe(this.client.get(`/api/v1/catalogue/collections/${encodedId}/deals`));
+  }
+  async validateDiscountCode(code, orderSubtotal, locationId) {
+    return safe(
+      this.client.post("/api/v1/catalogue/deals/validate", {
+        discount_code: code,
+        order_subtotal: orderSubtotal,
+        location_id: locationId
+      })
+    );
+  }
+  async search(query, options) {
+    const result = await this.getProducts({
+      ...options,
+      search: query,
+      limit: options?.limit ?? 20
+    });
+    if (!result.ok) return result;
+    return ok(result.value.items);
+  }
+  async searchProducts(query, options) {
+    return this.search(query, options);
+  }
+  async getMenu(options) {
+    const path = withQuery("/api/v1/catalogue/menu", {
+      category_id: options?.category,
+      limit: options?.limit
+    });
+    return safe(this.client.get(path));
+  }
+  async getMenuCategory(categoryId) {
+    const encodedId = encodeURIComponent(categoryId);
+    return safe(this.client.get(`/api/v1/catalogue/menu/categories/${encodedId}`));
+  }
+  async getMenuItem(itemId) {
+    const encodedId = encodeURIComponent(itemId);
+    return safe(this.client.get(`/api/v1/catalogue/menu/items/${encodedId}`));
+  }
+  async getTags(options) {
+    const path = withQuery("/api/v1/catalogue/tags", {
+      tag_group: options?.tag_group,
+      search: options?.search,
+      min_usage: options?.min_usage,
+      limit: options?.limit,
+      offset: options?.offset
+    });
+    return safe(this.client.get(path));
+  }
+  async getAttributeDefinitions() {
+    return safe(this.client.get("/api/v1/catalogue/attributes"));
+  }
+  async getPropertyFacets(options) {
+    const path = withQuery("/api/v1/catalogue/properties/facets", {
+      category_id: options?.category_id,
+      product_type: options?.product_type
+    });
+    return safe(this.client.get(path));
+  }
+  async getTaxonomyAttributes(taxonomyId) {
+    const encodedId = encodeURIComponent(taxonomyId);
+    return safe(
+      this.client.get(
+        `/api/v1/catalogue/taxonomies/${encodedId}/attributes`
+      )
+    );
+  }
+};
+
+// src/cart.ts
+function isUICartResponse(value) {
+  return "cart" in value;
+}
+function unwrapEnrichedCart(value) {
+  return isUICartResponse(value) ? value.cart : value;
+}
+var CartOperations = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async get() {
+    const result = await safe(this.client.get("/api/v1/cart"));
+    if (!result.ok) return result;
+    return ok(unwrapEnrichedCart(result.value));
+  }
+  async getRaw() {
+    return safe(this.client.get("/api/v1/cart"));
+  }
+  async getItems() {
+    return safe(this.client.get("/api/v1/cart/items"));
+  }
+  async getCount() {
+    return safe(this.client.get("/api/v1/cart/count"));
+  }
+  async getTotal() {
+    return safe(this.client.get("/api/v1/cart/total"));
+  }
+  async getSummary() {
+    const cartResult = await this.get();
+    if (!cartResult.ok) return cartResult;
+    const cart = cartResult.value;
+    return ok({
+      item_count: cart.items.length,
+      total_items: cart.items.reduce((sum, item) => sum + item.quantity, 0),
+      subtotal: cart.pricing.subtotal,
+      discount_amount: cart.pricing.total_discounts,
+      tax_amount: cart.pricing.tax_amount,
+      total: cart.pricing.total_price,
+      currency: cart.pricing.currency
+    });
+  }
+  async addItem(input) {
+    return safe(this.client.post("/api/v1/cart/items", input));
+  }
+  async updateItem(cartItemId, updates) {
+    if (typeof updates.quantity === "number") {
+      return this.updateQuantity(cartItemId, updates.quantity);
+    }
+    const encodedId = encodeURIComponent(cartItemId);
+    return safe(this.client.patch(`/api/v1/cart/items/${encodedId}`, updates));
+  }
+  async updateQuantity(cartItemId, quantity) {
+    const encodedId = encodeURIComponent(cartItemId);
+    return safe(
+      this.client.patch(`/api/v1/cart/items/${encodedId}`, {
+        quantity
+      })
+    );
+  }
+  async removeItem(cartItemId) {
+    const encodedId = encodeURIComponent(cartItemId);
+    return safe(this.client.delete(`/api/v1/cart/items/${encodedId}`));
+  }
+  async clear() {
+    return safe(this.client.delete("/api/v1/cart"));
+  }
+  async applyCoupon(code) {
+    return safe(
+      this.client.post("/api/v1/cart/coupons", {
+        coupon_code: code
+      })
+    );
+  }
+  async removeCoupon() {
+    return safe(this.client.delete("/api/v1/cart/coupons/current"));
+  }
+  async isEmpty() {
+    const countResult = await this.getCount();
+    if (!countResult.ok) return countResult;
+    return ok(countResult.value === 0);
+  }
+  async hasItem(productId, variantId) {
+    const itemsResult = await this.getItems();
+    if (!itemsResult.ok) return itemsResult;
+    const found = itemsResult.value.some((item) => {
+      const matchesProduct = item.item_id === productId;
+      if (!variantId) return matchesProduct;
+      const config = item.configuration;
+      if ("variant" in config && config.variant) {
+        return matchesProduct && config.variant.variant_id === variantId;
+      }
+      return matchesProduct;
+    });
+    return ok(found);
+  }
+  async findItem(productId, variantId) {
+    const itemsResult = await this.getItems();
+    if (!itemsResult.ok) return itemsResult;
+    const found = itemsResult.value.find((item) => {
+      const matchesProduct = item.item_id === productId;
+      if (!variantId) return matchesProduct;
+      const config = item.configuration;
+      if ("variant" in config && config.variant) {
+        return matchesProduct && config.variant.variant_id === variantId;
+      }
+      return matchesProduct;
+    });
+    return ok(found);
+  }
+};
+
+// src/constants.ts
+var CHECKOUT_MODE = {
+  LINK: "link",
+  GUEST: "guest"
+};
+var ORDER_TYPE = {
+  DELIVERY: "delivery",
+  PICKUP: "pickup",
+  DINE_IN: "dine-in",
+  WALK_IN: "walk-in"
+};
+var PAYMENT_METHOD = {
+  MOBILE_MONEY: "mobile_money",
+  CARD: "card"
+};
+var CHECKOUT_STEP = {
+  AUTHENTICATION: "authentication",
+  ORDER_DETAILS: "order_details",
+  PAYMENT_METHOD: "payment_method",
+  PAYMENT: "payment",
+  CONFIRMATION: "confirmation"
+};
+var PAYMENT_STATE = {
+  INITIAL: "initial",
+  PREPARING: "preparing",
+  PROCESSING: "processing",
+  VERIFYING: "verifying",
+  AWAITING_AUTHORIZATION: "awaiting_authorization",
+  SUCCESS: "success",
+  ERROR: "error",
+  TIMEOUT: "timeout"
+};
+var PICKUP_TIME_TYPE = {
+  ASAP: "asap",
+  SCHEDULED: "scheduled"
+};
+var MOBILE_MONEY_PROVIDER = {
+  MTN: "mtn",
+  VODAFONE: "vodafone",
+  AIRTEL: "airtel"
+};
+var AUTHORIZATION_TYPE = {
+  OTP: "otp",
+  PIN: "pin",
+  PHONE: "phone",
+  BIRTHDAY: "birthday",
+  ADDRESS: "address"
+};
+var DEVICE_TYPE = {
+  MOBILE: "mobile",
+  DESKTOP: "desktop",
+  TABLET: "tablet"
+};
+var CONTACT_TYPE = {
+  PHONE: "phone",
+  EMAIL: "email"
+};
+var LINK_QUERY = {
+  DATA: "link.data",
+  ADDRESSES: "link.addresses",
+  MOBILE_MONEY: "link.mobile_money",
+  PREFERENCES: "link.preferences",
+  SESSIONS: "link.sessions"
+};
+var LINK_MUTATION = {
+  CHECK_STATUS: "link.check_status",
+  ENROLL: "link.enroll",
+  ENROLL_AND_LINK_ORDER: "link.enroll_and_link_order",
+  UPDATE_PREFERENCES: "link.update_preferences",
+  CREATE_ADDRESS: "link.create_address",
+  UPDATE_ADDRESS: "link.update_address",
+  DELETE_ADDRESS: "link.delete_address",
+  SET_DEFAULT_ADDRESS: "link.set_default_address",
+  TRACK_ADDRESS_USAGE: "link.track_address_usage",
+  CREATE_MOBILE_MONEY: "link.create_mobile_money",
+  DELETE_MOBILE_MONEY: "link.delete_mobile_money",
+  SET_DEFAULT_MOBILE_MONEY: "link.set_default_mobile_money",
+  TRACK_MOBILE_MONEY_USAGE: "link.track_mobile_money_usage",
+  VERIFY_MOBILE_MONEY: "link.verify_mobile_money",
+  REVOKE_SESSION: "link.revoke_session",
+  REVOKE_ALL_SESSIONS: "link.revoke_all_sessions"
+};
+var AUTH_MUTATION = {
+  REQUEST_OTP: "auth.request_otp",
+  VERIFY_OTP: "auth.verify_otp"
+};
+var CHECKOUT_MUTATION = {
+  PROCESS: "checkout.process"
+};
+var PAYMENT_MUTATION = {
+  SUBMIT_AUTHORIZATION: "payment.submit_authorization",
+  CHECK_STATUS: "order.poll_payment_status"
+};
+var ORDER_MUTATION = {
+  UPDATE_CUSTOMER: "order.update_order_customer"
+};
+var DEFAULT_CURRENCY = "GHS";
+var DEFAULT_COUNTRY = "GHA";
+
+// src/utils/paystack.ts
+async function openPaystackPopup(options, signal) {
+  if (typeof window === "undefined") {
+    return { success: false, error: "PROVIDER_UNAVAILABLE" };
+  }
+  let PaystackPop;
+  try {
+    const imported = await import('@paystack/inline-js');
+    PaystackPop = imported.default;
+  } catch {
+    return { success: false, error: "PROVIDER_UNAVAILABLE" };
+  }
+  return new Promise((resolve) => {
+    let settled = false;
+    const resolveOnce = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (signal) {
+        signal.removeEventListener("abort", onAbort);
+      }
+      resolve(result);
+    };
+    const onAbort = () => {
+      resolveOnce({ success: false, error: "CANCELLED" });
+    };
+    if (signal?.aborted) {
+      resolveOnce({ success: false, error: "CANCELLED" });
+      return;
+    }
+    if (signal) {
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+    try {
+      const popup = new PaystackPop();
+      popup.newTransaction({
+        key: options.key,
+        email: options.email,
+        amount: options.amount,
+        currency: options.currency,
+        reference: options.reference,
+        accessCode: options.accessCode,
+        onSuccess: (transaction) => {
+          resolveOnce({
+            success: true,
+            reference: transaction.reference ?? options.reference
+          });
+        },
+        onCancel: () => {
+          resolveOnce({ success: false, error: "PAYMENT_CANCELLED" });
+        },
+        onError: (error) => {
+          resolveOnce({
+            success: false,
+            error: error?.message || "PAYMENT_FAILED"
+          });
+        }
+      });
+    } catch {
+      resolveOnce({ success: false, error: "POPUP_BLOCKED" });
+    }
+  });
+}
+
+// src/utils/checkout-resolver.ts
+var DEFAULT_POLL_INTERVAL_MS = 3e3;
+var DEFAULT_MAX_POLL_ATTEMPTS = 60;
+var MAX_CONSECUTIVE_NETWORK_ERRORS = 5;
+var CARD_PROVIDER_PAYSTACK = "paystack";
+var NEXT_ACTION_NONE = "none";
+var NEXT_ACTION_CARD_POPUP = "card_popup";
+var NEXT_ACTION_REDIRECT = "redirect";
+var NEXT_ACTION_AUTHORIZATION = "authorization";
+function normalizeCardPopupError(error) {
+  if (!error || error === "PAYMENT_CANCELLED" || error === "CANCELLED") {
+    return "PAYMENT_CANCELLED";
+  }
+  if (error === "PROVIDER_UNAVAILABLE") {
+    return "PROVIDER_UNAVAILABLE";
+  }
+  if (error === "POPUP_BLOCKED") {
+    return "POPUP_BLOCKED";
+  }
+  return "PAYMENT_FAILED";
+}
+function normalizeCardProvider(value) {
+  const normalized = value?.trim().toLowerCase();
+  return normalized && normalized.length > 0 ? normalized : CARD_PROVIDER_PAYSTACK;
+}
+async function openCardPopup(provider, checkoutResult, email, currency, signal) {
+  if (typeof window === "undefined") {
+    return { success: false, error: "PROVIDER_UNAVAILABLE" };
+  }
+  if (provider === CARD_PROVIDER_PAYSTACK) {
+    return openPaystackPopup(
+      {
+        key: checkoutResult.public_key || "",
+        email,
+        accessCode: checkoutResult.client_secret,
+        reference: checkoutResult.payment_reference || checkoutResult.client_secret,
+        currency
+      },
+      signal
+    );
+  }
+  return { success: false, error: "PROVIDER_UNAVAILABLE" };
+}
+var VALID_MOBILE_MONEY_PROVIDERS = new Set(Object.values(MOBILE_MONEY_PROVIDER));
+function isValidMobileMoneyProvider(value) {
+  return VALID_MOBILE_MONEY_PROVIDERS.has(value);
+}
+function normalizeAuthorizationType(value) {
+  if (value && typeof value === "object" && "address" in value) {
+    return "address";
+  }
+  if (typeof value !== "string") return void 0;
+  const normalized = value.trim().toLowerCase().replace(/[\s-]+/g, "_");
+  if (normalized === "otp" || normalized === "pin") return normalized;
+  if (normalized === "phone" || normalized === "birthday" || normalized === "address") {
+    return normalized;
+  }
+  return void 0;
+}
+function formatMoney(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value.toFixed(2);
+  }
+  if (typeof value === "string" && value.trim().length > 0) {
+    return value;
+  }
+  return "0.00";
+}
+function createAbortError() {
+  const error = new Error("CANCELLED");
+  error.name = "AbortError";
+  return error;
+}
+function isAbortError(error) {
+  if (error instanceof DOMException && error.name === "AbortError") {
+    return true;
+  }
+  return error instanceof Error && (error.name === "AbortError" || error.message === "CANCELLED");
+}
+var CheckoutResolver = class {
+  constructor(options) {
+    this.client = options.client;
+    this.checkoutData = options.checkoutData;
+    this.pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    this.maxPollAttempts = options.maxPollAttempts ?? DEFAULT_MAX_POLL_ATTEMPTS;
+    this.onStatusChange = options.onStatusChange;
+    this.onAuthorizationRequired = options.onAuthorizationRequired;
+    this.signal = options.signal;
+    this.returnUrl = options.returnUrl;
+    this.enrollInLink = options.enrollInLink !== false;
+    this.businessId = options.businessId;
+    this.addressData = options.addressData;
+    this.paymentData = options.paymentData;
+    this.orderType = options.orderType;
+    this.cartTotal = options.cartTotal;
+    this.cartCurrency = options.cartCurrency;
+    this.allowPopups = options.allowPopups ?? typeof window !== "undefined";
+  }
+  async resolve(checkoutResult) {
+    try {
+      this.ensureNotAborted();
+      if (!checkoutResult.order_id) {
+        return this.fail("CHECKOUT_FAILED", "Checkout did not return an order ID.", false);
+      }
+      if (checkoutResult.next_action) {
+        return this.resolveNextAction(checkoutResult);
+      }
+      let latestCheckoutResult = checkoutResult;
+      let authorizationType = normalizeAuthorizationType(checkoutResult.authorization_type);
+      let paymentReference = checkoutResult.payment_reference;
+      if (this.isSuccessfulStatus(checkoutResult.payment_status)) {
+        return this.finalizeSuccess(checkoutResult);
+      }
+      if (checkoutResult.client_secret && checkoutResult.public_key) {
+        const provider = normalizeCardProvider(checkoutResult.provider);
+        this.emit("awaiting_authorization", {
+          display_text: "Complete payment in the card authorization popup.",
+          order_id: checkoutResult.order_id,
+          order_number: checkoutResult.order_number
+        });
+        if (!this.allowPopups) {
+          return this.fail(
+            "PROVIDER_UNAVAILABLE",
+            "Card payment popup is unavailable in this environment.",
+            false
+          );
+        }
+        const popupResult = await openCardPopup(
+          provider,
+          checkoutResult,
+          this.checkoutData.customer.email || "customer@cimplify.io",
+          this.getOrderCurrency(checkoutResult),
+          this.signal
+        );
+        if (!popupResult.success) {
+          const popupError = normalizeCardPopupError(popupResult.error);
+          if (popupError === "POPUP_BLOCKED") {
+            return this.fail(
+              "POPUP_BLOCKED",
+              "Unable to open card payment popup. Please allow popups and try again.",
+              true
+            );
+          }
+          if (popupError === "PROVIDER_UNAVAILABLE") {
+            return this.fail(
+              "PROVIDER_UNAVAILABLE",
+              "Card payment provider is unavailable.",
+              false
+            );
+          }
+          return this.fail(
+            "PAYMENT_CANCELLED",
+            "Card payment was cancelled before completion.",
+            true
+          );
+        }
+        paymentReference = popupResult.reference || paymentReference;
+      }
+      if (checkoutResult.authorization_url) {
+        if (typeof window !== "undefined" && this.returnUrl) {
+          window.location.assign(checkoutResult.authorization_url);
+          return this.fail(
+            "REDIRECT_REQUIRED",
+            "Redirecting to complete payment authorization.",
+            true
+          );
+        }
+        if (typeof window !== "undefined") {
+          const popup = window.open(
+            checkoutResult.authorization_url,
+            "cimplify-auth",
+            "width=520,height=760,noopener,noreferrer"
+          );
+          if (!popup) {
+            return this.fail(
+              "POPUP_BLOCKED",
+              "Authorization popup was blocked. Please allow popups and retry.",
+              true
+            );
+          }
+        }
+      }
+      if (checkoutResult.requires_authorization || chunkRYQ5IPWX_js.isPaymentStatusRequiresAction(checkoutResult.payment_status)) {
+        const authorization = await this.handleAuthorization({
+          authorizationType,
+          paymentReference,
+          displayText: checkoutResult.display_text,
+          provider: checkoutResult.provider
+        });
+        if (!authorization.ok) {
+          return authorization.result;
+        }
+        if (authorization.value) {
+          latestCheckoutResult = authorization.value;
+          paymentReference = authorization.value.payment_reference || paymentReference;
+          authorizationType = normalizeAuthorizationType(authorization.value.authorization_type) || authorizationType;
+          if (this.isSuccessfulStatus(authorization.value.payment_status)) {
+            return this.finalizeSuccess(authorization.value);
+          }
+          if (this.isFailureStatus(authorization.value.payment_status)) {
+            return this.fail(
+              "AUTHORIZATION_FAILED",
+              authorization.value.display_text || "Payment authorization failed.",
+              false
+            );
+          }
+        }
+      }
+      return this.pollUntilTerminal({
+        orderId: checkoutResult.order_id,
+        latestCheckoutResult,
+        paymentReference,
+        authorizationType
+      });
+    } catch (error) {
+      if (isAbortError(error)) {
+        return this.fail("CANCELLED", "Checkout was cancelled.", true);
+      }
+      const message = error instanceof Error ? error.message : "Checkout failed unexpectedly.";
+      return this.fail("CHECKOUT_FAILED", message, true);
+    }
+  }
+  async resolveNextAction(checkoutResult) {
+    const action = checkoutResult.next_action;
+    if (this.isSuccessfulStatus(checkoutResult.payment_status)) {
+      return this.finalizeSuccess(checkoutResult);
+    }
+    let latestCheckoutResult = checkoutResult;
+    let paymentReference = checkoutResult.payment_reference;
+    switch (action.type) {
+      case NEXT_ACTION_NONE:
+        return this.finalizeSuccess(checkoutResult);
+      case NEXT_ACTION_CARD_POPUP: {
+        const provider = normalizeCardProvider(action.provider);
+        this.emit("awaiting_authorization", {
+          display_text: "Complete payment in the card authorization popup.",
+          order_id: checkoutResult.order_id,
+          order_number: checkoutResult.order_number
+        });
+        if (!this.allowPopups) {
+          return this.fail(
+            "PROVIDER_UNAVAILABLE",
+            "Card payment popup is unavailable in this environment.",
+            false
+          );
+        }
+        const popupResult = await openCardPopup(
+          provider,
+          checkoutResult,
+          this.checkoutData.customer.email || "customer@cimplify.io",
+          this.getOrderCurrency(checkoutResult),
+          this.signal
+        );
+        if (!popupResult.success) {
+          const popupError = normalizeCardPopupError(popupResult.error);
+          if (popupError === "POPUP_BLOCKED") {
+            return this.fail(
+              "POPUP_BLOCKED",
+              "Unable to open card payment popup. Please allow popups and try again.",
+              true
+            );
+          }
+          if (popupError === "PROVIDER_UNAVAILABLE") {
+            return this.fail("PROVIDER_UNAVAILABLE", "Card payment provider is unavailable.", false);
+          }
+          return this.fail("PAYMENT_CANCELLED", "Card payment was cancelled before completion.", true);
+        }
+        paymentReference = popupResult.reference || paymentReference;
+        break;
+      }
+      case NEXT_ACTION_REDIRECT: {
+        if (typeof window !== "undefined" && this.returnUrl) {
+          window.location.assign(action.authorization_url);
+          return this.fail("REDIRECT_REQUIRED", "Redirecting to complete payment authorization.", true);
+        }
+        if (typeof window !== "undefined") {
+          const popup = window.open(
+            action.authorization_url,
+            "cimplify-auth",
+            "width=520,height=760,noopener,noreferrer"
+          );
+          if (!popup) {
+            return this.fail(
+              "POPUP_BLOCKED",
+              "Authorization popup was blocked. Please allow popups and retry.",
+              true
+            );
+          }
+        }
+        break;
+      }
+      case NEXT_ACTION_AUTHORIZATION: {
+        const authType = normalizeAuthorizationType(action.authorization_type);
+        const authorization = await this.handleAuthorization({
+          authorizationType: authType,
+          paymentReference,
+          displayText: action.display_text,
+          provider: checkoutResult.provider
+        });
+        if (!authorization.ok) {
+          return authorization.result;
+        }
+        if (authorization.value) {
+          latestCheckoutResult = authorization.value;
+          paymentReference = authorization.value.payment_reference || paymentReference;
+          if (this.isSuccessfulStatus(authorization.value.payment_status)) {
+            return this.finalizeSuccess(authorization.value);
+          }
+          if (this.isFailureStatus(authorization.value.payment_status)) {
+            return this.fail(
+              "AUTHORIZATION_FAILED",
+              authorization.value.display_text || "Payment authorization failed.",
+              false
+            );
+          }
+        }
+        break;
+      }
+    }
+    return this.pollUntilTerminal({
+      orderId: checkoutResult.order_id,
+      latestCheckoutResult,
+      paymentReference,
+      authorizationType: normalizeAuthorizationType(checkoutResult.authorization_type)
+    });
+  }
+  async pollUntilTerminal(input) {
+    let consecutiveErrors = 0;
+    let latestCheckoutResult = input.latestCheckoutResult;
+    let paymentReference = input.paymentReference;
+    let authorizationType = input.authorizationType;
+    for (let attempt = 0; attempt < this.maxPollAttempts; attempt++) {
+      this.ensureNotAborted();
+      this.emit("polling", {
+        poll_attempt: attempt,
+        max_poll_attempts: this.maxPollAttempts,
+        order_id: input.orderId,
+        order_number: latestCheckoutResult.order_number
+      });
+      const statusResult = await this.client.checkout.pollPaymentStatus(input.orderId);
+      if (!statusResult.ok) {
+        consecutiveErrors += 1;
+        if (consecutiveErrors >= MAX_CONSECUTIVE_NETWORK_ERRORS) {
+          return this.fail(
+            "NETWORK_ERROR",
+            "Unable to confirm payment due to repeated network errors.",
+            true
+          );
+        }
+        await this.wait(this.pollIntervalMs);
+        continue;
+      }
+      consecutiveErrors = 0;
+      if (statusResult.value.reference) {
+        paymentReference = statusResult.value.reference;
+      }
+      const normalized = chunkRYQ5IPWX_js.normalizeStatusResponse(statusResult.value);
+      if (normalized.paid || chunkRYQ5IPWX_js.isPaymentStatusSuccess(normalized.status)) {
+        return this.finalizeSuccess(latestCheckoutResult);
+      }
+      if (chunkRYQ5IPWX_js.isPaymentStatusFailure(normalized.status)) {
+        return this.fail(
+          normalized.status ? normalized.status.toUpperCase() : "PAYMENT_FAILED",
+          normalized.message || "Payment failed during confirmation.",
+          false
+        );
+      }
+      if (chunkRYQ5IPWX_js.isPaymentStatusRequiresAction(normalized.status)) {
+        const authorization = await this.handleAuthorization({
+          authorizationType,
+          paymentReference,
+          displayText: normalized.message || latestCheckoutResult.display_text,
+          provider: latestCheckoutResult.provider
+        });
+        if (!authorization.ok) {
+          return authorization.result;
+        }
+        if (authorization.value) {
+          latestCheckoutResult = authorization.value;
+          paymentReference = authorization.value.payment_reference || paymentReference;
+          authorizationType = normalizeAuthorizationType(authorization.value.authorization_type) || authorizationType;
+          if (this.isSuccessfulStatus(authorization.value.payment_status)) {
+            return this.finalizeSuccess(authorization.value);
+          }
+          if (this.isFailureStatus(authorization.value.payment_status)) {
+            return this.fail(
+              "AUTHORIZATION_FAILED",
+              authorization.value.display_text || "Payment authorization failed.",
+              false
+            );
+          }
+        }
+      }
+      await this.wait(this.pollIntervalMs);
+    }
+    try {
+      const finalResult = await this.client.checkout.pollPaymentStatus(input.orderId);
+      if (finalResult.ok) {
+        const normalized = chunkRYQ5IPWX_js.normalizeStatusResponse(finalResult.value);
+        if (normalized.paid || chunkRYQ5IPWX_js.isPaymentStatusSuccess(normalized.status)) {
+          return this.finalizeSuccess(latestCheckoutResult);
+        }
+      }
+    } catch {
+    }
+    return this.fail(
+      "PAYMENT_TIMEOUT",
+      "Payment confirmation timed out. Please retry checkout.",
+      true
+    );
+  }
+  async handleAuthorization(input) {
+    const authorizationType = input.authorizationType;
+    const paymentReference = input.paymentReference;
+    if (!authorizationType || !paymentReference) {
+      return { ok: true };
+    }
+    this.emit("awaiting_authorization", {
+      authorization_type: authorizationType,
+      display_text: input.displayText,
+      provider: input.provider
+    });
+    let authorizationResult;
+    const submit = async (code) => {
+      this.ensureNotAborted();
+      const trimmedCode = code.trim();
+      if (!trimmedCode) {
+        throw new Error("Authorization code is required.");
+      }
+      const submitResult = await this.client.checkout.submitAuthorization({
+        reference: paymentReference,
+        auth_type: authorizationType,
+        value: trimmedCode
+      });
+      if (!submitResult.ok) {
+        throw new Error(submitResult.error.message || "Authorization failed.");
+      }
+      authorizationResult = submitResult.value;
+    };
+    try {
+      if (this.onAuthorizationRequired) {
+        await this.onAuthorizationRequired(authorizationType, submit);
+      } else {
+        return {
+          ok: false,
+          result: this.fail(
+            "AUTHORIZATION_REQUIRED",
+            "Authorization callback is required in headless checkout mode.",
+            false
+          )
+        };
+      }
+    } catch (error) {
+      if (isAbortError(error)) {
+        return {
+          ok: false,
+          result: this.fail("CANCELLED", "Checkout was cancelled.", true)
+        };
+      }
+      const message = error instanceof Error ? error.message : "Payment authorization failed.";
+      return {
+        ok: false,
+        result: this.fail("AUTHORIZATION_FAILED", message, true)
+      };
+    }
+    return {
+      ok: true,
+      value: authorizationResult
+    };
+  }
+  async finalizeSuccess(checkoutResult) {
+    this.emit("finalizing", {
+      order_id: checkoutResult.order_id,
+      order_number: checkoutResult.order_number
+    });
+    const enrolledInLink = await this.maybeEnrollInLink(checkoutResult.order_id);
+    this.emit("success", {
+      order_id: checkoutResult.order_id,
+      order_number: checkoutResult.order_number
+    });
+    return {
+      success: true,
+      order: {
+        id: checkoutResult.order_id,
+        order_number: checkoutResult.order_number || checkoutResult.order_id,
+        status: checkoutResult.payment_status || "paid",
+        total: this.getOrderTotal(checkoutResult),
+        currency: this.getOrderCurrency(checkoutResult)
+      },
+      enrolled_in_link: enrolledInLink
+    };
+  }
+  async maybeEnrollInLink(orderId) {
+    if (!this.enrollInLink || !orderId) {
+      return false;
+    }
+    let businessId = this.businessId;
+    if (!businessId) {
+      const businessResult = await this.client.business.getInfo();
+      if (!businessResult.ok || !businessResult.value?.id) {
+        return false;
+      }
+      businessId = businessResult.value.id;
+    }
+    const address = this.getEnrollmentAddress();
+    const mobileMoney = this.getEnrollmentMobileMoney();
+    try {
+      const enrollment = await this.client.link.enrollAndLinkOrder({
+        order_id: orderId,
+        business_id: businessId,
+        order_type: this.orderType || this.checkoutData.order_type,
+        address,
+        mobile_money: mobileMoney
+      });
+      return enrollment.ok && enrollment.value.success;
+    } catch {
+      return false;
+    }
+  }
+  getEnrollmentAddress() {
+    const source = this.addressData ?? this.checkoutData.address_info;
+    if (!source?.street_address) {
+      return void 0;
+    }
+    return {
+      label: "Default",
+      street_address: source.street_address,
+      apartment: source.apartment || void 0,
+      city: source.city || "",
+      region: source.region || "",
+      delivery_instructions: source.delivery_instructions || void 0,
+      phone_for_delivery: source.phone_for_delivery || void 0
+    };
+  }
+  getEnrollmentMobileMoney() {
+    if (this.paymentData?.type === "mobile_money" && this.paymentData.phone_number && this.paymentData.provider && isValidMobileMoneyProvider(this.paymentData.provider)) {
+      return {
+        phone_number: this.paymentData.phone_number,
+        provider: this.paymentData.provider,
+        label: this.paymentData.label || "Mobile Money"
+      };
+    }
+    if (this.checkoutData.mobile_money_details?.phone_number) {
+      return {
+        phone_number: this.checkoutData.mobile_money_details.phone_number,
+        provider: this.checkoutData.mobile_money_details.provider,
+        label: "Mobile Money"
+      };
+    }
+    return void 0;
+  }
+  getOrderTotal(checkoutResult) {
+    if (checkoutResult.fx?.pay_amount !== void 0) {
+      return formatMoney(checkoutResult.fx.pay_amount);
+    }
+    if (this.cartTotal !== void 0) {
+      return formatMoney(this.cartTotal);
+    }
+    return "0.00";
+  }
+  getOrderCurrency(checkoutResult) {
+    if (checkoutResult.fx?.pay_currency) {
+      return checkoutResult.fx.pay_currency;
+    }
+    if (this.cartCurrency) {
+      return this.cartCurrency;
+    }
+    if (this.checkoutData.pay_currency) {
+      return this.checkoutData.pay_currency;
+    }
+    return "GHS";
+  }
+  emit(status, context = {}) {
+    if (!this.onStatusChange) {
+      return;
+    }
+    try {
+      this.onStatusChange(status, context);
+    } catch {
+    }
+  }
+  fail(code, message, recoverable) {
+    this.emit("failed", {
+      display_text: message
+    });
+    return {
+      success: false,
+      error: {
+        code,
+        message,
+        recoverable
+      }
+    };
+  }
+  isSuccessfulStatus(status) {
+    const normalized = chunkRYQ5IPWX_js.normalizeStatusResponse({ status, paid: false });
+    return normalized.paid || chunkRYQ5IPWX_js.isPaymentStatusSuccess(normalized.status);
+  }
+  isFailureStatus(status) {
+    const normalized = chunkRYQ5IPWX_js.normalizeStatusResponse({ status, paid: false });
+    return chunkRYQ5IPWX_js.isPaymentStatusFailure(normalized.status);
+  }
+  ensureNotAborted() {
+    if (this.signal?.aborted) {
+      throw createAbortError();
+    }
+  }
+  wait(ms) {
+    this.ensureNotAborted();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        if (this.signal) {
+          this.signal.removeEventListener("abort", onAbort);
+        }
+        resolve();
+      }, ms);
+      const onAbort = () => {
+        clearTimeout(timer);
+        reject(createAbortError());
+      };
+      if (this.signal) {
+        this.signal.addEventListener("abort", onAbort, { once: true });
+      }
+    });
+  }
+};
+
+// src/checkout.ts
+function toTerminalFailure(code, message, recoverable) {
+  return {
+    success: false,
+    error: {
+      code,
+      message,
+      recoverable
+    }
+  };
+}
+function generateIdempotencyKey() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return `idem_${crypto.randomUUID()}`;
+  }
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 15);
+  return `idem_${timestamp}_${random}`;
+}
+var CheckoutService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  orderTokenParam(orderId) {
+    const token = this.client.getOrderToken(orderId);
+    return token ? `?token=${encodeURIComponent(token)}` : "";
+  }
+  async process(data) {
+    const checkoutData = {
+      ...data,
+      idempotency_key: data.idempotency_key || generateIdempotencyKey()
+    };
+    const result = await safe(
+      this.client.post("/api/v1/checkout", {
+        checkout_data: checkoutData
+      })
+    );
+    if (result.ok && result.value.bill_token) {
+      this.client.setOrderToken(result.value.order_id, result.value.bill_token);
+    }
+    return result;
+  }
+  async initializePayment(_orderId, _method) {
+    return err(
+      new chunkRYQ5IPWX_js.CimplifyError(
+        "NOT_IMPLEMENTED",
+        "initializePayment is not available in REST mode.",
+        false
+      )
+    );
+  }
+  async submitAuthorization(input) {
+    return safe(this.client.post("/api/v1/payments/authorization", input));
+  }
+  async pollPaymentStatus(orderId) {
+    const encodedId = encodeURIComponent(orderId);
+    const tokenParam = this.orderTokenParam(orderId);
+    return safe(this.client.get(`/api/v1/orders/${encodedId}/payment-status${tokenParam}`));
+  }
+  async updateOrderCustomer(orderId, customer) {
+    const encodedId = encodeURIComponent(orderId);
+    const tokenParam = this.orderTokenParam(orderId);
+    return safe(this.client.post(`/api/v1/orders/${encodedId}/customer${tokenParam}`, customer));
+  }
+  async verifyPayment(orderId) {
+    const encodedId = encodeURIComponent(orderId);
+    const tokenParam = this.orderTokenParam(orderId);
+    return safe(this.client.post(`/api/v1/orders/${encodedId}/verify-payment${tokenParam}`));
+  }
+  async processAndResolve(data) {
+    data.on_status_change?.("preparing", {});
+    if (!data.cart_id) {
+      return ok(
+        toTerminalFailure(
+          "INVALID_CART",
+          "A valid cart is required before checkout can start.",
+          false
+        )
+      );
+    }
+    const cartResult = await this.client.cart.get();
+    if (!cartResult.ok || !cartResult.value?.id) {
+      return ok(
+        toTerminalFailure(
+          "INVALID_CART",
+          "Unable to load cart for checkout.",
+          false
+        )
+      );
+    }
+    const cart = cartResult.value;
+    if (cart.id !== data.cart_id || cart.items.length === 0) {
+      return ok(
+        toTerminalFailure(
+          "INVALID_CART",
+          "Cart is empty or no longer valid. Please refresh and try again.",
+          false
+        )
+      );
+    }
+    const checkoutData = {
+      cart_id: data.cart_id,
+      location_id: data.location_id,
+      customer: data.customer,
+      order_type: data.order_type,
+      address_info: data.address_info,
+      payment_method: data.payment_method,
+      mobile_money_details: data.mobile_money_details,
+      special_instructions: data.special_instructions,
+      link_address_id: data.link_address_id,
+      link_payment_method_id: data.link_payment_method_id,
+      idempotency_key: data.idempotency_key || generateIdempotencyKey(),
+      metadata: data.metadata,
+      pay_currency: data.pay_currency,
+      fx_quote_id: data.fx_quote_id
+    };
+    const baseCurrency = chunkRYQ5IPWX_js.currencyCode(
+      (cart.pricing.currency || checkoutData.pay_currency || "GHS").toUpperCase()
+    );
+    const payCurrency = data.pay_currency?.trim().toUpperCase();
+    const payCurrencyCode = payCurrency ? chunkRYQ5IPWX_js.currencyCode(payCurrency) : void 0;
+    const cartTotalAmount = typeof cart.pricing.total_price === "number" ? cart.pricing.total_price : Number.parseFloat(cart.pricing.total_price || "0");
+    if (payCurrencyCode && payCurrencyCode !== baseCurrency && !checkoutData.fx_quote_id && Number.isFinite(cartTotalAmount) && cartTotalAmount > 0) {
+      const fxQuoteResult = await this.client.fx.lockQuote({
+        from: baseCurrency,
+        to: payCurrencyCode,
+        amount: cart.pricing.total_price
+      });
+      if (!fxQuoteResult.ok) {
+        return ok(
+          toTerminalFailure(
+            "FX_QUOTE_FAILED",
+            fxQuoteResult.error.message || "Unable to lock FX quote for checkout.",
+            true
+          )
+        );
+      }
+      checkoutData.pay_currency = payCurrencyCode;
+      checkoutData.fx_quote_id = fxQuoteResult.value.id;
+    }
+    data.on_status_change?.("processing", {});
+    const processResult = await this.process(checkoutData);
+    if (!processResult.ok) {
+      return ok(
+        toTerminalFailure(
+          processResult.error.code || "CHECKOUT_FAILED",
+          processResult.error.message || "Unable to process checkout.",
+          processResult.error.retryable ?? true
+        )
+      );
+    }
+    const resolver = new CheckoutResolver({
+      client: this.client,
+      checkoutData,
+      pollIntervalMs: data.poll_interval_ms,
+      maxPollAttempts: data.max_poll_attempts,
+      onStatusChange: data.on_status_change,
+      onAuthorizationRequired: data.on_authorization_required,
+      signal: data.signal,
+      returnUrl: data.return_url,
+      enrollInLink: data.enroll_in_link,
+      cartTotal: cart.pricing.total_price,
+      cartCurrency: checkoutData.pay_currency || cart.pricing.currency || "GHS",
+      orderType: checkoutData.order_type,
+      allowPopups: data.allow_popups
+    });
+    const resolved = await resolver.resolve(processResult.value);
+    return ok(resolved);
+  }
+};
+
+// src/orders.ts
+var OrderQueries = class {
+  constructor(client) {
+    this.client = client;
+  }
+  orderTokenParam(orderId) {
+    const token = this.client.getOrderToken(orderId);
+    return token ? `?token=${encodeURIComponent(token)}` : "";
+  }
+  async list(options) {
+    const params = new URLSearchParams();
+    if (options?.status) params.set("status", options.status);
+    if (options?.limit) params.set("limit", String(options.limit));
+    if (options?.offset) params.set("offset", String(options.offset));
+    const path = params.toString() ? `/api/v1/orders?${params.toString()}` : "/api/v1/orders";
+    return safe(this.client.get(path));
+  }
+  async get(orderId) {
+    const encodedId = encodeURIComponent(orderId);
+    const tokenParam = this.orderTokenParam(orderId);
+    return safe(this.client.get(`/api/v1/orders/${encodedId}${tokenParam}`));
+  }
+  async getRecent(limit = 5) {
+    return this.list({ limit });
+  }
+  async getByStatus(status) {
+    return this.list({ status });
+  }
+  async cancel(orderId, reason) {
+    const encodedId = encodeURIComponent(orderId);
+    const tokenParam = this.orderTokenParam(orderId);
+    return safe(
+      this.client.post(`/api/v1/orders/${encodedId}/cancel${tokenParam}`, {
+        reason
+      })
+    );
+  }
+};
+
+// src/link.ts
+function encodePathSegment(value) {
+  return encodeURIComponent(value);
+}
+function toCreateAddressPayload(input) {
+  return {
+    label: input.label,
+    street_address: input.address_line1,
+    apartment: input.address_line2,
+    city: input.city,
+    region: input.state ?? "",
+    postal_code: input.postal_code,
+    country: input.country
+  };
+}
+function toUpdateAddressPayload(input) {
+  return {
+    label: input.label,
+    street_address: input.address_line1,
+    apartment: input.address_line2,
+    city: input.city,
+    region: input.state,
+    postal_code: input.postal_code,
+    country: input.country
+  };
+}
+function toCreateMobileMoneyPayload(input) {
+  return {
+    phone_number: input.phone_number,
+    provider: input.provider,
+    label: input.account_name
+  };
+}
+var LinkService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getProfile() {
+    return safe(this.client.linkGet("/v1/link/profile"));
+  }
+  async requestOtp(input) {
+    return safe(this.client.linkPost("/v1/link/auth/request-otp", input));
+  }
+  async verifyOtp(input) {
+    const result = await safe(
+      this.client.linkPost("/v1/link/auth/verify-otp", input)
+    );
+    if (result.ok && result.value.session_token) {
+      this.client.setAccessToken(result.value.session_token);
+    }
+    return result;
+  }
+  async logout() {
+    const result = await safe(this.client.linkPost("/v1/link/auth/logout"));
+    if (result.ok) {
+      this.client.clearSession();
+    }
+    return result;
+  }
+  async checkStatus(contact) {
+    return safe(this.client.linkPost("/v1/link/check-status", { contact }));
+  }
+  async getLinkData() {
+    return safe(this.client.linkGet("/v1/link/data"));
+  }
+  async getAddresses() {
+    return safe(this.client.linkGet("/v1/link/addresses"));
+  }
+  async getMobileMoney() {
+    return safe(this.client.linkGet("/v1/link/mobile-money"));
+  }
+  async getPreferences() {
+    return safe(this.client.linkGet("/v1/link/preferences"));
+  }
+  async enroll(data) {
+    return safe(this.client.linkPost("/v1/link/enroll", data));
+  }
+  async enrollAndLinkOrder(data) {
+    return safe(
+      this.client.linkPost("/v1/link/enroll-and-link-order", data)
+    );
+  }
+  async updatePreferences(preferences) {
+    return safe(this.client.linkPost("/v1/link/preferences", preferences));
+  }
+  async createAddress(input) {
+    return safe(
+      this.client.linkPost("/v1/link/addresses", toCreateAddressPayload(input))
+    );
+  }
+  async updateAddress(input) {
+    return safe(
+      this.client.linkPost(
+        `/v1/link/addresses/${encodePathSegment(input.address_id)}`,
+        toUpdateAddressPayload(input)
+      )
+    );
+  }
+  async deleteAddress(addressId) {
+    return safe(
+      this.client.linkDelete(`/v1/link/addresses/${encodePathSegment(addressId)}`)
+    );
+  }
+  async setDefaultAddress(addressId) {
+    return safe(
+      this.client.linkPost(
+        `/v1/link/addresses/${encodePathSegment(addressId)}/default`
+      )
+    );
+  }
+  async trackAddressUsage(addressId) {
+    return safe(
+      this.client.linkPost(
+        `/v1/link/addresses/${encodePathSegment(addressId)}/track-usage`
+      )
+    );
+  }
+  async createMobileMoney(input) {
+    return safe(
+      this.client.linkPost(
+        "/v1/link/mobile-money",
+        toCreateMobileMoneyPayload(input)
+      )
+    );
+  }
+  async deleteMobileMoney(mobileMoneyId) {
+    return safe(
+      this.client.linkDelete(
+        `/v1/link/mobile-money/${encodePathSegment(mobileMoneyId)}`
+      )
+    );
+  }
+  async setDefaultMobileMoney(mobileMoneyId) {
+    return safe(
+      this.client.linkPost(
+        `/v1/link/mobile-money/${encodePathSegment(mobileMoneyId)}/default`
+      )
+    );
+  }
+  async trackMobileMoneyUsage(mobileMoneyId) {
+    return safe(
+      this.client.linkPost(
+        `/v1/link/mobile-money/${encodePathSegment(mobileMoneyId)}/track-usage`
+      )
+    );
+  }
+  async verifyMobileMoney(mobileMoneyId) {
+    return safe(
+      this.client.linkPost(
+        `/v1/link/mobile-money/${encodePathSegment(mobileMoneyId)}/verify`
+      )
+    );
+  }
+  async getSessions() {
+    return safe(this.client.linkGet("/v1/link/sessions"));
+  }
+  async revokeSession(sessionId) {
+    return safe(this.client.linkDelete(`/v1/link/sessions/${sessionId}`));
+  }
+  async revokeAllSessions() {
+    return safe(this.client.linkDelete("/v1/link/sessions"));
+  }
+};
+
+// src/auth.ts
+var AuthService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getStatus() {
+    return safe(this.client.get("/api/v1/auth/status"));
+  }
+  async getCurrentUser() {
+    const result = await this.getStatus();
+    if (!result.ok) return result;
+    return ok(result.value.customer || null);
+  }
+  async isAuthenticated() {
+    const result = await this.getStatus();
+    if (!result.ok) return result;
+    return ok(result.value.is_authenticated);
+  }
+  async requestOtp(contact, contactType) {
+    return safe(
+      this.client.post("/api/v1/auth/request-otp", {
+        contact,
+        contact_type: contactType
+      })
+    );
+  }
+  async verifyOtp(code, contact) {
+    return safe(
+      this.client.post("/api/v1/auth/verify-otp", {
+        otp_code: code,
+        contact
+      })
+    );
+  }
+  async logout() {
+    return safe(this.client.post("/api/v1/auth/logout"));
+  }
+  async updateProfile(input) {
+    return safe(this.client.post("/api/v1/auth/profile", input));
+  }
+};
+
+// src/business.ts
+var BusinessService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getInfo() {
+    return safe(this.client.get("/api/v1/business"));
+  }
+  async getByHandle(handle) {
+    const encodedHandle = encodeURIComponent(handle);
+    return safe(this.client.get(`/api/v1/business/by-handle/${encodedHandle}`));
+  }
+  async getByDomain(domain) {
+    const encodedDomain = encodeURIComponent(domain);
+    return safe(this.client.get(`/api/v1/business/by-domain?domain=${encodedDomain}`));
+  }
+  async getSettings() {
+    return safe(this.client.get("/api/v1/business/settings"));
+  }
+  async getLocations() {
+    return safe(this.client.get("/api/v1/business/locations"));
+  }
+  async getLocation(locationId) {
+    const result = await this.getLocations();
+    if (!result.ok) return err(result.error);
+    const location = result.value.find((item) => item.id === locationId);
+    if (!location) {
+      return err(new chunkRYQ5IPWX_js.CimplifyError(chunkRYQ5IPWX_js.ErrorCode.NOT_FOUND, `Location not found: ${locationId}`, false));
+    }
+    return ok(location);
+  }
+  async getHours() {
+    return safe(this.client.get("/api/v1/business/hours"));
+  }
+  async getLocationHours(locationId) {
+    const result = await this.getHours();
+    if (!result.ok) return result;
+    return ok(result.value.filter((hour) => hour.location_id === locationId));
+  }
+  async getBootstrap() {
+    return safe(this.client.get("/api/v1/bootstrap"));
+  }
+};
+
+// src/inventory.ts
+var InventoryService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  withQuery(path, params) {
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+      if (value === void 0) continue;
+      searchParams.set(key, String(value));
+    }
+    const query = searchParams.toString();
+    return query ? `${path}?${query}` : path;
+  }
+  async getProductStock(productId, locationId) {
+    const encodedId = encodeURIComponent(productId);
+    const path = this.withQuery(`/api/v1/inventory/products/${encodedId}/stock`, {
+      location_id: locationId
+    });
+    return safe(this.client.get(path));
+  }
+  async getVariantStock(variantId, locationId) {
+    const encodedId = encodeURIComponent(variantId);
+    const path = this.withQuery(`/api/v1/inventory/variants/${encodedId}/stock`, {
+      location_id: locationId
+    });
+    return safe(this.client.get(path));
+  }
+  async checkProductAvailability(productId, quantity, locationId) {
+    const encodedId = encodeURIComponent(productId);
+    const path = this.withQuery(`/api/v1/inventory/products/${encodedId}/availability`, {
+      quantity,
+      location_id: locationId
+    });
+    return safe(this.client.get(path));
+  }
+  async checkVariantAvailability(variantId, quantity, locationId) {
+    const encodedId = encodeURIComponent(variantId);
+    const path = this.withQuery(`/api/v1/inventory/variants/${encodedId}/availability`, {
+      quantity,
+      location_id: locationId
+    });
+    return safe(this.client.get(path));
+  }
+  async checkMultipleAvailability(items, locationId) {
+    const results = await Promise.all(
+      items.map(
+        (item) => item.variant_id ? this.checkVariantAvailability(item.variant_id, item.quantity, locationId) : this.checkProductAvailability(item.product_id, item.quantity, locationId)
+      )
+    );
+    for (const result of results) {
+      if (!result.ok) return result;
+    }
+    return ok(results.map((r) => r.value));
+  }
+  async isInStock(productId, locationId) {
+    const result = await this.checkProductAvailability(productId, 1, locationId);
+    if (!result.ok) return result;
+    return ok(result.value.is_available);
+  }
+  async getAvailableQuantity(productId, locationId) {
+    const result = await this.getProductStock(productId, locationId);
+    if (!result.ok) return result;
+    return ok(result.value.available_quantity);
+  }
+};
+
+// src/scheduling.ts
+function withQuery2(path, params) {
+  const searchParams = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0) continue;
+    searchParams.set(key, String(value));
+  }
+  const query = searchParams.toString();
+  return query ? `${path}?${query}` : path;
+}
+function firstScheduledTime(booking) {
+  return booking.service_items.find((item) => typeof item.scheduled_start === "string")?.scheduled_start || booking.created_at;
+}
+var SchedulingService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getServices() {
+    return safe(this.client.get("/api/v1/scheduling/services"));
+  }
+  async getService(serviceId) {
+    const encodedId = encodeURIComponent(serviceId);
+    return safe(this.client.get(`/api/v1/scheduling/services/${encodedId}`));
+  }
+  async getAvailableSlots(input) {
+    const path = withQuery2("/api/v1/scheduling/slots", {
+      service_id: input.service_id,
+      date: input.date,
+      participant_count: input.participant_count,
+      duration_minutes: input.duration_minutes
+    });
+    return safe(this.client.get(path));
+  }
+  async checkSlotAvailability(input) {
+    const path = withQuery2("/api/v1/scheduling/slots/check", {
+      service_id: input.service_id,
+      slot_time: input.slot_time,
+      duration_minutes: input.duration_minutes,
+      participant_count: input.participant_count
+    });
+    return safe(this.client.get(path));
+  }
+  async getServiceAvailability(params) {
+    const path = withQuery2("/api/v1/scheduling/availability", {
+      service_id: params.service_id,
+      start_date: params.start_date,
+      end_date: params.end_date,
+      location_id: params.location_id,
+      participant_count: params.participant_count
+    });
+    return safe(this.client.get(path));
+  }
+  async getBooking(bookingId) {
+    const encodedId = encodeURIComponent(bookingId);
+    return safe(this.client.get(`/api/v1/scheduling/bookings/${encodedId}`));
+  }
+  async getCustomerBookings(customerId) {
+    const path = withQuery2("/api/v1/scheduling/bookings", {
+      customer_id: customerId
+    });
+    return safe(this.client.get(path));
+  }
+  async getUpcomingBookings() {
+    const result = await this.getCustomerBookings();
+    if (!result.ok) return result;
+    const upcoming = result.value.filter((booking) => {
+      const status = String(booking.status).toLowerCase();
+      return status !== "completed" && status !== "cancelled";
+    }).sort((a, b) => firstScheduledTime(a).localeCompare(firstScheduledTime(b)));
+    return ok(upcoming);
+  }
+  async getPastBookings(limit = 10) {
+    const result = await this.getCustomerBookings();
+    if (!result.ok) return result;
+    const past = result.value.filter((booking) => String(booking.status).toLowerCase() === "completed").sort((a, b) => firstScheduledTime(b).localeCompare(firstScheduledTime(a))).slice(0, Math.max(0, limit));
+    return ok(past);
+  }
+  async cancelBooking(input) {
+    const encodedId = encodeURIComponent(input.booking_id);
+    return safe(
+      this.client.post(`/api/v1/scheduling/bookings/${encodedId}/cancel`, {
+        reason: input.reason
+      })
+    );
+  }
+  async rescheduleBooking(input) {
+    return safe(
+      this.client.post("/api/v1/scheduling/bookings/reschedule", input)
+    );
+  }
+  async getNextAvailableSlot(serviceId, fromDate) {
+    const date = fromDate || (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const result = await this.getAvailableSlots({
+      service_id: serviceId,
+      date
+    });
+    if (!result.ok) return result;
+    return ok(result.value.find((slot) => slot.is_available) || null);
+  }
+  async hasAvailabilityOn(serviceId, date) {
+    const result = await this.getAvailableSlots({
+      service_id: serviceId,
+      date
+    });
+    if (!result.ok) return result;
+    return ok(result.value.some((slot) => slot.is_available));
+  }
+};
+
+// src/lite.ts
+var LiteService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getBootstrap() {
+    return safe(this.client.get("/api/v1/lite/bootstrap"));
+  }
+  async getTable(tableId) {
+    const encodedId = encodeURIComponent(tableId);
+    return safe(this.client.get(`/api/v1/lite/tables/${encodedId}`));
+  }
+  async getMenu() {
+    return safe(this.client.get("/api/v1/lite/menu"));
+  }
+  async getMenuByCategory(categoryId) {
+    const encodedId = encodeURIComponent(categoryId);
+    return safe(this.client.get(`/api/v1/lite/menu/categories/${encodedId}`));
+  }
+};
+
+// src/fx.ts
+var FxService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getRate(from, to) {
+    const path = `/api/v1/fx/rate?from=${encodeURIComponent(from)}&to=${encodeURIComponent(to)}`;
+    return safe(this.client.get(path));
+  }
+  async lockQuote(request) {
+    return safe(this.client.post("/api/v1/fx/quotes", request));
+  }
+};
+
+// src/types/elements.ts
+var ELEMENT_TYPES = {
+  AUTH: "auth",
+  ADDRESS: "address",
+  PAYMENT: "payment",
+  CHECKOUT: "checkout"
+};
+var MESSAGE_TYPES = {
+  INIT: "init",
+  SET_TOKEN: "set_token",
+  SET_CART: "set_cart",
+  GET_DATA: "get_data",
+  REFRESH_TOKEN: "refresh_token",
+  LOGOUT: "logout",
+  PROCESS_CHECKOUT: "process_checkout",
+  ABORT_CHECKOUT: "abort_checkout",
+  READY: "ready",
+  HEIGHT_CHANGE: "height_change",
+  AUTHENTICATED: "authenticated",
+  REQUIRES_OTP: "requires_otp",
+  ERROR: "error",
+  ADDRESS_CHANGED: "address_changed",
+  ADDRESS_SELECTED: "address_selected",
+  PAYMENT_METHOD_SELECTED: "payment_method_selected",
+  TOKEN_REFRESHED: "token_refreshed",
+  LOGOUT_COMPLETE: "logout_complete",
+  CONTACT_PROVIDED: "contact_provided",
+  CHECKOUT_STATUS: "checkout_status",
+  CHECKOUT_COMPLETE: "checkout_complete",
+  ORDER_TYPE_CHANGED: "order_type_changed",
+  REQUEST_SUBMIT: "request_submit"
+};
+var EVENT_TYPES = {
+  READY: "ready",
+  AUTHENTICATED: "authenticated",
+  REQUIRES_OTP: "requires_otp",
+  ERROR: "error",
+  CHANGE: "change",
+  BLUR: "blur",
+  FOCUS: "focus",
+  ORDER_TYPE_CHANGED: "order_type_changed",
+  REQUEST_SUBMIT: "request_submit"
+};
+
+// src/elements.ts
+function toCheckoutError(code, message, recoverable) {
+  const hint = chunkRYQ5IPWX_js.getErrorHint(code);
+  return {
+    success: false,
+    error: {
+      code,
+      message,
+      recoverable,
+      docs_url: hint?.docs_url,
+      suggestion: hint?.suggestion
+    }
+  };
+}
+var DEFAULT_LINK_URL = "https://link.cimplify.io";
+function generateNonce() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID().replace(/-/g, "").slice(0, 16);
+  }
+  return Math.random().toString(36).slice(2) + Math.random().toString(36).slice(2);
+}
+function isAllowedOrigin(origin) {
+  try {
+    const url = new URL(origin);
+    const hostname = url.hostname;
+    if (hostname === "localhost" || hostname === "127.0.0.1") {
+      return true;
+    }
+    if (url.protocol !== "https:") {
+      return false;
+    }
+    return hostname === "cimplify.io" || hostname.endsWith(".cimplify.io");
+  } catch {
+    return false;
+  }
+}
+function parseIframeMessage(data) {
+  if (!data || typeof data !== "object") {
+    return null;
+  }
+  const maybeType = data.type;
+  if (typeof maybeType !== "string") {
+    return null;
+  }
+  return data;
+}
+var CimplifyElements = class {
+  constructor(client, businessId, options = {}) {
+    this.elements = /* @__PURE__ */ new Map();
+    this.accessToken = null;
+    this.accountId = null;
+    this.customerId = null;
+    this.customerData = null;
+    this.addressData = null;
+    this.paymentData = null;
+    this.checkoutInProgress = false;
+    this.activeCheckoutAbort = null;
+    this.businessIdResolvePromise = null;
+    this.client = client;
+    this.businessId = businessId ?? null;
+    this.linkUrl = options.linkUrl || DEFAULT_LINK_URL;
+    this.options = options;
+    this.boundHandleMessage = this.handleMessage.bind(this);
+    if (typeof window !== "undefined") {
+      window.addEventListener("message", this.boundHandleMessage);
+    }
+  }
+  debug(...args) {
+    if (this.client.isTestMode()) {
+      console.debug(...args);
+    }
+  }
+  create(type, options = {}) {
+    const existing = this.elements.get(type);
+    if (existing) return existing;
+    const element = new CimplifyElement(type, this.businessId, this.linkUrl, options, this);
+    this.elements.set(type, element);
+    return element;
+  }
+  getElement(type) {
+    return this.elements.get(type);
+  }
+  _removeElement(type, instance) {
+    const current = this.elements.get(type);
+    if (current === instance) {
+      this.elements.delete(type);
+    }
+  }
+  destroy() {
+    this.elements.forEach((element) => element.destroy());
+    this.elements.clear();
+    if (typeof window !== "undefined") {
+      window.removeEventListener("message", this.boundHandleMessage);
+    }
+  }
+  async submitCheckout(data) {
+    const result = await this.processCheckout({
+      cart_id: data.cart_id,
+      order_type: data.order_type ?? "delivery",
+      location_id: data.location_id,
+      notes: data.notes,
+      scheduled_time: data.scheduled_time,
+      tip_amount: data.tip_amount,
+      enroll_in_link: true
+    });
+    if (result.success) {
+      return {
+        success: true,
+        order: {
+          id: result.order?.id || "",
+          status: result.order?.status || "unknown",
+          total: result.order?.total || ""
+        }
+      };
+    }
+    return {
+      success: false,
+      error: {
+        code: result.error?.code || "CHECKOUT_FAILED",
+        message: result.error?.message || "Checkout failed"
+      }
+    };
+  }
+  processCheckout(options) {
+    let abortFn = null;
+    const task = (async () => {
+      this.debug("[cimplify:checkout] processCheckout called", { cart_id: options.cart_id, order_type: options.order_type, location_id: options.location_id });
+      if (this.checkoutInProgress) {
+        this.debug("[cimplify:checkout] BLOCKED: already processing");
+        return toCheckoutError(
+          "ALREADY_PROCESSING",
+          "Checkout is already in progress.",
+          false
+        );
+      }
+      this.checkoutInProgress = true;
+      if (!options.cart_id) {
+        this.debug("[cimplify:checkout] BLOCKED: no cart_id");
+        this.checkoutInProgress = false;
+        return toCheckoutError(
+          "INVALID_CART",
+          "A valid cart is required before checkout can start.",
+          false
+        );
+      }
+      if (!options.order_type) {
+        this.debug("[cimplify:checkout] BLOCKED: no order_type");
+        this.checkoutInProgress = false;
+        return toCheckoutError(
+          "ORDER_TYPE_REQUIRED",
+          "Order type is required before checkout can start.",
+          false
+        );
+      }
+      const checkoutElement = this.elements.get(ELEMENT_TYPES.CHECKOUT) || this.elements.get(ELEMENT_TYPES.PAYMENT);
+      if (!checkoutElement) {
+        this.debug("[cimplify:checkout] BLOCKED: no checkout element");
+        this.checkoutInProgress = false;
+        return toCheckoutError(
+          "NO_PAYMENT_ELEMENT",
+          "Checkout element must be mounted before checkout.",
+          false
+        );
+      }
+      if (!checkoutElement.isMounted()) {
+        this.debug("[cimplify:checkout] BLOCKED: checkout element not mounted");
+        this.checkoutInProgress = false;
+        return toCheckoutError(
+          "PAYMENT_NOT_MOUNTED",
+          "Checkout element must be mounted before checkout.",
+          false
+        );
+      }
+      const isUnifiedCheckout = this.elements.has(ELEMENT_TYPES.CHECKOUT);
+      if (!isUnifiedCheckout) {
+        const authElement = this.elements.get(ELEMENT_TYPES.AUTH);
+        if (authElement && !this.accessToken) {
+          this.debug("[cimplify:checkout] BLOCKED: auth incomplete");
+          this.checkoutInProgress = false;
+          return toCheckoutError(
+            "AUTH_INCOMPLETE",
+            "Authentication must complete before checkout can start.",
+            true
+          );
+        }
+        const addressElement = this.elements.get(ELEMENT_TYPES.ADDRESS);
+        if (addressElement) {
+          this.debug("[cimplify:checkout] getting address data...");
+          await addressElement.getData();
+          this.debug("[cimplify:checkout] address data resolved", this.addressData);
+        }
+        await this.hydrateCustomerData();
+      }
+      this.debug("[cimplify:checkout] customer data hydrated", { customerData: this.customerData, accountId: this.accountId, isUnifiedCheckout });
+      const processMessage = {
+        type: MESSAGE_TYPES.PROCESS_CHECKOUT,
+        cart_id: options.cart_id,
+        order_type: options.order_type,
+        location_id: options.location_id,
+        notes: options.notes,
+        scheduled_time: options.scheduled_time,
+        tip_amount: options.tip_amount,
+        pay_currency: options.pay_currency,
+        enroll_in_link: options.enroll_in_link ?? true,
+        address: isUnifiedCheckout ? void 0 : this.addressData ?? void 0,
+        customer: isUnifiedCheckout ? void 0 : this.customerData ? {
+          name: this.customerData.name,
+          email: this.customerData.email,
+          phone: this.customerData.phone
+        } : null,
+        account_id: this.accountId ?? void 0,
+        customer_id: this.customerId ?? void 0
+      };
+      const timeoutMs = options.timeout_ms ?? 18e4;
+      const paymentWindow = checkoutElement.getContentWindow();
+      return new Promise((resolve) => {
+        let settled = false;
+        const cleanup = () => {
+          if (typeof window !== "undefined") {
+            window.removeEventListener("message", handleCheckoutMessage);
+          }
+          clearTimeout(timeout);
+          this.checkoutInProgress = false;
+          this.activeCheckoutAbort = null;
+        };
+        const settle = (result) => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          cleanup();
+          resolve(result);
+        };
+        const timeout = setTimeout(() => {
+          settle(
+            toCheckoutError(
+              "TIMEOUT",
+              "Checkout timed out before receiving a terminal response.",
+              true
+            )
+          );
+        }, timeoutMs);
+        const handleCheckoutMessage = (event) => {
+          if (!isAllowedOrigin(event.origin)) {
+            return;
+          }
+          const message = parseIframeMessage(event.data);
+          if (!message) {
+            return;
+          }
+          if (message.type === MESSAGE_TYPES.LOGOUT_COMPLETE) {
+            checkoutElement.sendMessage({ type: MESSAGE_TYPES.ABORT_CHECKOUT });
+            settle(
+              toCheckoutError(
+                "AUTH_LOST",
+                "Authentication was cleared during checkout.",
+                true
+              )
+            );
+            return;
+          }
+          if (paymentWindow && event.source && event.source !== paymentWindow) {
+            return;
+          }
+          if (message.type === MESSAGE_TYPES.CHECKOUT_STATUS) {
+            options.on_status_change?.(message.status, message.context);
+            return;
+          }
+          if (message.type === MESSAGE_TYPES.CHECKOUT_COMPLETE) {
+            this.debug("[cimplify:checkout] received checkout_complete", { success: message.success, error: message.error });
+            settle({
+              success: message.success,
+              order: message.order,
+              error: message.error,
+              enrolled_in_link: message.enrolled_in_link
+            });
+          }
+        };
+        if (typeof window !== "undefined") {
+          window.addEventListener("message", handleCheckoutMessage);
+        }
+        abortFn = () => {
+          checkoutElement.sendMessage({ type: MESSAGE_TYPES.ABORT_CHECKOUT });
+          settle(
+            toCheckoutError(
+              "CANCELLED",
+              "Checkout was cancelled.",
+              true
+            )
+          );
+        };
+        this.activeCheckoutAbort = abortFn;
+        this.debug("[cimplify:checkout] sending process_checkout to checkout iframe", { cart_id: processMessage.cart_id, order_type: processMessage.order_type, hasCustomer: !!processMessage.customer, hasAddress: !!processMessage.address, isUnifiedCheckout });
+        checkoutElement.sendMessage(processMessage);
+        this.debug("[cimplify:checkout] postMessage sent, waiting for checkout_complete...");
+      });
+    })();
+    const abortable = task;
+    abortable.abort = () => {
+      if (abortFn) {
+        abortFn();
+      }
+    };
+    return abortable;
+  }
+  isAuthenticated() {
+    return this.accessToken !== null;
+  }
+  getAccessToken() {
+    return this.accessToken;
+  }
+  getPublicKey() {
+    return this.client.getPublicKey();
+  }
+  getBusinessId() {
+    return this.businessId;
+  }
+  async resolveBusinessId() {
+    if (this.businessId) {
+      return this.businessId;
+    }
+    if (this.businessIdResolvePromise) {
+      return this.businessIdResolvePromise;
+    }
+    this.businessIdResolvePromise = this.client.resolveBusinessId().then((resolvedBusinessId) => {
+      this.businessId = resolvedBusinessId;
+      return resolvedBusinessId;
+    }).catch(() => null).finally(() => {
+      this.businessIdResolvePromise = null;
+    });
+    return this.businessIdResolvePromise;
+  }
+  getAppearance() {
+    return this.options.appearance;
+  }
+  async hydrateCustomerData() {
+    if (!this.accessToken || this.customerData) {
+      return;
+    }
+    if (!this.client.getAccessToken()) {
+      this.client.setAccessToken(this.accessToken);
+    }
+    const linkDataResult = await this.client.link.getLinkData();
+    if (!linkDataResult.ok || !linkDataResult.value?.customer) {
+      return;
+    }
+    const customer = linkDataResult.value.customer;
+    this.customerData = {
+      name: customer.name || "",
+      email: customer.email || null,
+      phone: customer.phone || null
+    };
+  }
+  handleMessage(event) {
+    if (!isAllowedOrigin(event.origin)) {
+      return;
+    }
+    const message = parseIframeMessage(event.data);
+    if (!message) return;
+    switch (message.type) {
+      case MESSAGE_TYPES.AUTHENTICATED:
+        const customer = message.customer ?? {
+          name: "",
+          email: null,
+          phone: null
+        };
+        this.accessToken = message.token;
+        this.accountId = message.accountId;
+        this.customerId = message.customerId;
+        this.customerData = customer;
+        this.client.setAccessToken(message.token);
+        this.elements.forEach((element, type) => {
+          if (type !== ELEMENT_TYPES.AUTH && type !== ELEMENT_TYPES.CHECKOUT) {
+            element.sendMessage({ type: MESSAGE_TYPES.SET_TOKEN, token: message.token });
+          }
+        });
+        break;
+      case MESSAGE_TYPES.TOKEN_REFRESHED:
+        this.accessToken = message.token;
+        break;
+      case MESSAGE_TYPES.ADDRESS_CHANGED:
+      case MESSAGE_TYPES.ADDRESS_SELECTED:
+        this.addressData = message.address;
+        break;
+      case MESSAGE_TYPES.PAYMENT_METHOD_SELECTED:
+        this.paymentData = message.method;
+        break;
+      case MESSAGE_TYPES.CONTACT_PROVIDED:
+        if (!this.customerData) {
+          this.customerData = { name: "", email: null, phone: null };
+        }
+        if (message.contactType === "email") {
+          this.customerData.email = message.contact;
+        } else {
+          this.customerData.phone = message.contact;
+        }
+        break;
+      case MESSAGE_TYPES.LOGOUT_COMPLETE:
+        if (this.checkoutInProgress && this.activeCheckoutAbort) {
+          this.activeCheckoutAbort();
+        }
+        this.accessToken = null;
+        this.accountId = null;
+        this.customerId = null;
+        this.customerData = null;
+        this.addressData = null;
+        this.paymentData = null;
+        this.client.clearSession();
+        break;
+    }
+  }
+  _setAddressData(data) {
+    this.addressData = data;
+  }
+  _setPaymentData(data) {
+    this.paymentData = data;
+  }
+  _setGuestContact(contact, contactType) {
+    if (!this.customerData) {
+      this.customerData = { name: "", email: null, phone: null };
+    }
+    if (contactType === "email") {
+      this.customerData.email = contact;
+    } else {
+      this.customerData.phone = contact;
+    }
+  }
+};
+var CimplifyElement = class {
+  constructor(type, businessId, linkUrl, options, parent) {
+    this.iframe = null;
+    this.container = null;
+    this.mounted = false;
+    this.pendingInit = null;
+    this.eventHandlers = /* @__PURE__ */ new Map();
+    this.resolvers = /* @__PURE__ */ new Map();
+    this.listening = false;
+    this.type = type;
+    this.businessId = businessId;
+    this.linkUrl = linkUrl;
+    this.options = options;
+    this.parent = parent;
+    this.nonce = generateNonce();
+    this.boundHandleMessage = this.handleMessage.bind(this);
+    if (typeof window !== "undefined") {
+      window.addEventListener("message", this.boundHandleMessage);
+      this.listening = true;
+    }
+  }
+  mount(container) {
+    if (this.mounted) {
+      console.warn(`Element ${this.type} is already mounted`);
+      return;
+    }
+    const target = typeof container === "string" ? document.querySelector(container) : container;
+    if (!target) {
+      console.error(`Container not found: ${container}`);
+      return;
+    }
+    this.container = target;
+    this.mounted = true;
+    if (!this.listening && typeof window !== "undefined") {
+      window.addEventListener("message", this.boundHandleMessage);
+      this.listening = true;
+    }
+    void this.createIframe();
+  }
+  destroy() {
+    if (this.iframe) {
+      this.iframe.remove();
+      this.iframe = null;
+    }
+    this.container = null;
+    this.mounted = false;
+    this.eventHandlers.clear();
+    this.resolvers.forEach((entry) => clearTimeout(entry.timeoutId));
+    this.resolvers.clear();
+    if (this.listening && typeof window !== "undefined") {
+      window.removeEventListener("message", this.boundHandleMessage);
+      this.listening = false;
+    }
+    this.parent._removeElement(this.type, this);
+  }
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(event).add(handler);
+  }
+  off(event, handler) {
+    this.eventHandlers.get(event)?.delete(handler);
+  }
+  async getData() {
+    if (!this.isMounted()) {
+      return null;
+    }
+    return new Promise((resolve) => {
+      const id = Math.random().toString(36).slice(2);
+      const timeoutId = setTimeout(() => {
+        const entry = this.resolvers.get(id);
+        if (!entry) {
+          return;
+        }
+        this.resolvers.delete(id);
+        entry.resolve(null);
+      }, 5e3);
+      this.resolvers.set(id, { resolve, timeoutId });
+      this.sendMessage({ type: MESSAGE_TYPES.GET_DATA });
+    });
+  }
+  setCart(cart) {
+    this.sendMessage({ type: MESSAGE_TYPES.SET_CART, cart });
+  }
+  sendMessage(message) {
+    if (this.iframe?.contentWindow) {
+      this.iframe.contentWindow.postMessage(message, this.linkUrl);
+    } else {
+      console.warn("[cimplify:checkout] sendMessage DROPPED \u2014 no contentWindow", { type: message.type, hasIframe: !!this.iframe, isConnected: this.iframe?.isConnected });
+    }
+  }
+  getContentWindow() {
+    return this.iframe?.contentWindow ?? null;
+  }
+  isMounted() {
+    return this.mounted && Boolean(this.iframe) && this.iframe?.isConnected === true;
+  }
+  async createIframe() {
+    if (!this.container) return;
+    const resolvedBusinessId = this.businessId ?? await this.parent.resolveBusinessId();
+    if (!resolvedBusinessId || !this.container || !this.mounted) {
+      console.error("Unable to mount element without a resolved business ID");
+      this.emit(EVENT_TYPES.ERROR, {
+        code: "BUSINESS_ID_REQUIRED",
+        message: "Unable to initialize checkout without a business ID."
+      });
+      return;
+    }
+    this.businessId = resolvedBusinessId;
+    const iframe = document.createElement("iframe");
+    const url = new URL(`${this.linkUrl}/elements/${this.type}`);
+    url.searchParams.set("businessId", resolvedBusinessId);
+    url.searchParams.set("nonce", this.nonce);
+    if (this.options.prefillEmail) url.searchParams.set("email", this.options.prefillEmail);
+    if (this.options.mode) url.searchParams.set("mode", this.options.mode);
+    iframe.src = url.toString();
+    iframe.style.border = "none";
+    iframe.style.width = "100%";
+    iframe.style.minHeight = "200px";
+    iframe.style.display = "block";
+    iframe.style.overflow = "hidden";
+    iframe.style.background = "transparent";
+    iframe.setAttribute("allowtransparency", "true");
+    iframe.setAttribute("frameborder", "0");
+    iframe.setAttribute("allow", "geolocation");
+    iframe.setAttribute(
+      "sandbox",
+      "allow-scripts allow-same-origin allow-forms allow-popups allow-popups-to-escape-sandbox"
+    );
+    this.iframe = iframe;
+    this.container.appendChild(iframe);
+    this.pendingInit = {
+      businessId: resolvedBusinessId,
+      publicKey: this.parent.getPublicKey()
+    };
+  }
+  handleMessage(event) {
+    if (!isAllowedOrigin(event.origin)) {
+      return;
+    }
+    const data = event.data;
+    if (data?.nonce) {
+      if (data.nonce !== this.nonce) return;
+    } else {
+      const iframeWindow = this.iframe?.contentWindow;
+      if (iframeWindow && event.source && event.source !== iframeWindow) {
+        return;
+      }
+    }
+    const message = parseIframeMessage(event.data);
+    if (!message) return;
+    switch (message.type) {
+      case MESSAGE_TYPES.READY:
+        if (this.iframe && message.height) this.iframe.style.height = `${message.height}px`;
+        if (this.pendingInit) {
+          const { publicKey } = this.pendingInit;
+          this.sendMessage({
+            type: MESSAGE_TYPES.INIT,
+            businessId: this.pendingInit.businessId,
+            publicKey,
+            demoMode: publicKey.length === 0,
+            prefillEmail: this.options.prefillEmail,
+            appearance: this.parent.getAppearance(),
+            orderTypes: this.options.orderTypes,
+            defaultOrderType: this.options.defaultOrderType,
+            renderSubmitButton: true,
+            submitLabel: this.options.submitLabel
+          });
+          const token = this.parent.getAccessToken();
+          if (token && this.type !== ELEMENT_TYPES.AUTH) {
+            this.sendMessage({ type: MESSAGE_TYPES.SET_TOKEN, token });
+          }
+          this.pendingInit = null;
+        }
+        this.emit(EVENT_TYPES.READY, { height: message.height });
+        break;
+      case MESSAGE_TYPES.HEIGHT_CHANGE:
+        if (this.iframe) this.iframe.style.height = `${message.height}px`;
+        break;
+      case MESSAGE_TYPES.AUTHENTICATED:
+        const customer = message.customer ?? {
+          name: "",
+          email: null,
+          phone: null
+        };
+        this.emit(EVENT_TYPES.AUTHENTICATED, {
+          accountId: message.accountId,
+          customerId: message.customerId,
+          token: message.token,
+          customer
+        });
+        break;
+      case MESSAGE_TYPES.REQUIRES_OTP:
+        this.emit(EVENT_TYPES.REQUIRES_OTP, { contactMasked: message.contactMasked });
+        break;
+      case MESSAGE_TYPES.ERROR:
+        this.emit(EVENT_TYPES.ERROR, { code: message.code, message: message.message });
+        break;
+      case MESSAGE_TYPES.ADDRESS_CHANGED:
+      case MESSAGE_TYPES.ADDRESS_SELECTED:
+        this.parent._setAddressData(message.address);
+        this.emit(EVENT_TYPES.CHANGE, { address: message.address });
+        this.resolveData(message.address);
+        break;
+      case MESSAGE_TYPES.PAYMENT_METHOD_SELECTED:
+        this.parent._setPaymentData(message.method);
+        this.emit(EVENT_TYPES.CHANGE, { paymentMethod: message.method });
+        this.resolveData(message.method);
+        break;
+      case MESSAGE_TYPES.CONTACT_PROVIDED:
+        this.parent._setGuestContact(message.contact, message.contactType);
+        break;
+      case MESSAGE_TYPES.ORDER_TYPE_CHANGED:
+        this.emit(EVENT_TYPES.ORDER_TYPE_CHANGED, { orderType: message.orderType });
+        break;
+      case MESSAGE_TYPES.REQUEST_SUBMIT:
+        this.emit(EVENT_TYPES.REQUEST_SUBMIT, {});
+        break;
+    }
+  }
+  emit(event, data) {
+    this.eventHandlers.get(event)?.forEach((handler) => handler(data));
+  }
+  resolveData(data) {
+    this.resolvers.forEach((entry) => {
+      clearTimeout(entry.timeoutId);
+      entry.resolve(data);
+    });
+    this.resolvers.clear();
+  }
+};
+function createElements(client, businessId, options) {
+  return new CimplifyElements(client, businessId, options);
+}
+
+exports.AUTHORIZATION_TYPE = AUTHORIZATION_TYPE;
+exports.AUTH_MUTATION = AUTH_MUTATION;
+exports.AuthService = AuthService;
+exports.BusinessService = BusinessService;
+exports.CHECKOUT_MODE = CHECKOUT_MODE;
+exports.CHECKOUT_MUTATION = CHECKOUT_MUTATION;
+exports.CHECKOUT_STEP = CHECKOUT_STEP;
+exports.CONTACT_TYPE = CONTACT_TYPE;
+exports.CartOperations = CartOperations;
+exports.CatalogueQueries = CatalogueQueries;
+exports.CheckoutService = CheckoutService;
+exports.CimplifyElement = CimplifyElement;
+exports.CimplifyElements = CimplifyElements;
+exports.DEFAULT_COUNTRY = DEFAULT_COUNTRY;
+exports.DEFAULT_CURRENCY = DEFAULT_CURRENCY;
+exports.DEVICE_TYPE = DEVICE_TYPE;
+exports.ELEMENT_TYPES = ELEMENT_TYPES;
+exports.EVENT_TYPES = EVENT_TYPES;
+exports.FxService = FxService;
+exports.InventoryService = InventoryService;
+exports.LINK_MUTATION = LINK_MUTATION;
+exports.LINK_QUERY = LINK_QUERY;
+exports.LinkService = LinkService;
+exports.LiteService = LiteService;
+exports.MESSAGE_TYPES = MESSAGE_TYPES;
+exports.MOBILE_MONEY_PROVIDER = MOBILE_MONEY_PROVIDER;
+exports.ORDER_MUTATION = ORDER_MUTATION;
+exports.ORDER_TYPE = ORDER_TYPE;
+exports.OrderQueries = OrderQueries;
+exports.PAYMENT_METHOD = PAYMENT_METHOD;
+exports.PAYMENT_MUTATION = PAYMENT_MUTATION;
+exports.PAYMENT_STATE = PAYMENT_STATE;
+exports.PICKUP_TIME_TYPE = PICKUP_TIME_TYPE;
+exports.SchedulingService = SchedulingService;
+exports.combine = combine;
+exports.combineObject = combineObject;
+exports.createElements = createElements;
+exports.err = err;
+exports.flatMap = flatMap;
+exports.fromPromise = fromPromise;
+exports.generateIdempotencyKey = generateIdempotencyKey;
+exports.getOrElse = getOrElse;
+exports.isErr = isErr;
+exports.isOk = isOk;
+exports.mapError = mapError;
+exports.mapResult = mapResult;
+exports.ok = ok;
+exports.toNullable = toNullable;
+exports.tryCatch = tryCatch;
+exports.unwrap = unwrap;