@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-OMTVH334.js

@@ -0,0 +1,3779 @@
+'use strict';
+
+var chunkGTJWQAGU_js = require('./chunk-GTJWQAGU.js');
+var chunkDFZWHNRG_js = require('./chunk-DFZWHNRG.js');
+var chunkUCR5HRYM_js = require('./chunk-UCR5HRYM.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 {
+    let 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) {
+  let values = [];
+  for (let result of results) {
+    if (!result.ok)
+      return result;
+    values.push(result.value);
+  }
+  return ok(values);
+}
+function combineObject(results) {
+  let values = {};
+  for (let [key, result] of Object.entries(results)) {
+    if (!result.ok)
+      return result;
+    values[key] = result.value;
+  }
+  return ok(values);
+}
+
+// src/internal/idempotency.ts
+function generateIdempotencyKey(prefix = "idem") {
+  if (typeof crypto < "u" && crypto.randomUUID)
+    return `${prefix}_${crypto.randomUUID()}`;
+  let timestamp = Date.now().toString(36), random = Math.random().toString(36).substring(2, 15);
+  return `${prefix}_${timestamp}_${random}`;
+}
+var INTENT_PREFIX = "cimplify-intent:";
+function sessionStorageOrNull() {
+  try {
+    return typeof window < "u" ? window.sessionStorage : null;
+  } catch {
+    return null;
+  }
+}
+function intentIdempotencyKey(scope, fingerprint, storage = sessionStorageOrNull()) {
+  let slot = INTENT_PREFIX + scope;
+  try {
+    let raw = storage?.getItem(slot);
+    if (raw) {
+      let stored = JSON.parse(raw);
+      if (stored.fingerprint === fingerprint && typeof stored.key == "string") return stored.key;
+    }
+  } catch {
+  }
+  let key = generateIdempotencyKey();
+  try {
+    storage?.setItem(slot, JSON.stringify({ key, fingerprint }));
+  } catch {
+  }
+  return key;
+}
+function clearIntentIdempotencyKey(scope, storage = sessionStorageOrNull()) {
+  try {
+    storage?.removeItem(INTENT_PREFIX + scope);
+  } catch {
+  }
+}
+
+// src/internal/safe.ts
+function toCimplifyError(error) {
+  return error instanceof chunkUCR5HRYM_js.CimplifyError ? chunkUCR5HRYM_js.enrichError(error) : error instanceof Error ? chunkUCR5HRYM_js.enrichError(new chunkUCR5HRYM_js.CimplifyError(chunkUCR5HRYM_js.ErrorCode.UNKNOWN_ERROR, error.message, false)) : chunkUCR5HRYM_js.enrichError(new chunkUCR5HRYM_js.CimplifyError(chunkUCR5HRYM_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) {
+  let query = new URLSearchParams();
+  for (let [key, value] of Object.entries(params))
+    value !== void 0 && query.set(key, String(value));
+  let queryString = query.toString();
+  return queryString ? `${path}?${queryString}` : path;
+}
+function isRecord(value) {
+  return typeof value == "object" && value !== null;
+}
+function readFinalPrice(value) {
+  if (!isRecord(value)) return;
+  let finalPrice = value.final_price;
+  if (typeof finalPrice == "string" || typeof finalPrice == "number")
+    return finalPrice;
+}
+function needsDefaultPriceNormalization(value) {
+  return value == null || value === "";
+}
+function optionNeedsNormalization(option) {
+  return isRecord(option) && needsDefaultPriceNormalization(option.default_price);
+}
+function addOnNeedsNormalization(addOn) {
+  if (!isRecord(addOn)) return false;
+  let options = addOn.options;
+  return Array.isArray(options) && options.some((option) => optionNeedsNormalization(option));
+}
+function normalizeAddOnPayload(addOn) {
+  if (!isRecord(addOn)) return addOn;
+  let options = addOn.options;
+  if (!Array.isArray(options) || !options.some((option) => optionNeedsNormalization(option))) return addOn;
+  let normalizedAddOn = { ...addOn };
+  return normalizedAddOn.options = options.map((option) => {
+    if (!isRecord(option) || !optionNeedsNormalization(option)) return option;
+    let normalizedOption = { ...option }, optionPrice = normalizedOption.default_price;
+    return needsDefaultPriceNormalization(optionPrice) && (normalizedOption.default_price = readFinalPrice(normalizedOption.default_price_info) || readFinalPrice(normalizedOption.price_info) || "0"), normalizedOption;
+  }), normalizedAddOn;
+}
+function normalizeCatalogueProductPayload(product) {
+  let productRecord = product, defaultPrice = productRecord.default_price, addOns = productRecord.add_ons, needsPriceFix = needsDefaultPriceNormalization(defaultPrice), needsAddOnFix = Array.isArray(addOns) && addOns.some((addOn) => addOnNeedsNormalization(addOn));
+  if (!needsPriceFix && !needsAddOnFix)
+    return product;
+  let normalized = { ...productRecord };
+  if (needsPriceFix) {
+    let 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";
+  }
+  return needsAddOnFix && Array.isArray(addOns) && (normalized.add_ons = addOns.map((addOn) => normalizeAddOnPayload(addOn))), normalized;
+}
+function toFiniteNumber(value) {
+  if (typeof value == "number" && Number.isFinite(value))
+    return value;
+  if (typeof value == "string" && value.trim().length > 0) {
+    let parsed = Number(value);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+}
+function normalizePagination(value) {
+  if (!isRecord(value))
+    return;
+  let totalCount = toFiniteNumber(value.total_count), currentPage = toFiniteNumber(value.current_page), pageSize = toFiniteNumber(value.page_size), totalPages = toFiniteNumber(value.total_pages);
+  if (!(totalCount === void 0 || currentPage === void 0 || pageSize === void 0 || totalPages === 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) {
+  return Array.isArray(payload) ? {
+    items: payload.map((product) => normalizeCatalogueProductPayload(product)),
+    is_complete: true
+  } : isRecord(payload) ? {
+    items: (Array.isArray(payload.products) ? payload.products : Array.isArray(payload.items) ? payload.items : []).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)
+  } : {
+    items: [],
+    is_complete: true
+  };
+}
+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
+    };
+  let rawProducts = Array.isArray(payload.products) ? payload.products : Array.isArray(payload.items) ? payload.items : [], rawCategories = Array.isArray(payload.categories) ? payload.categories : [], 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(opts) {
+    let result = await safe(
+      this.client.get("/api/v1/catalogue", opts)
+    );
+    return result.ok ? ok(normalizeCatalogueSnapshot(result.value)) : result;
+  }
+  async getProducts(options, opts) {
+    let 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
+    }), result = await safe(this.client.get(path, opts));
+    return result.ok ? ok(normalizeCatalogueResult(result.value)) : result;
+  }
+  async getProduct(id, opts) {
+    let encodedId = encodeURIComponent(id), result = await safe(
+      this.client.get(`/api/v1/catalogue/products/${encodedId}`, opts)
+    );
+    if (!result.ok) return result;
+    let payload = result.value, rawProduct = isRecord(payload.item) ? payload.item : payload, product = normalizeCatalogueProductPayload(rawProduct);
+    isRecord(payload.category) && (product.category = payload.category);
+    let addOnIds = rawProduct.add_on_ids;
+    if (Array.isArray(addOnIds) && addOnIds.length > 0) {
+      let addOnsResult = await this.getAddOns(product.id, opts);
+      addOnsResult.ok && (product.add_ons = addOnsResult.value);
+    }
+    return ok(product);
+  }
+  async getProductBySlug(slug, opts) {
+    return this.getProduct(slug, opts);
+  }
+  async getVariants(productId) {
+    let encodedId = encodeURIComponent(productId);
+    return safe(
+      this.client.get(`/api/v1/catalogue/products/${encodedId}/variants`)
+    );
+  }
+  async getVariantAxes(productId) {
+    let encodedId = encodeURIComponent(productId);
+    return safe(
+      this.client.get(`/api/v1/catalogue/products/${encodedId}/variant-axes`)
+    );
+  }
+  async getVariantByAxisSelections(productId, selections) {
+    let encodedId = encodeURIComponent(productId);
+    return safe(
+      this.client.post(
+        `/api/v1/catalogue/products/${encodedId}/variants/find`,
+        { axis_selections: selections }
+      )
+    );
+  }
+  async getVariantById(productId, variantId) {
+    let encodedProductId = encodeURIComponent(productId), encodedVariantId = encodeURIComponent(variantId);
+    return safe(
+      this.client.get(
+        `/api/v1/catalogue/products/${encodedProductId}/variants/${encodedVariantId}`
+      )
+    );
+  }
+  async getAddOns(productId, opts) {
+    let encodedId = encodeURIComponent(productId);
+    return safe(this.client.get(`/api/v1/catalogue/products/${encodedId}/add-ons`, opts));
+  }
+  async getCategories(opts) {
+    return safe(this.client.get("/api/v1/catalogue/categories", opts));
+  }
+  async getCategory(id, opts) {
+    let encodedId = encodeURIComponent(id);
+    return safe(this.client.get(`/api/v1/catalogue/categories/${encodedId}`, opts));
+  }
+  async getCategoryBySlug(slug, opts) {
+    return this.getCategory(slug, opts);
+  }
+  async getCategoryProducts(categoryId, options, opts) {
+    let encodedId = encodeURIComponent(categoryId), path = withQuery(`/api/v1/catalogue/categories/${encodedId}/products`, {
+      limit: options?.limit,
+      offset: options?.offset
+    });
+    return safe(this.client.get(path, opts));
+  }
+  async getCollections(opts) {
+    return safe(this.client.get("/api/v1/catalogue/collections", opts));
+  }
+  async getCollection(id, opts) {
+    let encodedId = encodeURIComponent(id);
+    return safe(this.client.get(`/api/v1/catalogue/collections/${encodedId}`, opts));
+  }
+  async getCollectionBySlug(slug, opts) {
+    return this.getCollection(slug, opts);
+  }
+  async getCollectionProducts(collectionId, options, opts) {
+    let encodedId = encodeURIComponent(collectionId), path = withQuery(`/api/v1/catalogue/collections/${encodedId}/products`, {
+      limit: options?.limit,
+      offset: options?.offset
+    });
+    return safe(this.client.get(path, opts));
+  }
+  async searchCollections(query, limit = 20) {
+    let 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 getBundle(id) {
+    let encodedId = encodeURIComponent(id);
+    return safe(this.client.get(`/api/v1/catalogue/bundles/${encodedId}`));
+  }
+  async getBundleBySlug(slug) {
+    return this.getBundle(slug);
+  }
+  async searchBundles(query, limit = 20) {
+    let path = withQuery("/api/v1/catalogue/bundles", { search: query, limit });
+    return safe(this.client.get(path));
+  }
+  async getComposites(options) {
+    let path = withQuery("/api/v1/catalogue/composites", { limit: options?.limit });
+    return safe(this.client.get(path));
+  }
+  async getComposite(id) {
+    let encodedId = encodeURIComponent(id);
+    return safe(this.client.get(`/api/v1/catalogue/composites/${encodedId}`));
+  }
+  async getCompositeByProduct(productId) {
+    let encodedId = encodeURIComponent(productId);
+    return safe(this.client.get(`/api/v1/catalogue/composites/by-product/${encodedId}`));
+  }
+  async calculateCompositePrice(compositeId, selections, locationId) {
+    let encodedId = encodeURIComponent(compositeId);
+    return safe(
+      this.client.post(
+        `/api/v1/catalogue/composites/${encodedId}/calculate-price`,
+        {
+          selections,
+          location_id: locationId
+        }
+      )
+    );
+  }
+  async fetchQuote(input, opts) {
+    let idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
+    return safe(
+      this.client.post("/api/v1/catalogue/quotes", input, { idempotencyKey })
+    );
+  }
+  async getQuote(quoteId) {
+    let encodedQuoteId = encodeURIComponent(quoteId);
+    return safe(this.client.get(`/api/v1/catalogue/quotes/${encodedQuoteId}`));
+  }
+  async refreshQuote(input) {
+    let encodedQuoteId = encodeURIComponent(input.quote_id);
+    return safe(
+      this.client.post(
+        `/api/v1/catalogue/quotes/${encodedQuoteId}/refresh`,
+        input
+      )
+    );
+  }
+  async getTaxonomies(parentId) {
+    let path = withQuery("/api/v1/catalogue/taxonomies", { parent_id: parentId });
+    return safe(this.client.get(path));
+  }
+  async getTaxonomy(id) {
+    let encodedId = encodeURIComponent(id);
+    return safe(this.client.get(`/api/v1/catalogue/taxonomies/${encodedId}`));
+  }
+  async getTaxonomyPath(id) {
+    let encodedId = encodeURIComponent(id);
+    return safe(
+      this.client.get(`/api/v1/catalogue/taxonomies/${encodedId}/path`)
+    );
+  }
+  async searchTaxonomies(query, limit) {
+    let path = withQuery("/api/v1/catalogue/taxonomies/search", { q: query, limit });
+    return safe(this.client.get(path));
+  }
+  async getEligibleBillingPlans(productId, query) {
+    let encodedId = encodeURIComponent(productId), path = withQuery(`/api/v1/catalogue/products/${encodedId}/billing-plans/eligible`, {
+      customer_id: query?.customer_id,
+      quantity: query?.quantity,
+      order_value: query?.order_value
+    });
+    return safe(this.client.get(path));
+  }
+  async getProductSchedules(productId) {
+    let encodedId = encodeURIComponent(productId);
+    return safe(
+      this.client.get(`/api/v1/catalogue/products/${encodedId}/schedules`)
+    );
+  }
+  async checkProductAvailableNow(productId, locationId) {
+    let encodedId = encodeURIComponent(productId), path = withQuery(`/api/v1/catalogue/products/${encodedId}/available-now`, {
+      location_id: locationId
+    });
+    return safe(this.client.get(path));
+  }
+  async getDeals(locationId) {
+    let 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) {
+    let encodedId = encodeURIComponent(productId);
+    return safe(this.client.get(`/api/v1/catalogue/products/${encodedId}/deals`));
+  }
+  async getCategoryDeals(categoryId) {
+    let encodedId = encodeURIComponent(categoryId);
+    return safe(this.client.get(`/api/v1/catalogue/categories/${encodedId}/deals`));
+  }
+  async getCollectionDeals(collectionId) {
+    let 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, opts) {
+    let result = await this.getProducts(
+      {
+        ...options,
+        search: query,
+        limit: options?.limit ?? 20
+      },
+      opts
+    );
+    return result.ok ? ok(result.value.items) : result;
+  }
+  async searchProducts(query, options, opts) {
+    return this.search(query, options, opts);
+  }
+  async getMenu(options) {
+    let path = withQuery("/api/v1/catalogue/menu", {
+      category_id: options?.category,
+      limit: options?.limit
+    });
+    return safe(this.client.get(path));
+  }
+  async getMenuCategory(categoryId) {
+    let encodedId = encodeURIComponent(categoryId);
+    return safe(this.client.get(`/api/v1/catalogue/menu/categories/${encodedId}`));
+  }
+  async getMenuItem(itemId) {
+    let encodedId = encodeURIComponent(itemId);
+    return safe(this.client.get(`/api/v1/catalogue/menu/items/${encodedId}`));
+  }
+  async getTags(options) {
+    let 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(namespace) {
+    let params = namespace ? `?namespace=${encodeURIComponent(namespace)}` : "";
+    return safe(
+      this.client.get(`/api/v1/catalogue/attributes${params}`)
+    );
+  }
+  async getProductAttributes(productId) {
+    let encodedId = encodeURIComponent(productId);
+    return safe(
+      this.client.get(`/api/v1/catalogue/products/${encodedId}/attributes`)
+    );
+  }
+  async getCategoryAttributes(categoryId) {
+    let encodedId = encodeURIComponent(categoryId);
+    return safe(
+      this.client.get(
+        `/api/v1/catalogue/categories/${encodedId}/attributes`
+      )
+    );
+  }
+  async getCollectionAttributes(collectionId) {
+    let encodedId = encodeURIComponent(collectionId);
+    return safe(
+      this.client.get(
+        `/api/v1/catalogue/collections/${encodedId}/attributes`
+      )
+    );
+  }
+  async getPropertyFacets(options) {
+    let 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) {
+    let encodedId = encodeURIComponent(taxonomyId);
+    return safe(
+      this.client.get(
+        `/api/v1/catalogue/taxonomies/${encodedId}/attributes`
+      )
+    );
+  }
+  async searchKnowledge(query, limit) {
+    let path = withQuery("/api/v1/catalogue/knowledge-base/search", {
+      q: query,
+      limit: limit ?? 5
+    });
+    return safe(this.client.get(path));
+  }
+  async getKnowledgeArticles() {
+    return safe(this.client.get("/api/v1/catalogue/knowledge-base/articles"));
+  }
+};
+
+// src/cart.ts
+function lineItemToCartInput(item) {
+  let config = item.configuration, input = {
+    item_id: item.product_id,
+    quantity: item.quantity
+  };
+  return config.variant && (input.variant_id = config.variant.variant_id), config.add_ons && config.add_ons.selected_options.length > 0 && (input.add_on_options = config.add_ons.selected_options.map((o) => o.option_id)), config.type === "bundle" ? input.bundle_selections = config.input : config.type === "composite" && (input.composite_selections = config.input), input;
+}
+var CartOperations = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async get() {
+    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 quoteDestination(input) {
+    return safe(this.client.post("/api/v1/cart/destination-quote", input));
+  }
+  async getSummary() {
+    let cartResult = await this.get();
+    if (!cartResult.ok) return cartResult;
+    let 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, opts) {
+    let idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
+    return safe(
+      this.client.post("/api/v1/cart/items", input, { idempotencyKey })
+    );
+  }
+  async updateItem(cartItemId, updates) {
+    return typeof updates.quantity != "number" ? {
+      ok: false,
+      error: new chunkUCR5HRYM_js.CimplifyError(
+        "VALIDATION_ERROR",
+        "updateItem requires a quantity; richer mid-cart edits are not supported"
+      )
+    } : this.updateQuantity(cartItemId, updates.quantity);
+  }
+  async updateQuantity(cartItemId, quantity) {
+    let encodedId = encodeURIComponent(cartItemId);
+    return safe(
+      this.client.patch(`/api/v1/cart/items/${encodedId}`, {
+        quantity
+      })
+    );
+  }
+  async removeItem(cartItemId) {
+    let 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, opts) {
+    let idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
+    return safe(
+      this.client.post(
+        "/api/v1/cart/coupons",
+        { coupon_code: code },
+        { idempotencyKey }
+      )
+    );
+  }
+  async removeCoupon() {
+    return safe(this.client.delete("/api/v1/cart/coupons/current"));
+  }
+  async reorderFromOrder(orderId) {
+    let orderResult = await this.client.orders.get(orderId);
+    if (!orderResult.ok) return orderResult;
+    let order = orderResult.value;
+    if (!order.items || order.items.length === 0)
+      return ok({ added: [], failed: [] });
+    let added = [], failed = [];
+    for (let item of order.items) {
+      let input = lineItemToCartInput(item), result = await this.addItem(input);
+      result.ok ? added.push({ item_id: input.item_id }) : failed.push({ item_id: input.item_id, error: result.error });
+    }
+    return ok({ added, failed });
+  }
+  async isEmpty() {
+    let countResult = await this.getCount();
+    return countResult.ok ? ok(countResult.value === 0) : countResult;
+  }
+  async hasItem(productId, variantId) {
+    let itemsResult = await this.getItems();
+    if (!itemsResult.ok) return itemsResult;
+    let found = itemsResult.value.some((item) => {
+      let matchesProduct = item.item_id === productId;
+      if (!variantId) return matchesProduct;
+      let config = item.configuration;
+      return "variant" in config && config.variant ? matchesProduct && config.variant.variant_id === variantId : matchesProduct;
+    });
+    return ok(found);
+  }
+  async findItem(productId, variantId) {
+    let itemsResult = await this.getItems();
+    if (!itemsResult.ok) return itemsResult;
+    let found = itemsResult.value.find((item) => {
+      let matchesProduct = item.item_id === productId;
+      if (!variantId) return matchesProduct;
+      let config = item.configuration;
+      return "variant" in config && config.variant ? matchesProduct && config.variant.variant_id === variantId : matchesProduct;
+    });
+    return ok(found);
+  }
+};
+
+// src/payment-authorization/types.ts
+var PAYMENT_AUTHORIZATION_OUTCOME_STATUS = {
+  SUBMITTED: "submitted",
+  CANCELLED: "cancelled",
+  FAILED: "failed"
+}, PAYMENT_AUTHORIZATION_PROVIDER = {
+  PAYSTACK: "paystack",
+  STRIPE: "stripe"
+};
+
+// src/payment-authorization/providers/paystack.ts
+var PAYSTACK_POPUP_ERROR = {
+  PROVIDER_UNAVAILABLE: chunkUCR5HRYM_js.ErrorCode.PROVIDER_UNAVAILABLE,
+  SUBMISSION_UNKNOWN: "SUBMISSION_UNKNOWN",
+  CANCELLED: "CANCELLED",
+  PAYMENT_CANCELLED: chunkUCR5HRYM_js.ErrorCode.PAYMENT_CANCELLED,
+  PAYMENT_FAILED: chunkUCR5HRYM_js.ErrorCode.PAYMENT_FAILED,
+  POPUP_BLOCKED: chunkUCR5HRYM_js.ErrorCode.POPUP_BLOCKED
+};
+async function openPaystackPopup(options, signal) {
+  if (typeof window > "u")
+    return { success: false, error: PAYSTACK_POPUP_ERROR.PROVIDER_UNAVAILABLE };
+  let PaystackPop;
+  try {
+    PaystackPop = (await import('@paystack/inline-js')).default;
+  } catch {
+    return { success: false, error: PAYSTACK_POPUP_ERROR.PROVIDER_UNAVAILABLE };
+  }
+  return new Promise((resolve) => {
+    let settled = false, providerStarted = false, resolveOnce = (result) => {
+      settled || (settled = true, signal && signal.removeEventListener("abort", onAbort), resolve(result));
+    }, onAbort = () => {
+      resolveOnce({
+        success: false,
+        // Once Paystack owns the transaction, cancellation is ambiguous. The
+        // adapter converts this into submitted so Cimplify polling decides.
+        error: providerStarted ? PAYSTACK_POPUP_ERROR.SUBMISSION_UNKNOWN : PAYSTACK_POPUP_ERROR.CANCELLED
+      });
+    };
+    if (signal?.aborted) {
+      resolveOnce({ success: false, error: PAYSTACK_POPUP_ERROR.CANCELLED });
+      return;
+    }
+    signal && signal.addEventListener("abort", onAbort, { once: true });
+    try {
+      new PaystackPop().newTransaction({
+        key: options.key,
+        email: options.email,
+        amount: options.amount,
+        currency: options.currency,
+        reference: options.reference,
+        accessCode: options.accessCode,
+        onSuccess: (transaction) => {
+          resolveOnce({
+            success: !0,
+            reference: transaction.reference ?? options.reference
+          });
+        },
+        onCancel: () => {
+          resolveOnce({ success: !1, error: PAYSTACK_POPUP_ERROR.PAYMENT_CANCELLED });
+        },
+        onError: (error) => {
+          resolveOnce({
+            success: !1,
+            error: error?.message || PAYSTACK_POPUP_ERROR.PAYMENT_FAILED
+          });
+        }
+      }), providerStarted = !0;
+    } catch {
+      resolveOnce({ success: false, error: PAYSTACK_POPUP_ERROR.POPUP_BLOCKED });
+    }
+  });
+}
+var PaystackAuthorizationAdapter = class {
+  constructor(openPopup = openPaystackPopup) {
+    this.openPopup = openPopup;
+    this.provider = PAYMENT_AUTHORIZATION_PROVIDER.PAYSTACK;
+  }
+  async authorize(context) {
+    let result = await this.openPopup(
+      {
+        key: context.action.public_key,
+        email: context.email,
+        accessCode: context.action.client_secret,
+        reference: context.reference || context.action.client_secret,
+        currency: context.currency
+      },
+      context.signal
+    );
+    return result.success ? {
+      status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.SUBMITTED,
+      reference: result.reference || context.reference
+    } : result.error === PAYSTACK_POPUP_ERROR.SUBMISSION_UNKNOWN ? {
+      status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.SUBMITTED,
+      reference: context.reference
+    } : !result.error || result.error === PAYSTACK_POPUP_ERROR.CANCELLED || result.error === PAYSTACK_POPUP_ERROR.PAYMENT_CANCELLED ? { status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.CANCELLED } : result.error === PAYSTACK_POPUP_ERROR.POPUP_BLOCKED ? {
+      status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
+      code: chunkUCR5HRYM_js.ErrorCode.POPUP_BLOCKED,
+      message: "Unable to open the Paystack payment popup. Please allow popups and try again.",
+      recoverable: true
+    } : result.error === PAYSTACK_POPUP_ERROR.PROVIDER_UNAVAILABLE ? {
+      status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
+      code: chunkUCR5HRYM_js.ErrorCode.PROVIDER_UNAVAILABLE,
+      message: "Paystack is unavailable in this environment.",
+      recoverable: false
+    } : {
+      status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
+      code: chunkUCR5HRYM_js.ErrorCode.PAYMENT_FAILED,
+      message: result.error || "Paystack payment could not be submitted.",
+      recoverable: true
+    };
+  }
+};
+
+// src/payment-authorization/providers/stripe.ts
+var STRIPE_REDIRECT_MODE = "if_required", STRIPE_PAYMENT_ELEMENT_TYPE = "payment";
+async function loadStripeFromPeer(publicKey, options) {
+  try {
+    let imported = await import('@stripe/stripe-js');
+    return imported.loadStripe ? imported.loadStripe(publicKey, options) : null;
+  } catch {
+    return null;
+  }
+}
+function createStripeModal() {
+  if (typeof document > "u" || !document.body) return null;
+  let previousFocus = document.activeElement instanceof HTMLElement ? document.activeElement : null, root = document.createElement("div");
+  root.setAttribute("role", "dialog"), root.setAttribute("aria-modal", "true"), root.setAttribute("aria-label", "Secure card payment"), Object.assign(root.style, {
+    position: "fixed",
+    inset: "0",
+    zIndex: "2147483647",
+    display: "grid",
+    placeItems: "center",
+    padding: "16px",
+    background: "rgba(15, 23, 42, 0.58)"
+  });
+  let form = document.createElement("form");
+  Object.assign(form.style, {
+    width: "min(100%, 480px)",
+    maxHeight: "calc(100vh - 32px)",
+    overflow: "auto",
+    borderRadius: "12px",
+    padding: "24px",
+    background: "#fff",
+    boxShadow: "0 24px 80px rgba(15, 23, 42, 0.32)"
+  });
+  let title = document.createElement("h2");
+  title.textContent = "Complete card payment", Object.assign(title.style, { margin: "0 0 18px", font: "600 18px/1.4 system-ui" });
+  let paymentMount = document.createElement("div");
+  paymentMount.setAttribute("data-cimplify-stripe-payment-element", "");
+  let error = document.createElement("p");
+  error.setAttribute("role", "alert"), Object.assign(error.style, {
+    minHeight: "20px",
+    margin: "14px 0 0",
+    color: "#b91c1c",
+    font: "14px/1.4 system-ui"
+  });
+  let actions = document.createElement("div");
+  Object.assign(actions.style, {
+    display: "flex",
+    justifyContent: "flex-end",
+    gap: "10px",
+    marginTop: "18px"
+  });
+  let cancelButton = document.createElement("button");
+  cancelButton.type = "button", cancelButton.textContent = "Cancel", Object.assign(cancelButton.style, {
+    border: "1px solid #cbd5e1",
+    borderRadius: "8px",
+    padding: "10px 16px",
+    background: "#fff",
+    color: "#0f172a",
+    cursor: "pointer"
+  });
+  let submitButton = document.createElement("button");
+  return submitButton.type = "submit", submitButton.textContent = "Pay securely", Object.assign(submitButton.style, {
+    border: "0",
+    borderRadius: "8px",
+    padding: "10px 16px",
+    background: "#0f172a",
+    color: "#fff",
+    cursor: "pointer"
+  }), actions.append(cancelButton, submitButton), form.append(title, paymentMount, error, actions), root.append(form), document.body.append(root), cancelButton.focus(), { root, form, paymentMount, submitButton, cancelButton, error, previousFocus };
+}
+function stripeFailure(error) {
+  let message = error?.message || "Stripe could not authorize this payment.";
+  return error?.code === "payment_intent_authentication_failure" || error?.type === "invalid_request_error" ? {
+    status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
+    code: chunkUCR5HRYM_js.ErrorCode.AUTHORIZATION_FAILED,
+    message,
+    recoverable: true
+  } : {
+    status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
+    code: chunkUCR5HRYM_js.ErrorCode.PAYMENT_FAILED,
+    message,
+    recoverable: true
+  };
+}
+var StripeAuthorizationAdapter = class {
+  constructor(loadStripe = loadStripeFromPeer) {
+    this.loadStripe = loadStripe;
+    this.provider = PAYMENT_AUTHORIZATION_PROVIDER.STRIPE;
+  }
+  async authorize(context) {
+    if (typeof window > "u" || typeof document > "u" || context.signal?.aborted)
+      return context.signal?.aborted ? { status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.CANCELLED } : {
+        status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
+        code: chunkUCR5HRYM_js.ErrorCode.PROVIDER_UNAVAILABLE,
+        message: "Stripe Payment Element is unavailable in this environment.",
+        recoverable: false
+      };
+    let stripe;
+    try {
+      stripe = await this.loadStripe(
+        context.action.public_key,
+        context.action.provider_account_id ? { stripeAccount: context.action.provider_account_id } : void 0
+      );
+    } catch (error) {
+      return {
+        status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
+        code: chunkUCR5HRYM_js.ErrorCode.PROVIDER_UNAVAILABLE,
+        message: error instanceof Error ? error.message : "Stripe.js could not be loaded.",
+        recoverable: true
+      };
+    }
+    if (context.signal?.aborted)
+      return { status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.CANCELLED };
+    if (!stripe)
+      return {
+        status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
+        code: chunkUCR5HRYM_js.ErrorCode.PROVIDER_UNAVAILABLE,
+        message: "Stripe.js could not be loaded.",
+        recoverable: false
+      };
+    let modal = createStripeModal();
+    if (!modal)
+      return {
+        status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
+        code: chunkUCR5HRYM_js.ErrorCode.PROVIDER_UNAVAILABLE,
+        message: "Stripe Payment Element could not be mounted.",
+        recoverable: false
+      };
+    let paymentElement, elements;
+    try {
+      elements = stripe.elements({ clientSecret: context.action.client_secret }), paymentElement = elements.create(STRIPE_PAYMENT_ELEMENT_TYPE), paymentElement.mount(modal.paymentMount);
+    } catch {
+      return modal.root.remove(), modal.previousFocus?.focus(), {
+        status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
+        code: chunkUCR5HRYM_js.ErrorCode.PROVIDER_UNAVAILABLE,
+        message: "Stripe Payment Element could not be initialized.",
+        recoverable: false
+      };
+    }
+    return context.signal?.aborted ? (paymentElement.destroy ? paymentElement.destroy() : paymentElement.unmount?.(), modal.root.remove(), modal.previousFocus?.focus(), { status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.CANCELLED }) : new Promise((resolve) => {
+      let settled = false, submitting = false, confirmationStarted = false, cleanup = () => {
+        context.signal?.removeEventListener("abort", onAbort), modal.form.removeEventListener("submit", onSubmit), modal.cancelButton.removeEventListener("click", onCancel), paymentElement.destroy ? paymentElement.destroy() : paymentElement.unmount?.(), modal.root.remove(), modal.previousFocus?.focus();
+      }, settle = (outcome) => {
+        settled || (settled = true, cleanup(), resolve(outcome));
+      }, onAbort = () => {
+        if (confirmationStarted) {
+          settle({
+            status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.SUBMITTED,
+            reference: context.reference
+          });
+          return;
+        }
+        settle({ status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.CANCELLED });
+      }, onCancel = () => {
+        confirmationStarted || settle({ status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.CANCELLED });
+      }, onSubmit = async (event) => {
+        if (event.preventDefault(), !(submitting || settled)) {
+          submitting = true, modal.submitButton.disabled = true, modal.error.textContent = "";
+          try {
+            let validation = elements.submit ? await elements.submit() : {};
+            if (validation.error) {
+              modal.error.textContent = validation.error.message || "Check your payment details.", submitting = !1, modal.submitButton.disabled = !1;
+              return;
+            }
+            if (settled || context.signal?.aborted) {
+              settle({ status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.CANCELLED });
+              return;
+            }
+            confirmationStarted = !0, modal.cancelButton.disabled = !0;
+            let confirmation = await stripe.confirmPayment({
+              elements,
+              confirmParams: { return_url: context.returnUrl || window.location.href },
+              redirect: STRIPE_REDIRECT_MODE
+            });
+            if (settled) return;
+            if (confirmation.error) {
+              settle(stripeFailure(confirmation.error));
+              return;
+            }
+            settle({
+              status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.SUBMITTED,
+              reference: confirmation.paymentIntent?.id || context.reference
+            });
+          } catch (error) {
+            if (confirmationStarted) {
+              settle({
+                status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.SUBMITTED,
+                reference: context.reference
+              });
+              return;
+            }
+            settle(
+              stripeFailure({
+                message: error instanceof Error ? error.message : "Stripe confirmation failed."
+              })
+            );
+          }
+        }
+      };
+      modal.form.addEventListener("submit", onSubmit), modal.cancelButton.addEventListener("click", onCancel), context.signal?.addEventListener("abort", onAbort, { once: true }), paymentElement.on?.("escape", onCancel), paymentElement.on?.("loaderror", (event) => {
+        confirmationStarted || settle({
+          status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
+          code: chunkUCR5HRYM_js.ErrorCode.PROVIDER_UNAVAILABLE,
+          message: event?.error?.message || "Stripe Payment Element failed to load.",
+          recoverable: true
+        });
+      });
+    });
+  }
+};
+
+// src/payment-authorization/registry.ts
+function normalizeProvider(provider) {
+  return typeof provider == "string" ? provider.trim().toLowerCase() : "";
+}
+var PaymentAuthorizationAdapterRegistry = class {
+  constructor(adapters = []) {
+    this.adapters = /* @__PURE__ */ new Map();
+    for (let adapter of adapters)
+      this.register(adapter);
+  }
+  register(adapter) {
+    let provider = normalizeProvider(adapter.provider);
+    if (!provider)
+      throw new TypeError("Payment authorization adapter provider cannot be empty.");
+    return this.adapters.set(provider, adapter), this;
+  }
+  unregister(provider) {
+    return this.adapters.delete(normalizeProvider(provider));
+  }
+  get(provider) {
+    return this.adapters.get(normalizeProvider(provider));
+  }
+  supports(provider) {
+    return this.adapters.has(normalizeProvider(provider));
+  }
+  providers() {
+    return [...this.adapters.keys()];
+  }
+  async authorize(action, options) {
+    let provider = normalizeProvider(action.provider);
+    if (!provider)
+      return {
+        status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
+        code: chunkUCR5HRYM_js.ErrorCode.PROVIDER_UNAVAILABLE,
+        message: "Card authorization response did not identify a payment provider.",
+        recoverable: false
+      };
+    let adapter = this.adapters.get(provider);
+    if (!adapter)
+      return {
+        status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
+        code: chunkUCR5HRYM_js.ErrorCode.PROVIDER_UNAVAILABLE,
+        message: `Card authorization provider '${provider}' is not supported by this SDK client.`,
+        recoverable: false
+      };
+    try {
+      let normalizedAction = action.provider === provider ? action : { ...action, provider };
+      return await adapter.authorize({ ...options, action: normalizedAction });
+    } catch (error) {
+      return {
+        status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
+        code: chunkUCR5HRYM_js.ErrorCode.PAYMENT_FAILED,
+        message: error instanceof Error ? error.message : `Card authorization provider '${provider}' failed unexpectedly.`,
+        recoverable: true
+      };
+    }
+  }
+};
+function createDefaultPaymentAuthorizationAdapterRegistry() {
+  return new PaymentAuthorizationAdapterRegistry([
+    new PaystackAuthorizationAdapter(),
+    new StripeAuthorizationAdapter()
+  ]);
+}
+
+// src/utils/purchase-intent-confirmation.ts
+var EXACT_ZERO_MONEY = /^[+-]?0+(?:\.0+)?(?:[eE][+-]?\d+)?$/;
+function isExactlyZeroMoney(value) {
+  return typeof value == "number" ? Object.is(value, 0) || Object.is(value, -0) : EXACT_ZERO_MONEY.test(value.trim());
+}
+function selectPurchaseIntentPaymentOption(terms, selection) {
+  return terms.payment_options.filter((option) => option.status === chunkUCR5HRYM_js.PAYMENT_OPTION_STATUS.ELIGIBLE).sort((left, right) => left.rank - right.rank).find(
+    (option) => option.method_kind === selection.method_kind && (selection.payment_option_id === void 0 || option.id === selection.payment_option_id)
+  );
+}
+function createPurchaseIntentConfirmation(terms, paymentOption, idempotencyKey) {
+  let normalizedKey = idempotencyKey.trim();
+  if (!normalizedKey) throw new TypeError("idempotencyKey must not be empty");
+  let requiresOption = purchaseIntentRequiresPaymentOption(terms);
+  if (!paymentOption && requiresOption)
+    throw new TypeError("Nonzero rail terms require an eligible payment option");
+  if (paymentOption && !requiresOption)
+    throw new TypeError("Zero-rail terms must not name a payment option");
+  let authoritativeOption = paymentOption ? terms.payment_options.find(
+    (candidate) => candidate.id === paymentOption.id && candidate.status === chunkUCR5HRYM_js.PAYMENT_OPTION_STATUS.ELIGIBLE
+  ) : void 0;
+  if (paymentOption && !authoritativeOption)
+    throw new TypeError("Payment option is not eligible for these checkout terms");
+  return {
+    accepted_intent_revision: terms.intent_revision,
+    accepted_terms_version: terms.terms_version,
+    accepted_due_now: terms.money.due_now,
+    // Rail fees and routes may differ by option. Consent is to the exact
+    // server-issued buyer debit, never an ambiguous principal/fee aggregate.
+    accepted_customer_debit_amount: authoritativeOption?.customer_debit_amount ?? terms.money.rail_amount,
+    currency: terms.money.currency,
+    payment_option_id: authoritativeOption?.id ?? null,
+    idempotency_key: normalizedKey
+  };
+}
+function purchaseIntentRequiresPaymentOption(terms) {
+  return terms.payment_options.length > 0 || !isExactlyZeroMoney(terms.money.rail_amount);
+}
+var PLAIN_DECIMAL = /^([+-]?)(\d+)(?:\.(\d+))?$/;
+function canonicalDecimal(value) {
+  let match = PLAIN_DECIMAL.exec(typeof value == "number" ? String(value) : value.trim());
+  if (!match) return null;
+  let whole = match[2].replace(/^0+(?=\d)/, ""), fraction = (match[3] ?? "").replace(/0+$/, ""), isZero = whole === "0" && fraction === "";
+  return `${match[1] === "-" && !isZero ? "-" : ""}${whole}${fraction ? `.${fraction}` : ""}`;
+}
+function isSameAmount(left, right) {
+  let canonicalLeft = canonicalDecimal(left);
+  return canonicalLeft !== null && canonicalLeft === canonicalDecimal(right);
+}
+function confirmationForUnchangedReplacement(response, selection, idempotencyKey) {
+  let { replacement, deltas } = response, paymentDeltas = deltas.filter(
+    (delta2) => delta2.kind === chunkUCR5HRYM_js.CHECKOUT_TERMS_DELTA_KIND.PAYMENT_OPTION
+  );
+  if (paymentDeltas.length !== deltas.length) return null;
+  if (!purchaseIntentRequiresPaymentOption(replacement))
+    return paymentDeltas.length === 0 ? createPurchaseIntentConfirmation(replacement, null, idempotencyKey) : null;
+  if (!selection || paymentDeltas.length !== 1) return null;
+  let option = selectPurchaseIntentPaymentOption(replacement, {
+    method_kind: selection.method_kind
+  }), [delta] = paymentDeltas;
+  return !option || delta.kind !== chunkUCR5HRYM_js.CHECKOUT_TERMS_DELTA_KIND.PAYMENT_OPTION || !isSameAmount(option.customer_debit_amount, delta.accepted_customer_debit_amount) ? null : createPurchaseIntentConfirmation(replacement, option, idempotencyKey);
+}
+
+// src/utils/purchase-intent-adapter.ts
+function tenderPreference(form) {
+  if (form.payment_method === chunkUCR5HRYM_js.PURCHASE_INTENT_PAYMENT_METHOD.MOBILE_MONEY) {
+    if (form.link_payment_method_id)
+      return {
+        method_kind: chunkUCR5HRYM_js.PURCHASE_INTENT_PAYMENT_METHOD.MOBILE_MONEY,
+        authority: {
+          authority_kind: chunkUCR5HRYM_js.MOBILE_MONEY_TENDER_AUTHORITY_KIND.SAVED_REFERENCE,
+          stored_instrument_id: form.link_payment_method_id
+        }
+      };
+    let details = form.mobile_money_details;
+    if (!details?.phone_number || !details.provider)
+      throw new chunkUCR5HRYM_js.CimplifyError(
+        chunkUCR5HRYM_js.ErrorCode.INVALID_PAYMENT_METHOD,
+        "Mobile money requires a phone number and network.",
+        false
+      );
+    let network = chunkDFZWHNRG_js.purchaseIntentMobileMoneyNetwork(details.provider);
+    if (!network)
+      throw new chunkUCR5HRYM_js.CimplifyError(
+        chunkUCR5HRYM_js.ErrorCode.INVALID_PAYMENT_METHOD,
+        "That mobile money network is not available for PurchaseIntent checkout.",
+        false
+      );
+    return {
+      method_kind: chunkUCR5HRYM_js.PURCHASE_INTENT_PAYMENT_METHOD.MOBILE_MONEY,
+      authority: {
+        authority_kind: chunkUCR5HRYM_js.MOBILE_MONEY_TENDER_AUTHORITY_KIND.TRANSIENT,
+        phone_number: details.phone_number,
+        network
+      }
+    };
+  }
+  if (form.payment_method === chunkUCR5HRYM_js.LEGACY_CHECKOUT_PAYMENT_METHOD_ALIAS.CASH || form.payment_method === chunkUCR5HRYM_js.PURCHASE_INTENT_PAYMENT_METHOD.OFFLINE)
+    throw new chunkUCR5HRYM_js.CimplifyError(
+      chunkUCR5HRYM_js.ErrorCode.INVALID_PAYMENT_METHOD,
+      "Offline tender requires an authenticated staff checkout.",
+      false
+    );
+  if (form.payment_method === chunkUCR5HRYM_js.PURCHASE_INTENT_PAYMENT_METHOD.CARD)
+    return {
+      method_kind: chunkUCR5HRYM_js.PURCHASE_INTENT_PAYMENT_METHOD.CARD,
+      stored_instrument_id: form.link_payment_method_id
+    };
+  if (form.payment_method !== chunkUCR5HRYM_js.LEGACY_CHECKOUT_PAYMENT_METHOD_ALIAS.STORE_CREDIT)
+    throw new chunkUCR5HRYM_js.CimplifyError(
+      chunkUCR5HRYM_js.ErrorCode.INVALID_PAYMENT_METHOD,
+      "Checkout payment method is not supported.",
+      false
+    );
+}
+function checkoutFormToIntentRequest(form, clientIntentKey) {
+  return {
+    client_intent_key: clientIntentKey,
+    source: { kind: chunkUCR5HRYM_js.PURCHASE_INTENT_SOURCE_KIND.CART, cart_id: form.cart_id },
+    checkout: {
+      customer: form.customer,
+      order_type: form.order_type,
+      address_info: form.address_info,
+      location_id: form.location_id,
+      delivery_rate_id: form.delivery_rate_id,
+      special_instructions: form.special_instructions,
+      link_address_id: form.link_address_id,
+      metadata: form.metadata,
+      pay_currency: form.pay_currency,
+      fx_quote_id: form.fx_quote_id,
+      use_store_credit: form.use_store_credit || form.payment_method === chunkUCR5HRYM_js.LEGACY_CHECKOUT_PAYMENT_METHOD_ALIAS.STORE_CREDIT,
+      voucher_code: form.voucher_code,
+      pay_deposit: form.pay_deposit,
+      tender_preference: tenderPreference(form)
+    }
+  };
+}
+function selectCheckoutPaymentOption(terms, form) {
+  let preference = tenderPreference(form);
+  if (preference)
+    return terms.payment_options.filter((option) => option.status === chunkUCR5HRYM_js.PAYMENT_OPTION_STATUS.ELIGIBLE).sort((left, right) => left.rank - right.rank).find((option) => option.method_kind === preference.method_kind);
+}
+function checkoutFormToConfirmation(_form, terms, paymentOption, idempotencyKey) {
+  return createPurchaseIntentConfirmation(terms, paymentOption, idempotencyKey);
+}
+function committedBase(response) {
+  return {
+    intent_id: response.intent_id,
+    attempt_id: response.attempt_id,
+    order_id: response.order_id,
+    order_number: response.order_number || response.order_id,
+    payment_id: response.payment_id
+  };
+}
+function confirmationToCheckoutResult(response) {
+  switch (response.status) {
+    case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.ORDER_CREATED:
+      return ok({
+        ...committedBase(response),
+        payment_status: chunkUCR5HRYM_js.LEGACY_CHECKOUT_PAYMENT_STATUS.SUCCEEDED,
+        requires_authorization: false,
+        next_action: { type: chunkGTJWQAGU_js.CHECKOUT_NEXT_ACTION.NONE }
+      });
+    case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.COLLECTION_PROCESSING:
+      return ok({
+        ...committedBase(response),
+        payment_status: chunkUCR5HRYM_js.LEGACY_CHECKOUT_PAYMENT_STATUS.PROCESSING,
+        requires_authorization: false,
+        next_action: { type: chunkGTJWQAGU_js.CHECKOUT_NEXT_ACTION.POLL }
+      });
+    case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.PAYMENT_OUTCOME_UNKNOWN:
+      return ok({
+        ...committedBase(response),
+        payment_status: chunkUCR5HRYM_js.LEGACY_CHECKOUT_PAYMENT_STATUS.UNKNOWN,
+        requires_authorization: false,
+        next_action: { type: chunkGTJWQAGU_js.CHECKOUT_NEXT_ACTION.POLL }
+      });
+    case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.PAYMENT_FAILED:
+      return err(
+        new chunkUCR5HRYM_js.CimplifyError(
+          chunkUCR5HRYM_js.PURCHASE_INTENT_ERROR_CODE.PAYMENT_FAILED,
+          "Payment failed. The order remains recorded, but collection did not succeed.",
+          true
+        )
+      );
+    case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.REDIRECT_REQUIRED:
+      return ok({
+        ...committedBase(response),
+        payment_status: chunkUCR5HRYM_js.LEGACY_CHECKOUT_PAYMENT_STATUS.REQUIRES_ACTION,
+        requires_authorization: false,
+        authorization_url: response.authorization_url,
+        next_action: {
+          type: chunkGTJWQAGU_js.CHECKOUT_NEXT_ACTION.REDIRECT,
+          authorization_url: response.authorization_url
+        }
+      });
+    case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.CARD_POPUP_REQUIRED:
+      return ok({
+        ...committedBase(response),
+        payment_status: chunkUCR5HRYM_js.LEGACY_CHECKOUT_PAYMENT_STATUS.REQUIRES_ACTION,
+        requires_authorization: false,
+        provider: response.provider,
+        client_secret: response.client_secret,
+        public_key: response.public_key,
+        next_action: {
+          type: chunkGTJWQAGU_js.CHECKOUT_NEXT_ACTION.CARD_POPUP,
+          provider: response.provider,
+          client_secret: response.client_secret,
+          public_key: response.public_key,
+          provider_account_id: response.provider_account_id ?? void 0
+        }
+      });
+    case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.AUTHORIZATION_REQUIRED:
+      return ok({
+        ...committedBase(response),
+        payment_status: chunkUCR5HRYM_js.LEGACY_CHECKOUT_PAYMENT_STATUS.REQUIRES_ACTION,
+        requires_authorization: true,
+        authorization_type: response.authorization_type,
+        display_text: response.display_text,
+        next_action: {
+          type: chunkGTJWQAGU_js.CHECKOUT_NEXT_ACTION.AUTHORIZATION,
+          authorization_type: response.authorization_type,
+          display_text: response.display_text
+        }
+      });
+    case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.TERMS_CHANGED:
+      return err(
+        new chunkUCR5HRYM_js.CimplifyError(
+          chunkUCR5HRYM_js.PURCHASE_INTENT_ERROR_CODE.TERMS_CHANGED,
+          "Checkout terms changed. Review the replacement terms before confirming again.",
+          true
+        )
+      );
+    case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.SELECTION_UNAVAILABLE:
+      return err(
+        new chunkUCR5HRYM_js.CimplifyError(
+          chunkUCR5HRYM_js.PURCHASE_INTENT_ERROR_CODE.SELECTION_UNAVAILABLE,
+          "One or more checkout selections are no longer available.",
+          true
+        )
+      );
+    case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.OFFER_ENDED:
+      return err(
+        new chunkUCR5HRYM_js.CimplifyError(
+          chunkUCR5HRYM_js.PURCHASE_INTENT_ERROR_CODE.OFFER_ENDED,
+          "This offer has ended.",
+          false
+        )
+      );
+    case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.SOURCE_UNAVAILABLE:
+      return err(
+        new chunkUCR5HRYM_js.CimplifyError(
+          chunkUCR5HRYM_js.PURCHASE_INTENT_ERROR_CODE.SOURCE_UNAVAILABLE,
+          "This purchase source is unavailable.",
+          false
+        )
+      );
+  }
+}
+
+// src/checkout.ts
+function checkoutActionAuthority(response) {
+  if (response.status !== chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.CARD_POPUP_REQUIRED && response.status !== chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.AUTHORIZATION_REQUIRED)
+    return null;
+  let paymentId = response.payment_id?.trim();
+  return paymentId ? {
+    intentId: response.intent_id,
+    attemptId: response.attempt_id,
+    paymentId
+  } : null;
+}
+function isAmbiguousCheckoutError(error) {
+  return error.code === chunkUCR5HRYM_js.ErrorCode.NETWORK_ERROR || error.code === chunkUCR5HRYM_js.ErrorCode.TIMEOUT;
+}
+function authorizationKind(value) {
+  if (value && typeof value == "object" && chunkGTJWQAGU_js.AUTHORIZATION_TYPE.ADDRESS in value)
+    return chunkGTJWQAGU_js.AUTHORIZATION_TYPE.ADDRESS;
+  if (value === chunkGTJWQAGU_js.AUTHORIZATION_TYPE.OTP || value === chunkGTJWQAGU_js.AUTHORIZATION_TYPE.PIN || value === chunkGTJWQAGU_js.AUTHORIZATION_TYPE.PHONE || value === chunkGTJWQAGU_js.AUTHORIZATION_TYPE.BIRTHDAY)
+    return value;
+}
+function normalizeAuthorizationSubmission(expected, submission) {
+  if (submission.type !== expected) throw new Error(`Expected ${expected} authorization details.`);
+  if (submission.type === chunkGTJWQAGU_js.AUTHORIZATION_TYPE.ADDRESS) {
+    let address = submission.address.trim(), city = submission.city.trim(), state = submission.state.trim(), zipCode = submission.zip_code.trim();
+    if (!address || !city || !state || !zipCode)
+      throw new Error("Complete all authorization address fields.");
+    return { type: chunkGTJWQAGU_js.AUTHORIZATION_TYPE.ADDRESS, address, city, state, zip_code: zipCode };
+  }
+  let value = submission.value.trim();
+  if (!value) throw new Error("Authorization value is required.");
+  return { type: submission.type, value };
+}
+var DECIMAL_WIRE_VALUE = /^([+-]?)(\d+)(?:\.(\d+))?(?:[eE][+-]?\d+)?$/;
+function decimalSign(value) {
+  if (typeof value == "number")
+    return Number.isFinite(value) ? Object.is(value, 0) || Object.is(value, -0) ? 0 : value > 0 ? 1 : -1 : null;
+  let match = DECIMAL_WIRE_VALUE.exec(value.trim());
+  return match ? [...match[2], ...match[3] ?? ""].some((digit) => digit !== "0") ? match[1] === "-" ? -1 : 1 : 0 : null;
+}
+function toTerminalFailure(code, message, recoverable) {
+  return {
+    success: false,
+    error: {
+      code,
+      message,
+      recoverable
+    }
+  };
+}
+function isValidCustomerName(name) {
+  let trimmed = (name ?? "").trim();
+  return trimmed.length >= 2 && /\p{L}/u.test(trimmed);
+}
+function isOfflinePaymentMethod(method) {
+  return method === chunkUCR5HRYM_js.LEGACY_CHECKOUT_PAYMENT_METHOD_ALIAS.CASH || method === chunkUCR5HRYM_js.PURCHASE_INTENT_PAYMENT_METHOD.OFFLINE;
+}
+function notifyCheckoutStatus(observer, status, context = {}) {
+  try {
+    observer?.(status, context);
+  } catch {
+  }
+}
+function notifyAuthorizationUi(observer, open) {
+  try {
+    observer?.(open);
+  } catch {
+  }
+}
+var MAX_STOREFRONT_COLLECTION_OPTIONS = 32, CHECKOUT_INTENT_SCOPE_PREFIX = "checkout:", CHECKOUT_CONFIRMATION_SCOPE_PREFIX = "checkout-confirm:", CHECKOUT_INTENT_RECOVERY_FINGERPRINT = "cart-intent-v1", ABORT_ERROR_NAME = "AbortError", AUTHORIZATION_POPUP_NAME = "cimplify-auth", AUTHORIZATION_POPUP_FEATURES = "width=520,height=760", ORDER_TOKEN_QUERY_PARAMETER = "token", CHECKOUT_API_ROUTE = {
+  COLLECTION_OPTIONS: "/api/v1/payments/collection-options",
+  paymentStatus: (orderId) => `/api/v1/orders/${orderId}/payment-status`,
+  updateCustomer: (orderId) => `/api/v1/orders/${orderId}/customer`,
+  verifyPayment: (orderId) => `/api/v1/orders/${orderId}/verify-payment`
+}, CHECKOUT_STATUS_BY_PURCHASE_INTENT_RESOLVE_STATUS = {
+  [chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLVE_STATUS.CONFIRMING]: chunkGTJWQAGU_js.CHECKOUT_STATUS.PROCESSING,
+  [chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLVE_STATUS.POLLING]: chunkGTJWQAGU_js.CHECKOUT_STATUS.POLLING,
+  [chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLVE_STATUS.RECONNECTING]: chunkGTJWQAGU_js.CHECKOUT_STATUS.POLLING,
+  [chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLVE_STATUS.AWAITING_ACTION]: chunkGTJWQAGU_js.CHECKOUT_STATUS.AWAITING_AUTHORIZATION,
+  [chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLVE_STATUS.REVIEWING_TERMS]: chunkGTJWQAGU_js.CHECKOUT_STATUS.REVIEWING_TERMS,
+  [chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLVE_STATUS.COMPLETED]: chunkGTJWQAGU_js.CHECKOUT_STATUS.FINALIZING,
+  [chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLVE_STATUS.FAILED]: chunkGTJWQAGU_js.CHECKOUT_STATUS.FAILED,
+  [chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLVE_STATUS.OUTCOME_UNKNOWN]: chunkGTJWQAGU_js.CHECKOUT_STATUS.RECOVERING
+};
+function normalizeCollectionOptions(value, expectedCurrency) {
+  if (!value || typeof value != "object") return null;
+  let response = value;
+  if (response.presentment_currency !== expectedCurrency || !Array.isArray(response.options) || response.options.length > (32)) return null;
+  let options = [], seen = /* @__PURE__ */ new Set();
+  for (let candidate of response.options) {
+    if (!candidate || typeof candidate != "object") continue;
+    let option = candidate;
+    if (option.method === chunkGTJWQAGU_js.PAYMENT_METHOD.CARD && option.network == null) {
+      seen.has(chunkGTJWQAGU_js.PAYMENT_METHOD.CARD) || (seen.add(chunkGTJWQAGU_js.PAYMENT_METHOD.CARD), options.push({ method: chunkGTJWQAGU_js.PAYMENT_METHOD.CARD, network: null }));
+      continue;
+    }
+    if (option.method !== chunkGTJWQAGU_js.PAYMENT_METHOD.MOBILE_MONEY || typeof option.network != "string" || !option.network.trim())
+      continue;
+    let network = chunkDFZWHNRG_js.purchaseIntentMobileMoneyNetwork(option.network);
+    if (!network) continue;
+    let key = `${chunkGTJWQAGU_js.PAYMENT_METHOD.MOBILE_MONEY}:${network}`;
+    seen.has(key) || (seen.add(key), options.push({ method: chunkGTJWQAGU_js.PAYMENT_METHOD.MOBILE_MONEY, network }));
+  }
+  return { presentment_currency: expectedCurrency, options };
+}
+var CheckoutService = class {
+  constructor(client) {
+    this.client = client;
+    /** Raw checkout material is component-lifetime only, never browser storage. */
+    this.intentCommands = /* @__PURE__ */ new Map();
+    /** Opaque owner/attempt authority for deprecated action submission. */
+    this.actionAuthorities = /* @__PURE__ */ new Map();
+  }
+  validateCheckoutData(data) {
+    return isOfflinePaymentMethod(data.payment_method) ? new chunkUCR5HRYM_js.CimplifyError(
+      chunkUCR5HRYM_js.ErrorCode.INVALID_PAYMENT_METHOD,
+      "Offline payment isn't available for online checkout. Please pay by card or mobile money.",
+      false
+    ) : isValidCustomerName(data.customer?.name) ? null : new chunkUCR5HRYM_js.CimplifyError(
+      chunkUCR5HRYM_js.ErrorCode.INVALID_CUSTOMER_NAME,
+      "Enter your name, not a phone number.",
+      false
+    );
+  }
+  orderTokenParam(orderId) {
+    let token = this.client.getOrderToken(orderId);
+    return token ? `?${ORDER_TOKEN_QUERY_PARAMETER}=${encodeURIComponent(token)}` : "";
+  }
+  /** Available storefront collection methods for one presentment currency. */
+  async collectionOptions(currency) {
+    let normalized = currency.trim().toUpperCase();
+    if (!chunkUCR5HRYM_js.isSupportedCurrency(normalized))
+      return err(
+        new chunkUCR5HRYM_js.CimplifyError(
+          chunkUCR5HRYM_js.ErrorCode.UNSUPPORTED_CURRENCY,
+          "No online payment method is available for this currency.",
+          false
+        )
+      );
+    let response = await safe(
+      this.client.get(
+        `${CHECKOUT_API_ROUTE.COLLECTION_OPTIONS}?currency=${encodeURIComponent(normalized)}`
+      )
+    );
+    if (!response.ok) return response;
+    let options = normalizeCollectionOptions(response.value, normalized);
+    return options ? ok(options) : err(
+      new chunkUCR5HRYM_js.CimplifyError(
+        chunkUCR5HRYM_js.ErrorCode.PAYMENT_CAPABILITY_MISMATCH,
+        "Payment methods could not be verified for this currency.",
+        false
+      )
+    );
+  }
+  /**
+   * Run provider-owned UI for a backend `card_popup` action. A submitted
+   * outcome is not proof of payment; callers must poll/verify with Cimplify.
+   */
+  authorizeCardPopup(action, options) {
+    return this.client.authorizationAdapters.authorize(action, options);
+  }
+  async startIntentCheckout(data, options) {
+    let invalid = this.validateCheckoutData(data);
+    if (invalid) return err(invalid);
+    let intentScope = `${CHECKOUT_INTENT_SCOPE_PREFIX}${data.cart_id}`, inMemoryCommand = JSON.stringify(data), previousCommand = this.intentCommands.get(intentScope);
+    previousCommand !== void 0 && previousCommand !== inMemoryCommand && clearIntentIdempotencyKey(intentScope), this.intentCommands.set(intentScope, inMemoryCommand);
+    let clientIntentKey = data.idempotency_key || intentIdempotencyKey(intentScope, CHECKOUT_INTENT_RECOVERY_FINGERPRINT), checkoutData = { ...data, idempotency_key: clientIntentKey }, mintRequest;
+    try {
+      mintRequest = checkoutFormToIntentRequest(checkoutData, clientIntentKey);
+    } catch (error) {
+      return clearIntentIdempotencyKey(intentScope), this.intentCommands.delete(intentScope), err(
+        error instanceof chunkUCR5HRYM_js.CimplifyError ? error : new chunkUCR5HRYM_js.CimplifyError(
+          chunkUCR5HRYM_js.ErrorCode.CHECKOUT_VALIDATION_FAILED,
+          "Checkout details are invalid.",
+          false
+        )
+      );
+    }
+    let minted = await this.client.purchaseIntents.mint(mintRequest, options);
+    if (!minted.ok)
+      return isAmbiguousCheckoutError(minted.error) || (clearIntentIdempotencyKey(intentScope), this.intentCommands.delete(intentScope)), minted;
+    let terms = minted.value.current_terms;
+    if (!terms)
+      return clearIntentIdempotencyKey(intentScope), this.intentCommands.delete(intentScope), err(
+        new chunkUCR5HRYM_js.CimplifyError(
+          chunkUCR5HRYM_js.ErrorCode.CHECKOUT_TERMS_UNAVAILABLE,
+          "Checkout terms are not available for this purchase intent.",
+          true
+        )
+      );
+    let paymentOption;
+    try {
+      paymentOption = selectCheckoutPaymentOption(terms, checkoutData);
+    } catch (error) {
+      return err(
+        error instanceof chunkUCR5HRYM_js.CimplifyError ? error : new chunkUCR5HRYM_js.CimplifyError(
+          chunkUCR5HRYM_js.ErrorCode.INVALID_PAYMENT_METHOD,
+          "Payment details are invalid.",
+          false
+        )
+      );
+    }
+    if (!paymentOption && purchaseIntentRequiresPaymentOption(terms))
+      return err(
+        new chunkUCR5HRYM_js.CimplifyError(
+          chunkUCR5HRYM_js.ErrorCode.PAYMENT_CAPABILITY_MISMATCH,
+          "The selected payment method is not eligible for these checkout terms.",
+          true
+        )
+      );
+    let confirmationScope = `${CHECKOUT_CONFIRMATION_SCOPE_PREFIX}${minted.value.id}`, confirmationFingerprint = JSON.stringify([
+      terms.intent_revision,
+      terms.terms_version,
+      terms.terms_digest,
+      paymentOption?.id ?? null,
+      terms.money.due_now,
+      paymentOption?.customer_debit_amount ?? terms.money.rail_amount,
+      terms.money.currency
+    ]), confirmationKey = intentIdempotencyKey(
+      confirmationScope,
+      confirmationFingerprint
+    ), confirmation = checkoutFormToConfirmation(
+      checkoutData,
+      terms,
+      paymentOption,
+      confirmationKey
+    ), confirmed = await this.client.purchaseIntents.confirm(
+      minted.value.id,
+      confirmation,
+      options
+    );
+    return confirmed.ok ? ok({
+      intentId: minted.value.id,
+      intentScope,
+      confirmationScope,
+      confirmation,
+      initialResponse: confirmed.value,
+      terms
+    }) : (isAmbiguousCheckoutError(confirmed.error) || clearIntentIdempotencyKey(confirmationScope), confirmed);
+  }
+  /** @deprecated Use `client.purchaseIntents.mint()` then `confirm()`. */
+  async process(data, options) {
+    let started = await this.startIntentCheckout(data, options);
+    if (!started.ok) return started;
+    this.reconcileActionAuthority(started.value.initialResponse);
+    let result = confirmationToCheckoutResult(started.value.initialResponse);
+    return (started.value.initialResponse.status === chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.ORDER_CREATED || started.value.initialResponse.status === chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.PAYMENT_FAILED) && (clearIntentIdempotencyKey(started.value.intentScope), clearIntentIdempotencyKey(started.value.confirmationScope), this.intentCommands.delete(started.value.intentScope)), result;
+  }
+  async initializePayment(_orderId, _method) {
+    return err(
+      new chunkUCR5HRYM_js.CimplifyError(
+        chunkUCR5HRYM_js.ErrorCode.NOT_IMPLEMENTED,
+        "initializePayment is not available in REST mode.",
+        false
+      )
+    );
+  }
+  /**
+   * @deprecated Use `client.purchaseIntents.submitAction()`. This adapter works
+   * only while this CheckoutService instance retains the opaque authority
+   * returned by its own `process()` call; it never falls back to a payment-id
+   * mutation.
+   */
+  async submitAuthorization(input, options) {
+    let paymentId = input.payment_id.trim(), authority = this.actionAuthorities.get(paymentId);
+    if (!authority)
+      return err(
+        new chunkUCR5HRYM_js.CimplifyError(
+          chunkUCR5HRYM_js.ErrorCode.CHECKOUT_AUTHORITY_REQUIRED,
+          "The purchase-intent action authority is unavailable. Restart checkout before submitting authorization.",
+          false
+        )
+      );
+    let submitted = await this.client.purchaseIntents.submitAction(
+      authority.intentId,
+      authority.attemptId,
+      { authorization: input.authorization },
+      {
+        signal: options?.signal,
+        timeoutMs: options?.timeoutMs
+      }
+    );
+    return submitted.ok ? (this.reconcileActionAuthority(submitted.value, paymentId), confirmationToCheckoutResult(submitted.value)) : submitted;
+  }
+  reconcileActionAuthority(response, previousPaymentId) {
+    previousPaymentId && this.actionAuthorities.delete(previousPaymentId), "payment_id" in response && typeof response.payment_id == "string" && response.payment_id.trim() && this.actionAuthorities.delete(response.payment_id.trim());
+    let authority = checkoutActionAuthority(response);
+    authority && this.actionAuthorities.set(authority.paymentId, authority);
+  }
+  async pollPaymentStatus(orderId, options) {
+    let encodedId = encodeURIComponent(orderId), tokenParam = this.orderTokenParam(orderId);
+    return safe(
+      this.client.get(
+        `${CHECKOUT_API_ROUTE.paymentStatus(encodedId)}${tokenParam}`,
+        options
+      )
+    );
+  }
+  async updateOrderCustomer(orderId, customer) {
+    let encodedId = encodeURIComponent(orderId), tokenParam = this.orderTokenParam(orderId);
+    return safe(
+      this.client.post(`${CHECKOUT_API_ROUTE.updateCustomer(encodedId)}${tokenParam}`, customer)
+    );
+  }
+  async verifyPayment(orderId) {
+    let encodedId = encodeURIComponent(orderId), tokenParam = this.orderTokenParam(orderId);
+    return safe(
+      this.client.post(`${CHECKOUT_API_ROUTE.verifyPayment(encodedId)}${tokenParam}`)
+    );
+  }
+  async maybeEnrollResolvedOrder(orderId, data) {
+    if (data.enroll_in_link !== true) return false;
+    let business = await safe(this.client.resolveBusinessId());
+    if (!business.ok) return false;
+    let address = data.address_info.street_address ? {
+      label: "Default",
+      street_address: data.address_info.street_address,
+      apartment: data.address_info.apartment,
+      city: data.address_info.city ?? "",
+      region: data.address_info.region ?? "",
+      postal_code: data.address_info.postal_code,
+      country: data.address_info.country,
+      delivery_instructions: data.address_info.delivery_instructions,
+      phone_for_delivery: data.address_info.phone_for_delivery,
+      latitude: data.address_info.latitude,
+      longitude: data.address_info.longitude
+    } : void 0;
+    try {
+      let saved = await this.client.link.saveDetails({
+        order_id: orderId,
+        business_id: business.value,
+        address,
+        consent: {
+          copy_version: chunkGTJWQAGU_js.SAVE_DETAILS_CONSENT.COPY_VERSION,
+          channel: chunkGTJWQAGU_js.SAVE_DETAILS_CONSENT.CHANNEL.LINK_ELEMENT
+        }
+      });
+      return saved.ok && saved.value.saved;
+    } catch {
+      return false;
+    }
+  }
+  /** @deprecated Use `client.purchaseIntents.resolve()`. */
+  async processAndResolve(data) {
+    if (notifyCheckoutStatus(data.on_status_change, chunkGTJWQAGU_js.CHECKOUT_STATUS.PREPARING), !data.cart_id)
+      return ok(
+        toTerminalFailure(
+          chunkUCR5HRYM_js.ErrorCode.INVALID_CART,
+          "A valid cart is required before checkout can start.",
+          false
+        )
+      );
+    let cartResult = await this.client.cart.get();
+    if (!cartResult.ok || !cartResult.value?.id)
+      return ok(
+        toTerminalFailure(
+          chunkUCR5HRYM_js.ErrorCode.INVALID_CART,
+          "Unable to load cart for checkout.",
+          false
+        )
+      );
+    let cart = cartResult.value;
+    if (cart.id !== data.cart_id || cart.items.length === 0)
+      return ok(
+        toTerminalFailure(
+          chunkUCR5HRYM_js.ErrorCode.INVALID_CART,
+          "Cart is empty or no longer valid. Please refresh and try again.",
+          false
+        )
+      );
+    let checkoutData = {
+      cart_id: data.cart_id,
+      location_id: data.location_id,
+      customer: data.customer,
+      order_type: data.order_type,
+      address_info: data.address_info,
+      delivery_rate_id: data.delivery_rate_id,
+      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,
+      metadata: data.metadata,
+      pay_currency: data.pay_currency,
+      fx_quote_id: data.fx_quote_id,
+      use_store_credit: data.use_store_credit,
+      voucher_code: data.voucher_code,
+      pay_deposit: data.pay_deposit
+    }, rawBaseCurrency = typeof cart.pricing.currency == "string" ? cart.pricing.currency.trim().toUpperCase() : "";
+    if (!chunkUCR5HRYM_js.isSupportedCurrency(rawBaseCurrency))
+      return ok(
+        toTerminalFailure(
+          chunkUCR5HRYM_js.ErrorCode.UNSUPPORTED_CURRENCY,
+          "Cart currency is missing or unsupported. Refresh the cart before checkout.",
+          false
+        )
+      );
+    let baseCurrency = rawBaseCurrency, payCurrency = data.pay_currency?.trim().toUpperCase();
+    if (payCurrency && !chunkUCR5HRYM_js.isSupportedCurrency(payCurrency))
+      return ok(
+        toTerminalFailure(
+          chunkUCR5HRYM_js.ErrorCode.UNSUPPORTED_CURRENCY,
+          "Payment currency is unsupported for checkout.",
+          false
+        )
+      );
+    let payCurrencyCode = payCurrency && chunkUCR5HRYM_js.isSupportedCurrency(payCurrency) ? payCurrency : void 0, cartTotalSign = decimalSign(cart.pricing.total_price);
+    if (cartTotalSign === null || cartTotalSign < 0)
+      return ok(
+        toTerminalFailure(
+          chunkUCR5HRYM_js.ErrorCode.CHECKOUT_VALIDATION_FAILED,
+          "Cart total is not a valid non-negative decimal amount.",
+          false
+        )
+      );
+    if (payCurrencyCode && payCurrencyCode !== baseCurrency && !checkoutData.fx_quote_id && cartTotalSign > 0) {
+      let fxQuoteResult = await this.client.fx.lockQuote({
+        from: baseCurrency,
+        to: payCurrencyCode,
+        amount: cart.pricing.total_price
+      });
+      if (!fxQuoteResult.ok)
+        return ok(
+          toTerminalFailure(
+            chunkUCR5HRYM_js.ErrorCode.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;
+    }
+    notifyCheckoutStatus(data.on_status_change, chunkGTJWQAGU_js.CHECKOUT_STATUS.PROCESSING);
+    let started = await this.startIntentCheckout(checkoutData, { signal: data.signal });
+    if (!started.ok)
+      return ok(
+        toTerminalFailure(
+          started.error.code || chunkUCR5HRYM_js.ErrorCode.CHECKOUT_FAILED,
+          started.error.message || "Unable to process checkout.",
+          started.error.retryable ?? true
+        )
+      );
+    let actionFailure;
+    try {
+      let resolved = await this.client.purchaseIntents.resolve(started.value.intentId, {
+        confirmation: started.value.confirmation,
+        initialResponse: started.value.initialResponse,
+        pollIntervalMs: data.poll_interval_ms,
+        maxPollAttempts: data.max_poll_attempts,
+        signal: data.signal,
+        onStatusChange: (status, response) => {
+          let context = {};
+          response && "order_id" in response && (context.order_id = response.order_id), response?.status === chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.TERMS_CHANGED && (context.replacement_terms = response.replacement, context.terms_deltas = response.deltas), response?.status === chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.SELECTION_UNAVAILABLE && (context.unavailable_lines = response.lines);
+          let checkoutStatus = CHECKOUT_STATUS_BY_PURCHASE_INTENT_RESOLVE_STATUS[status];
+          notifyCheckoutStatus(data.on_status_change, checkoutStatus, context);
+        },
+        onActionRequired: async (action) => {
+          switch (action.status) {
+            case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.CARD_POPUP_REQUIRED: {
+              if (!(data.allow_popups ?? typeof window < "u"))
+                return actionFailure = {
+                  code: chunkUCR5HRYM_js.ErrorCode.PROVIDER_UNAVAILABLE,
+                  message: "Card authorization UI is unavailable in this environment.",
+                  recoverable: !1
+                }, chunkUCR5HRYM_js.PURCHASE_INTENT_ACTION_DECISION.STOP;
+              let outcome;
+              try {
+                notifyAuthorizationUi(data.on_authorization_ui_change, !0), outcome = await this.authorizeCardPopup(
+                  {
+                    type: chunkGTJWQAGU_js.CHECKOUT_NEXT_ACTION.CARD_POPUP,
+                    provider: action.provider,
+                    client_secret: action.client_secret,
+                    public_key: action.public_key,
+                    provider_account_id: action.provider_account_id ?? void 0
+                  },
+                  {
+                    email: checkoutData.customer.email,
+                    currency: started.value.terms.money.currency,
+                    returnUrl: data.return_url,
+                    signal: data.signal
+                  }
+                );
+              } finally {
+                notifyAuthorizationUi(data.on_authorization_ui_change, !1);
+              }
+              return outcome.status === PAYMENT_AUTHORIZATION_OUTCOME_STATUS.SUBMITTED ? chunkUCR5HRYM_js.PURCHASE_INTENT_ACTION_DECISION.CONTINUE : (actionFailure = outcome.status === PAYMENT_AUTHORIZATION_OUTCOME_STATUS.CANCELLED ? {
+                code: chunkUCR5HRYM_js.ErrorCode.PAYMENT_CANCELLED,
+                message: "Card payment was cancelled before submission.",
+                recoverable: !0
+              } : {
+                code: outcome.code,
+                message: outcome.message,
+                recoverable: outcome.recoverable
+              }, chunkUCR5HRYM_js.PURCHASE_INTENT_ACTION_DECISION.STOP);
+            }
+            case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.REDIRECT_REQUIRED: {
+              let authorizationUrl = chunkDFZWHNRG_js.paymentAuthorizationUrl(action.authorization_url);
+              if (!authorizationUrl)
+                return actionFailure = {
+                  code: chunkUCR5HRYM_js.ErrorCode.AUTHORIZATION_FAILED,
+                  message: "The provider returned an invalid authorization URL.",
+                  recoverable: !1
+                }, chunkUCR5HRYM_js.PURCHASE_INTENT_ACTION_DECISION.STOP;
+              if (typeof window < "u")
+                if (data.allow_popups === !1)
+                  window.location.assign(authorizationUrl);
+                else {
+                  let popup = window.open(
+                    "",
+                    AUTHORIZATION_POPUP_NAME,
+                    AUTHORIZATION_POPUP_FEATURES
+                  );
+                  if (!popup)
+                    return actionFailure = {
+                      code: chunkUCR5HRYM_js.ErrorCode.POPUP_BLOCKED,
+                      message: "Authorization popup was blocked.",
+                      recoverable: !0
+                    }, chunkUCR5HRYM_js.PURCHASE_INTENT_ACTION_DECISION.STOP;
+                  popup.opener = null, popup.location.replace(authorizationUrl);
+                }
+              return actionFailure = {
+                code: chunkUCR5HRYM_js.ErrorCode.REDIRECT_REQUIRED,
+                message: "Complete authorization at the payment provider, then resume checkout.",
+                recoverable: !0
+              }, chunkUCR5HRYM_js.PURCHASE_INTENT_ACTION_DECISION.STOP;
+            }
+            case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.AUTHORIZATION_REQUIRED: {
+              let expected = authorizationKind(action.authorization_type);
+              if (!expected || !data.on_authorization_required)
+                return actionFailure = {
+                  code: chunkUCR5HRYM_js.ErrorCode.AUTHORIZATION_REQUIRED,
+                  message: "Additional payment authorization is required.",
+                  recoverable: !0
+                }, chunkUCR5HRYM_js.PURCHASE_INTENT_ACTION_DECISION.STOP;
+              let submission;
+              return await data.on_authorization_required(expected, async (candidate) => {
+                if (submission) throw new Error("Authorization was already submitted.");
+                submission = normalizeAuthorizationSubmission(expected, candidate);
+              }), submission ? {
+                kind: chunkUCR5HRYM_js.PURCHASE_INTENT_ACTION_DECISION.SUBMIT,
+                request: { authorization: submission }
+              } : (actionFailure = {
+                code: chunkUCR5HRYM_js.ErrorCode.AUTHORIZATION_REQUIRED,
+                message: "Payment authorization was not submitted.",
+                recoverable: !0
+              }, chunkUCR5HRYM_js.PURCHASE_INTENT_ACTION_DECISION.STOP);
+            }
+          }
+        }
+      });
+      if (!resolved.ok)
+        return ok(
+          toTerminalFailure(
+            resolved.error.code || chunkUCR5HRYM_js.ErrorCode.CHECKOUT_FAILED,
+            resolved.error.message || "Unable to resolve checkout.",
+            resolved.error.retryable ?? !0
+          )
+        );
+      switch (resolved.value.kind) {
+        case chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLUTION_KIND.COMPLETED: {
+          clearIntentIdempotencyKey(started.value.intentScope), clearIntentIdempotencyKey(started.value.confirmationScope);
+          let response = resolved.value.response;
+          notifyCheckoutStatus(data.on_status_change, chunkGTJWQAGU_js.CHECKOUT_STATUS.FINALIZING, {
+            order_id: response.order_id
+          });
+          let enrolledInLink = await this.maybeEnrollResolvedOrder(response.order_id, data);
+          return notifyCheckoutStatus(data.on_status_change, chunkGTJWQAGU_js.CHECKOUT_STATUS.SUCCESS, {
+            order_id: response.order_id
+          }), ok({
+            success: !0,
+            order: {
+              id: response.order_id,
+              order_number: response.order_number ?? response.order_id,
+              status: chunkGTJWQAGU_js.CHECKOUT_ORDER_RESULT_STATUS.CONFIRMED,
+              total: String(cart.pricing.total_price),
+              currency: started.value.terms.money.currency
+            },
+            enrolled_in_link: enrolledInLink
+          });
+        }
+        case chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLUTION_KIND.FAILED:
+          return clearIntentIdempotencyKey(started.value.confirmationScope), ok(
+            toTerminalFailure(
+              chunkUCR5HRYM_js.PURCHASE_INTENT_ERROR_CODE.PAYMENT_FAILED,
+              "Payment failed. Choose another method or retry collection.",
+              !0
+            )
+          );
+        case chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLUTION_KIND.OUTCOME_UNKNOWN:
+          return ok(
+            toTerminalFailure(
+              chunkUCR5HRYM_js.ErrorCode.PAYMENT_OUTCOME_UNKNOWN,
+              "Payment outcome is still unknown. Resume this intent before retrying.",
+              !0
+            )
+          );
+        case chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLUTION_KIND.TIMED_OUT:
+          return ok(
+            toTerminalFailure(
+              chunkUCR5HRYM_js.ErrorCode.TIMEOUT,
+              "Payment is still processing. Resume this intent to continue polling.",
+              !0
+            )
+          );
+        case chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLUTION_KIND.ACTION_REQUIRED:
+          return ok(
+            toTerminalFailure(
+              actionFailure?.code ?? chunkUCR5HRYM_js.ErrorCode.AUTHORIZATION_REQUIRED,
+              actionFailure?.message ?? "Checkout requires additional authorization.",
+              actionFailure?.recoverable ?? !0
+            )
+          );
+        case chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLUTION_KIND.REVIEW_REQUIRED:
+          switch (resolved.value.response.status) {
+            case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.TERMS_CHANGED:
+              return ok(
+                toTerminalFailure(
+                  chunkUCR5HRYM_js.PURCHASE_INTENT_ERROR_CODE.TERMS_CHANGED,
+                  "Checkout terms changed and require explicit review.",
+                  !0
+                )
+              );
+            case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.SELECTION_UNAVAILABLE:
+              return ok(
+                toTerminalFailure(
+                  chunkUCR5HRYM_js.PURCHASE_INTENT_ERROR_CODE.SELECTION_UNAVAILABLE,
+                  "One or more checkout selections are unavailable.",
+                  !0
+                )
+              );
+            case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.OFFER_ENDED:
+              return ok(
+                toTerminalFailure(
+                  chunkUCR5HRYM_js.PURCHASE_INTENT_ERROR_CODE.OFFER_ENDED,
+                  "This offer has ended.",
+                  !1
+                )
+              );
+            case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.SOURCE_UNAVAILABLE:
+              return ok(
+                toTerminalFailure(
+                  chunkUCR5HRYM_js.PURCHASE_INTENT_ERROR_CODE.SOURCE_UNAVAILABLE,
+                  "This purchase source is unavailable.",
+                  !1
+                )
+              );
+          }
+      }
+    } catch (error) {
+      let cancelled = data.signal?.aborted || error instanceof Error && error.name === ABORT_ERROR_NAME;
+      return ok(
+        toTerminalFailure(
+          cancelled ? chunkUCR5HRYM_js.ErrorCode.CANCELLED : chunkUCR5HRYM_js.ErrorCode.AUTHORIZATION_FAILED,
+          cancelled ? "Checkout was cancelled." : error instanceof Error ? error.message : "Checkout authorization failed.",
+          true
+        )
+      );
+    }
+  }
+};
+
+// src/orders.ts
+var OrderQueries = class {
+  constructor(client) {
+    this.client = client;
+  }
+  orderTokenParam(orderId) {
+    let token = this.client.getOrderToken(orderId);
+    return token ? `?token=${encodeURIComponent(token)}` : "";
+  }
+  async list(options) {
+    let params = new URLSearchParams();
+    options?.status && params.set("status", options.status), options?.limit && params.set("limit", String(options.limit)), options?.offset && params.set("offset", String(options.offset));
+    let path = params.toString() ? `/api/v1/orders?${params.toString()}` : "/api/v1/orders";
+    return safe(this.client.get(path));
+  }
+  async get(orderId) {
+    let encodedId = encodeURIComponent(orderId), tokenParam = this.orderTokenParam(orderId);
+    return safe(this.client.get(`/api/v1/orders/${encodedId}${tokenParam}`));
+  }
+  /**
+   * Same endpoint as `get`, typed as the enriched display contract
+   * (product names, images, resolved selections, customer inputs, scheduling,
+   * fulfillment). Feed the result through `toAccountOrderView`.
+   */
+  async getDetail(orderId) {
+    let encodedId = encodeURIComponent(orderId), 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, opts) {
+    let encodedId = encodeURIComponent(orderId), tokenParam = this.orderTokenParam(orderId), idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
+    return safe(
+      this.client.post(
+        `/api/v1/orders/${encodedId}/cancel${tokenParam}`,
+        { reason },
+        { idempotencyKey }
+      )
+    );
+  }
+};
+
+// src/link.ts
+function encodePathSegment(value) {
+  return encodeURIComponent(value);
+}
+var LinkService = class {
+  constructor(client) {
+    this.client = client;
+    this.activationGeneration = 0;
+  }
+  beginActivation() {
+    return {
+      generation: ++this.activationGeneration,
+      sessionEpoch: this.client.getSessionEpoch(),
+      publicKeyEpoch: this.client.getPublicKeyEpoch()
+    };
+  }
+  isActivationFenceCurrent(fence) {
+    return fence.generation === this.activationGeneration && fence.sessionEpoch === this.client.getSessionEpoch() && fence.publicKeyEpoch === this.client.getPublicKeyEpoch();
+  }
+  supersededActivation() {
+    return {
+      ok: false,
+      error: new chunkUCR5HRYM_js.CimplifyError(
+        "session_superseded",
+        "A newer authentication session replaced this one"
+      )
+    };
+  }
+  async activateAuthenticatedSession(result, fence) {
+    if (!result.ok || !result.value.session_token) return result;
+    if (!this.isActivationFenceCurrent(fence)) return this.supersededActivation();
+    let accessToken = result.value.session_token;
+    this.client.setAccessToken(accessToken);
+    let installedSessionEpoch = this.client.getSessionEpoch();
+    if (!this.client.getPublicKey().trim())
+      return this.client.activity.refreshIdentity(), result;
+    let claim = await this.client.session.claim();
+    return fence.generation !== this.activationGeneration || fence.publicKeyEpoch !== this.client.getPublicKeyEpoch() || this.client.getAccessToken() !== accessToken ? this.supersededActivation() : !claim.ok && claim.error.code !== "already_claimed" ? this.client.getSessionEpoch() !== installedSessionEpoch ? this.supersededActivation() : (this.client.hasClaimedSessionAuthority() ? this.client.clearSession() : this.client.setAccessToken(null), claim) : (this.client.activity.refreshIdentity(), result);
+  }
+  async requestOtp(input, opts) {
+    let idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
+    return safe(
+      this.client.linkPost("/v1/link/auth/request-otp", input, {
+        idempotencyKey
+      })
+    );
+  }
+  async verifyOtp(input, opts) {
+    let idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey(), activationFence = opts?.activateSession === false ? null : this.beginActivation(), { business_id: _ignoredBusinessId, ...body } = input, result = await safe(
+      this.client.linkPost("/v1/link/auth/verify-otp", body, { idempotencyKey })
+    );
+    return activationFence ? this.activateAuthenticatedSession(result, activationFence) : result;
+  }
+  async refreshSession(sessionToken, opts) {
+    let idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey(), activationFence = opts?.activateSession === false ? null : this.beginActivation(), body = sessionToken ? { session_token: sessionToken } : {}, result = await safe(
+      this.client.linkPost("/v1/link/auth/refresh", body, { idempotencyKey })
+    );
+    return activationFence ? this.activateAuthenticatedSession(result, activationFence) : result;
+  }
+  async logout() {
+    this.activationGeneration += 1;
+    let request = safe(this.client.linkPost("/v1/link/auth/logout"));
+    return this.client.clearSession(), request;
+  }
+  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"));
+  }
+  /**
+   * Updates the profile name. An email or phone may only be echoed back
+   * unchanged; a different one is refused with CONTACT_VERIFICATION_REQUIRED
+   * and goes through `requestContactChange` and `confirmContactChange`.
+   */
+  async updateProfile(input) {
+    return safe(this.client.linkPost("/v1/link/profile", input));
+  }
+  async requestContactChange(input) {
+    return safe(
+      this.client.linkPost("/v1/link/profile/contact/request", input)
+    );
+  }
+  async confirmContactChange(input) {
+    return safe(this.client.linkPost("/v1/link/profile/contact/confirm", input));
+  }
+  async getOrders(options) {
+    let params = new URLSearchParams();
+    options?.status && params.set("status", options.status), options?.limit && params.set("limit", String(options.limit)), options?.offset && params.set("offset", String(options.offset)), options?.businessId && params.set("business_id", options.businessId);
+    let query = params.toString(), path = query ? `/v1/link/orders?${query}` : "/v1/link/orders";
+    return safe(this.client.linkGet(path));
+  }
+  async getOrder(orderId, options) {
+    let params = new URLSearchParams();
+    options?.businessId && params.set("business_id", options.businessId);
+    let query = params.toString(), path = query ? `/v1/link/orders/${encodePathSegment(orderId)}?${query}` : `/v1/link/orders/${encodePathSegment(orderId)}`;
+    return safe(this.client.linkGet(path));
+  }
+  async enroll(data, opts) {
+    let idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
+    return safe(
+      this.client.linkPost("/v1/link/enroll", data, { idempotencyKey })
+    );
+  }
+  /**
+   * Save a paid order's details after the person ticked "Save my details with Cimplify".
+   * Nothing is saved until the order's contact is proved; when it is not, the result names
+   * the contact to send one code to. Never call this before payment completes.
+   */
+  async saveDetails(data, opts) {
+    let idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
+    return safe(
+      this.client.linkPost("/v1/link/save-details", data, {
+        idempotencyKey
+      })
+    );
+  }
+  /**
+   * After `saveDetails` asked for a code: checks the code the person received, which signs
+   * them in to Link, then saves the order's details under their account.
+   */
+  async confirmSaveDetails(data, code) {
+    let verified = await this.verifyOtp(code);
+    return verified.ok ? verified.value.success ? this.saveDetails(data) : err(new chunkUCR5HRYM_js.CimplifyError(chunkUCR5HRYM_js.ErrorCode.UNAUTHORIZED, verified.value.message, true)) : err(verified.error);
+  }
+  async updatePreferences(preferences) {
+    return safe(this.client.linkPost("/v1/link/preferences", preferences));
+  }
+  async createAddress(input, opts) {
+    let idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
+    return safe(
+      this.client.linkPost("/v1/link/addresses", input, { idempotencyKey })
+    );
+  }
+  async updateAddress(input) {
+    let { address_id, ...patch } = input;
+    return safe(
+      this.client.linkPost(
+        `/v1/link/addresses/${encodePathSegment(address_id)}`,
+        patch
+      )
+    );
+  }
+  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, opts) {
+    let idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
+    return safe(
+      this.client.linkPost("/v1/link/mobile-money", input, { idempotencyKey })
+    );
+  }
+  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`
+      )
+    );
+  }
+  /**
+   * Reports whether a saved mobile money account is verified; it verifies nothing.
+   * Verification comes only from a successful payment from the account; one not yet
+   * verified fails with `CONCURRENCY_CONFLICT`.
+   */
+  async checkMobileMoneyVerification(mobileMoneyId, opts) {
+    let idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
+    return safe(
+      this.client.linkPost(
+        `/v1/link/mobile-money/${encodePathSegment(mobileMoneyId)}/verify`,
+        void 0,
+        { idempotencyKey }
+      )
+    );
+  }
+  /**
+   * @deprecated Renamed to {@link LinkService.checkMobileMoneyVerification}: it only reports
+   * whether the account is verified and never verifies it.
+   */
+  async verifyMobileMoney(mobileMoneyId, opts) {
+    return this.checkMobileMoneyVerification(mobileMoneyId, opts);
+  }
+  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() {
+    let result = await this.getStatus();
+    return result.ok ? ok(result.value.customer || null) : result;
+  }
+  async isAuthenticated() {
+    let result = await this.getStatus();
+    return result.ok ? ok(result.value.is_authenticated) : result;
+  }
+  async requestOtp(contact, contactType, opts) {
+    let idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
+    return safe(
+      this.client.post(
+        "/api/v1/auth/request-otp",
+        { contact, contact_type: contactType },
+        { idempotencyKey }
+      )
+    );
+  }
+  async verifyOtp(code, contact, opts) {
+    let idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey(), result = await safe(
+      this.client.post(
+        "/api/v1/auth/verify-otp",
+        { otp_code: code, contact },
+        { idempotencyKey }
+      )
+    );
+    return result.ok && result.value.session_token && (this.client.setAccessToken(result.value.session_token), this.client.activity.refreshIdentity(), this.client.autoClaimSession()), result;
+  }
+  async logout() {
+    let result = await safe(this.client.post("/api/v1/auth/logout"));
+    return this.client.clearSession(), result;
+  }
+  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 getEmbeddingOrigins(opts) {
+    return safe(this.client.get("/api/v1/elements/origins", opts));
+  }
+  async getInfo(opts) {
+    return safe(this.client.get("/api/v1/business", opts));
+  }
+  async getByHandle(handle, opts) {
+    let encodedHandle = encodeURIComponent(handle);
+    return safe(this.client.get(`/api/v1/business/by-handle/${encodedHandle}`, opts));
+  }
+  async getByDomain(domain, opts) {
+    let encodedDomain = encodeURIComponent(domain);
+    return safe(this.client.get(`/api/v1/business/by-domain?domain=${encodedDomain}`, opts));
+  }
+  async getSettings(opts) {
+    return safe(this.client.get("/api/v1/business/settings", opts));
+  }
+  async getLocations(opts) {
+    return safe(this.client.get("/api/v1/business/locations", opts));
+  }
+  async getLocation(locationId, opts) {
+    let result = await this.getLocations(opts);
+    if (!result.ok) return err(result.error);
+    let location = result.value.find((item) => item.id === locationId);
+    return location ? ok(location) : err(new chunkUCR5HRYM_js.CimplifyError(chunkUCR5HRYM_js.ErrorCode.NOT_FOUND, `Location not found: ${locationId}`, false));
+  }
+  async getHours(opts) {
+    return safe(this.client.get("/api/v1/business/hours", opts));
+  }
+  async getLocationHours(locationId, opts) {
+    let result = await this.getHours(opts);
+    return result.ok ? ok(result.value.filter((hour) => hour.location_id === locationId)) : result;
+  }
+  async getBootstrap(opts) {
+    return safe(this.client.get("/api/v1/bootstrap", opts));
+  }
+};
+
+// src/inventory.ts
+var InventoryService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  withQuery(path, params) {
+    let searchParams = new URLSearchParams();
+    for (let [key, value] of Object.entries(params))
+      value !== void 0 && searchParams.set(key, String(value));
+    let query = searchParams.toString();
+    return query ? `${path}?${query}` : path;
+  }
+  async getProductStock(productId, locationId) {
+    let encodedId = encodeURIComponent(productId), path = this.withQuery(`/api/v1/inventory/products/${encodedId}/stock`, {
+      location_id: locationId
+    });
+    return safe(this.client.get(path));
+  }
+  async getVariantStock(variantId, locationId) {
+    let encodedId = encodeURIComponent(variantId), path = this.withQuery(`/api/v1/inventory/variants/${encodedId}/stock`, {
+      location_id: locationId
+    });
+    return safe(this.client.get(path));
+  }
+  async checkProductAvailability(productId, quantity, locationId) {
+    let encodedId = encodeURIComponent(productId), path = this.withQuery(`/api/v1/inventory/products/${encodedId}/availability`, {
+      quantity,
+      location_id: locationId
+    });
+    return safe(this.client.get(path));
+  }
+  async checkVariantAvailability(variantId, quantity, locationId) {
+    let encodedId = encodeURIComponent(variantId), path = this.withQuery(`/api/v1/inventory/variants/${encodedId}/availability`, {
+      quantity,
+      location_id: locationId
+    });
+    return safe(this.client.get(path));
+  }
+  async checkMultipleAvailability(items, locationId) {
+    let 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 (let result of results)
+      if (!result.ok) return result;
+    return ok(results.map((r) => r.value));
+  }
+  async isInStock(productId, locationId) {
+    let result = await this.checkProductAvailability(productId, 1, locationId);
+    return result.ok ? ok(result.value.is_available) : result;
+  }
+  async getAvailableQuantity(productId, locationId) {
+    let result = await this.getProductStock(productId, locationId);
+    return result.ok ? ok(result.value.available_quantity ?? void 0) : result;
+  }
+};
+
+// src/scheduling.ts
+function withQuery2(path, params) {
+  let searchParams = new URLSearchParams();
+  for (let [key, value] of Object.entries(params))
+    value !== void 0 && searchParams.set(key, String(value));
+  let 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) {
+    let encodedId = encodeURIComponent(serviceId);
+    return safe(this.client.get(`/api/v1/scheduling/services/${encodedId}`));
+  }
+  async getAvailableSlots(input) {
+    let path = withQuery2("/api/v1/scheduling/slots", {
+      service_id: input.service_id,
+      date: input.date,
+      participant_count: input.participant_count,
+      units: input.units,
+      variant_id: input.variant_id
+    });
+    return safe(this.client.get(path));
+  }
+  async checkSlotAvailability(input) {
+    let 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) {
+    let 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,
+      units: params.units,
+      variant_id: params.variant_id
+    });
+    return safe(this.client.get(path));
+  }
+  async getBooking(bookingId) {
+    let encodedId = encodeURIComponent(bookingId);
+    return safe(this.client.get(`/api/v1/scheduling/bookings/${encodedId}`));
+  }
+  async getCustomerBookings(customerId) {
+    let path = withQuery2("/api/v1/scheduling/bookings", {
+      customer_id: customerId
+    });
+    return safe(this.client.get(path));
+  }
+  async getUpcomingBookings() {
+    let result = await this.getCustomerBookings();
+    if (!result.ok) return result;
+    let upcoming = result.value.filter((booking) => {
+      let 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) {
+    let result = await this.getCustomerBookings();
+    if (!result.ok) return result;
+    let 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, opts) {
+    let encodedId = encodeURIComponent(input.booking_id), idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
+    return safe(
+      this.client.post(
+        `/api/v1/scheduling/bookings/${encodedId}/cancel`,
+        { reason: input.reason },
+        { idempotencyKey }
+      )
+    );
+  }
+  async rescheduleBooking(input, opts) {
+    let idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
+    return safe(
+      this.client.post(
+        "/api/v1/scheduling/bookings/reschedule",
+        input,
+        { idempotencyKey }
+      )
+    );
+  }
+  async getNextAvailableSlot(serviceId, fromDate) {
+    let date = fromDate || (/* @__PURE__ */ new Date()).toISOString().split("T")[0], result = await this.getAvailableSlots({
+      service_id: serviceId,
+      date
+    });
+    return result.ok ? ok(result.value[0] ?? null) : result;
+  }
+  async hasAvailabilityOn(serviceId, date) {
+    let result = await this.getAvailableSlots({
+      service_id: serviceId,
+      date
+    });
+    return result.ok ? ok(result.value.length > 0) : result;
+  }
+};
+
+// src/lite.ts
+var LiteService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getBootstrap() {
+    return safe(this.client.get("/api/v1/lite/bootstrap"));
+  }
+  async getResource(resourceId) {
+    let encodedId = encodeURIComponent(resourceId);
+    return safe(this.client.get(`/api/v1/lite/resources/${encodedId}`));
+  }
+  async getMenu() {
+    return safe(this.client.get("/api/v1/lite/menu"));
+  }
+  async getMenuByCategory(categoryId) {
+    let 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) {
+    let path = `/api/v1/fx/rate?from=${encodeURIComponent(from)}&to=${encodeURIComponent(to)}`;
+    return safe(this.client.get(path));
+  }
+  async lockQuote(request, opts) {
+    let idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
+    return safe(
+      this.client.post("/api/v1/fx/quotes", request, { idempotencyKey })
+    );
+  }
+};
+
+// src/types/elements.ts
+var ELEMENT_TYPES = {
+  AUTH: "auth",
+  ADDRESS: "address",
+  PAYMENT: "payment",
+  CHECKOUT: "checkout",
+  ACCOUNT: "account"
+}, MESSAGE_TYPES = {
+  INIT: "init",
+  IDENTITY: "identity",
+  SESSION_CLEARED: "session_cleared",
+  SET_CART: "set_cart",
+  GET_DATA: "get_data",
+  LOGOUT: "logout",
+  PROCESS_CHECKOUT: "process_checkout",
+  ABORT_CHECKOUT: "abort_checkout",
+  READY: "ready",
+  HEIGHT_CHANGE: "height_change",
+  ERROR: "error",
+  ADDRESS_CHANGED: "address_changed",
+  ADDRESS_SELECTED: "address_selected",
+  PAYMENT_METHOD_SELECTED: "payment_method_selected",
+  LOGOUT_COMPLETE: "logout_complete",
+  AUTH_REQUESTED: "auth_requested",
+  SESSION_ESTABLISHED: "session_established",
+  CONTINUE_WITHOUT_SAVED_DETAILS: "continue_without_saved_details",
+  CONTACT_PROVIDED: "contact_provided",
+  CHECKOUT_STATUS: "checkout_status",
+  CHECKOUT_COMPLETE: "checkout_complete",
+  TERMS_CHANGED: "terms_changed",
+  SELECTION_UNAVAILABLE: "selection_unavailable",
+  ORDER_TYPE_CHANGED: "order_type_changed",
+  REQUEST_SUBMIT: "request_submit"
+}, ELEMENTS_AUTH_CONTACT_TYPES = {
+  EMAIL: "email",
+  PHONE: "phone"
+}, ELEMENTS_AUTH_PROMPTS = {
+  LOGIN: "login"
+}, ELEMENTS_AUTH_MODES = {
+  CHECKOUT: "checkout",
+  DEFAULT: "default"
+}, EVENT_TYPES = {
+  READY: "ready",
+  AUTHENTICATED: "authenticated",
+  ERROR: "error",
+  CHANGE: "change",
+  BLUR: "blur",
+  FOCUS: "focus",
+  ORDER_TYPE_CHANGED: "order_type_changed",
+  REQUEST_SUBMIT: "request_submit",
+  CHECKOUT_STATUS: "checkout_status",
+  CHECKOUT_COMPLETE: "checkout_complete"
+};
+
+// src/internal/pkce.ts
+async function generatePkce() {
+  let random = new Uint8Array(64);
+  crypto.getRandomValues(random);
+  let verifier = base64UrlEncode(random), digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier)), challenge = base64UrlEncode(new Uint8Array(digest));
+  return { verifier, challenge, method: "S256" };
+}
+function generateState(byteLength = 16) {
+  let buf = new Uint8Array(byteLength);
+  return crypto.getRandomValues(buf), base64UrlEncode(buf);
+}
+function base64UrlEncode(bytes) {
+  let str = "";
+  for (let byte of bytes) str += String.fromCharCode(byte);
+  return btoa(str).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+
+// src/internal/pkce-cookie.ts
+var PKCE_COOKIE = "cimplify_pkce", PKCE_COOKIE_PATH = "/auth";
+function encodePkceState(state) {
+  return encodeURIComponent(JSON.stringify(state));
+}
+function decodePkceState(raw) {
+  try {
+    let parsed = JSON.parse(decodeURIComponent(raw));
+    if (typeof parsed?.verifier == "string" && typeof parsed.state == "string" && typeof parsed.returnTo == "string")
+      return { verifier: parsed.verifier, state: parsed.state, returnTo: parsed.returnTo };
+  } catch {
+  }
+  return null;
+}
+
+// src/internal/discovery.ts
+var DEFAULT_ISSUER = "https://api.cimplify.io", DEFAULT_AUTHORIZATION_ENDPOINT = "https://auth.cimplify.io/oauth/authorize";
+function fallbackAuthorizationEndpoint(issuerBase) {
+  if (issuerBase === DEFAULT_ISSUER) return DEFAULT_AUTHORIZATION_ENDPOINT;
+  throw new Error(
+    `OIDC discovery for "${issuerBase}" is unreachable and no fallback authorize endpoint is known for it. Make discovery reachable (enable CORS) or pass authUrl.`
+  );
+}
+var cache = /* @__PURE__ */ new Map();
+function fetchDiscovery(issuer) {
+  let base = issuer.replace(/\/$/, ""), pending = cache.get(base);
+  return pending || (pending = fetch(`${base}/.well-known/openid-configuration`).then((res) => {
+    if (!res.ok) throw new Error(`oidc discovery failed: ${res.status}`);
+    return res.json();
+  }), pending.catch(() => cache.delete(base)), cache.set(base, pending)), pending;
+}
+async function getAuthorizationEndpoint(issuer) {
+  let base = issuer.replace(/\/$/, "");
+  try {
+    let doc = await fetchDiscovery(base);
+    if (doc.authorization_endpoint) return doc.authorization_endpoint;
+  } catch {
+  }
+  return fallbackAuthorizationEndpoint(base);
+}
+
+// src/internal/modal-iframe.ts
+function openModalIframe(opts) {
+  let overlay = document.createElement("div");
+  overlay.dataset.cimplifyModal = "1", Object.assign(overlay.style, {
+    position: "fixed",
+    inset: "0",
+    background: "rgba(15, 18, 24, 0.55)",
+    zIndex: "2147483647",
+    display: "grid",
+    placeItems: "center",
+    backdropFilter: "blur(2px)"
+  });
+  let card = document.createElement("div");
+  Object.assign(card.style, {
+    width: `${opts.width ?? 480}px`,
+    maxWidth: "calc(100vw - 24px)",
+    height: `${opts.height ?? 720}px`,
+    maxHeight: "calc(100vh - 32px)"
+  });
+  let iframe = document.createElement("iframe");
+  iframe.src = opts.src, iframe.style.width = "100%", iframe.style.height = "100%", iframe.style.border = "none", iframe.style.background = "transparent", iframe.setAttribute(
+    "sandbox",
+    opts.sandbox ?? "allow-scripts allow-same-origin allow-forms allow-popups"
+  ), iframe.setAttribute("allow", "publickey-credentials-get; publickey-credentials-create"), card.appendChild(iframe), overlay.appendChild(card), document.body.appendChild(overlay);
+  let close = () => {
+    overlay.remove(), document.removeEventListener("keydown", onKey), opts.onClose?.();
+  }, onKey = (e) => {
+    e.key === "Escape" && close();
+  };
+  return overlay.addEventListener("click", (e) => {
+    e.target === overlay && close();
+  }), document.addEventListener("keydown", onKey), { iframe, close };
+}
+
+// src/sign-in.ts
+var DEFAULT_SCOPE = "openid email phone profile", DEFAULT_SILENT_TIMEOUT_MS = 900, RESPONSE_TYPE_CODE = "code", RESPONSE_MODE_WEB_MESSAGE = "web_message", RESPONSE_MODE_QUERY = "query", PROMPT_NONE = "none", AUTHORIZATION_RESPONSE_MESSAGE_TYPE = "authorization_response", ERROR_STATE_MISMATCH = "state_mismatch", ERROR_CALLBACK_FAILED = "callback_failed", ERROR_CALLBACK_EXCEPTION = "callback_exception", ERROR_CANCELLED = "cancelled", ERROR_LOGIN_REQUIRED = "login_required", ERROR_CONSENT_REQUIRED = "consent_required", ERROR_INTERACTION_REQUIRED = "interaction_required", INTERACTIVE_AUTH_ERRORS = /* @__PURE__ */ new Set([
+  ERROR_LOGIN_REQUIRED,
+  ERROR_CONSENT_REQUIRED,
+  ERROR_INTERACTION_REQUIRED
+]);
+function buildAuthorizeUrl(opts, authorizeEndpoint, pkce, state, urlOpts) {
+  let params = new URLSearchParams({
+    response_type: RESPONSE_TYPE_CODE,
+    response_mode: urlOpts.responseMode,
+    client_id: opts.clientId,
+    redirect_uri: opts.redirectUri,
+    scope: opts.scope ?? DEFAULT_SCOPE,
+    state,
+    code_challenge: pkce.challenge,
+    code_challenge_method: pkce.method
+  });
+  return opts.loginHint && params.set("login_hint", opts.loginHint), urlOpts.prompt && params.set("prompt", urlOpts.prompt), opts.uiMode && params.set("ui_mode", opts.uiMode), `${authorizeEndpoint}?${params.toString()}`;
+}
+async function exchangeAuthorizationCode(callbackUri, pkce, state, code) {
+  let res = await fetch(callbackUri, {
+    method: "POST",
+    credentials: "include",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ code, codeVerifier: pkce.verifier, state })
+  });
+  if (!res.ok) {
+    let body = await res.text().catch(() => "");
+    throw { error: ERROR_CALLBACK_FAILED, description: body };
+  }
+  let payload = await res.json().catch(() => ({}));
+  return {
+    accessToken: payload.accessToken ?? payload.access_token,
+    expiresIn: payload.expiresIn ?? payload.expires_in,
+    scope: payload.scope
+  };
+}
+async function trySilentModalSignIn(opts, authorizeEndpoint, callbackUri, pkce, state) {
+  let expectedOrigin = new URL(authorizeEndpoint).origin, iframe = document.createElement("iframe");
+  return iframe.style.display = "none", iframe.setAttribute("aria-hidden", "true"), iframe.setAttribute("sandbox", "allow-scripts allow-same-origin"), iframe.src = buildAuthorizeUrl(opts, authorizeEndpoint, pkce, state, {
+    responseMode: RESPONSE_MODE_WEB_MESSAGE,
+    prompt: PROMPT_NONE
+  }), new Promise((resolve) => {
+    let settled = false, handler = () => {
+    }, timeout = setTimeout(() => finish(false), opts.silentTimeoutMs ?? (900)), cleanup = () => {
+      window.removeEventListener("message", handler), iframe.remove(), clearTimeout(timeout);
+    }, finish = (handled) => {
+      settled || (settled = true, cleanup(), resolve(handled));
+    };
+    handler = async (event) => {
+      if (event.origin !== expectedOrigin) return;
+      let data = event.data;
+      if (!data || typeof data != "object" || data.type !== AUTHORIZATION_RESPONSE_MESSAGE_TYPE) return;
+      let response = data.response;
+      if (response.error) {
+        if (INTERACTIVE_AUTH_ERRORS.has(response.error)) {
+          finish(false);
+          return;
+        }
+        opts.onError?.({ error: response.error, description: response.error_description }), finish(true);
+        return;
+      }
+      if (response.code) {
+        if (response.state !== state) {
+          opts.onError?.({ error: ERROR_STATE_MISMATCH }), finish(true);
+          return;
+        }
+        try {
+          opts.onSuccess?.(await exchangeAuthorizationCode(callbackUri, pkce, state, response.code));
+        } catch (e) {
+          let err2 = e;
+          opts.onError?.({
+            error: err2.error ?? ERROR_CALLBACK_EXCEPTION,
+            description: err2.description ?? String(e)
+          });
+        }
+        finish(true);
+      }
+    }, window.addEventListener("message", handler), document.body.appendChild(iframe);
+  });
+}
+function resolveAuthorizeEndpoint(opts) {
+  return opts.authUrl ? Promise.resolve(`${opts.authUrl.replace(/\/$/, "")}/oauth/authorize`) : getAuthorizationEndpoint(opts.issuer ?? DEFAULT_ISSUER);
+}
+async function startSignIn(opts) {
+  let callbackUri = opts.callbackUri ?? "/auth/callback", pkce = await generatePkce(), state = generateState(), authorizeEndpoint = await resolveAuthorizeEndpoint(opts);
+  if ((opts.mode ?? "redirect") === "redirect") {
+    startRedirectSignIn(opts, authorizeEndpoint, pkce, state);
+    return;
+  }
+  if (opts.silentFirst && !opts.prompt && await trySilentModalSignIn(opts, authorizeEndpoint, callbackUri, pkce, state))
+    return;
+  let src = buildAuthorizeUrl(opts, authorizeEndpoint, pkce, state, {
+    responseMode: RESPONSE_MODE_WEB_MESSAGE,
+    prompt: opts.prompt
+  }), expectedOrigin = new URL(authorizeEndpoint).origin, completed = false, handler = () => {
+  }, modal = openModalIframe({
+    src,
+    onClose: () => {
+      window.removeEventListener("message", handler), completed || opts.onError?.({ error: ERROR_CANCELLED });
+    }
+  });
+  handler = async (event) => {
+    if (event.origin !== expectedOrigin) return;
+    let data = event.data;
+    if (!data || typeof data != "object" || data.type !== AUTHORIZATION_RESPONSE_MESSAGE_TYPE) return;
+    let response = data.response;
+    if (response.error) {
+      completed = true, modal.close(), opts.onError?.({ error: response.error, description: response.error_description });
+      return;
+    }
+    if (response.code) {
+      if (response.state !== state) {
+        completed = true, modal.close(), opts.onError?.({ error: ERROR_STATE_MISMATCH });
+        return;
+      }
+      try {
+        let result = await exchangeAuthorizationCode(callbackUri, pkce, state, response.code);
+        completed = !0, modal.close(), opts.onSuccess?.(result);
+      } catch (e) {
+        let err2 = e;
+        completed = true, opts.onError?.({
+          error: err2.error ?? ERROR_CALLBACK_EXCEPTION,
+          description: err2.description ?? String(e)
+        }), modal.close();
+      }
+    }
+  }, window.addEventListener("message", handler);
+}
+function startRedirectSignIn(opts, authorizeEndpoint, pkce, state) {
+  let returnTo = opts.returnTo ?? window.location.pathname + window.location.search, cookieValue = encodePkceState({ verifier: pkce.verifier, state, returnTo }), secure = window.location.protocol === "https:" ? "; Secure" : "";
+  document.cookie = `${PKCE_COOKIE}=${cookieValue}; Path=${PKCE_COOKIE_PATH}; Max-Age=${600}; SameSite=Lax${secure}`, window.location.assign(buildAuthorizeUrl(opts, authorizeEndpoint, pkce, state, {
+    responseMode: RESPONSE_MODE_QUERY,
+    prompt: opts.prompt
+  }));
+}
+
+// src/internal/events.ts
+var MUTATION_ERROR = "mutation:error";
+var AUTH_TOKEN_CHANGED = "auth:token-changed", SESSION_CLAIMED = "session:claimed", SESSION_CLEARED = "session:cleared";
+function createClientEvents() {
+  let listeners = /* @__PURE__ */ new Map();
+  return {
+    on(name, listener) {
+      let set = listeners.get(name);
+      return set || (set = /* @__PURE__ */ new Set(), listeners.set(name, set)), set.add(listener), () => {
+        set?.delete(listener);
+      };
+    },
+    off(name, listener) {
+      listeners.get(name)?.delete(listener);
+    },
+    emit(name, payload) {
+      let set = listeners.get(name);
+      if (!set) return;
+      let snapshot = Array.from(set);
+      for (let listener of snapshot)
+        try {
+          listener(payload);
+        } catch (err2) {
+          console.error(`[Cimplify] event listener for "${name}" threw:`, err2);
+        }
+    }
+  };
+}
+
+// src/elements.ts
+function toCheckoutError(code, message, recoverable) {
+  let hint = chunkUCR5HRYM_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", ELEMENT_IFRAME_PERMISSIONS = "geolocation; publickey-credentials-get; publickey-credentials-create", LEGACY_REFRESH_TOKEN_PREFIX = "cimplify.link.rt.", AUTH_CONTACT_TYPES = new Set(Object.values(ELEMENTS_AUTH_CONTACT_TYPES)), AUTH_MODES = new Set(Object.values(ELEMENTS_AUTH_MODES)), AUTH_PROMPTS = new Set(Object.values(ELEMENTS_AUTH_PROMPTS));
+function generateNonce() {
+  return typeof crypto < "u" && crypto.randomUUID ? crypto.randomUUID().replace(/-/g, "").slice(0, 16) : Math.random().toString(36).slice(2) + Math.random().toString(36).slice(2);
+}
+function readPublicEnv(name) {
+  try {
+    let value = globalThis.process?.env?.[name];
+    return value && value.trim() ? value : void 0;
+  } catch {
+    return;
+  }
+}
+function decodeJwtSub(token) {
+  let [, payload] = token.split(".");
+  if (!payload || typeof atob > "u") return "";
+  try {
+    let base64 = payload.replace(/-/g, "+").replace(/_/g, "/"), padded = base64.padEnd(base64.length + (4 - base64.length % 4) % 4, "="), parsed = JSON.parse(atob(padded));
+    return typeof parsed.sub == "string" ? parsed.sub : "";
+  } catch {
+    return "";
+  }
+}
+function isClaimedCustomer(value) {
+  if (!value || typeof value != "object") return false;
+  let record = value;
+  return typeof record.id == "string" && typeof record.name == "string" && (record.email === null || typeof record.email == "string") && (record.phone === null || typeof record.phone == "string");
+}
+function isAllowedOrigin(origin) {
+  try {
+    let url = new URL(origin), hostname = url.hostname;
+    return hostname === "localhost" || hostname === "127.0.0.1" ? !0 : url.protocol !== "https:" ? !1 : hostname === "cimplify.io" || hostname.endsWith(".cimplify.io");
+  } catch {
+    return false;
+  }
+}
+var KNOWN_IFRAME_TYPES = /* @__PURE__ */ new Set([
+  MESSAGE_TYPES.READY,
+  MESSAGE_TYPES.HEIGHT_CHANGE,
+  MESSAGE_TYPES.AUTH_REQUESTED,
+  MESSAGE_TYPES.SESSION_ESTABLISHED,
+  MESSAGE_TYPES.CONTINUE_WITHOUT_SAVED_DETAILS,
+  MESSAGE_TYPES.ERROR,
+  MESSAGE_TYPES.ADDRESS_CHANGED,
+  MESSAGE_TYPES.ADDRESS_SELECTED,
+  MESSAGE_TYPES.PAYMENT_METHOD_SELECTED,
+  MESSAGE_TYPES.CONTACT_PROVIDED,
+  MESSAGE_TYPES.LOGOUT_COMPLETE,
+  MESSAGE_TYPES.CHECKOUT_STATUS,
+  MESSAGE_TYPES.CHECKOUT_COMPLETE,
+  MESSAGE_TYPES.TERMS_CHANGED,
+  MESSAGE_TYPES.SELECTION_UNAVAILABLE,
+  MESSAGE_TYPES.ORDER_TYPE_CHANGED,
+  MESSAGE_TYPES.REQUEST_SUBMIT
+]);
+function parseIframeMessage(data) {
+  if (!data || typeof data != "object")
+    return null;
+  let record = data;
+  if (typeof record.type != "string" || !KNOWN_IFRAME_TYPES.has(record.type))
+    return null;
+  switch (record.type) {
+    case MESSAGE_TYPES.AUTH_REQUESTED:
+      if (record.loginHint !== void 0 && typeof record.loginHint != "string" || record.contactType !== void 0 && (typeof record.contactType != "string" || !AUTH_CONTACT_TYPES.has(record.contactType)) || record.mode !== void 0 && (typeof record.mode != "string" || !AUTH_MODES.has(record.mode)) || record.prompt !== void 0 && (typeof record.prompt != "string" || !AUTH_PROMPTS.has(record.prompt)))
+        return null;
+      break;
+    case MESSAGE_TYPES.SESSION_ESTABLISHED:
+      return typeof record.sessionToken != "string" || !record.sessionToken.trim() || !isClaimedCustomer(record.customer) ? null : {
+        type: MESSAGE_TYPES.SESSION_ESTABLISHED,
+        sessionToken: record.sessionToken,
+        customer: record.customer,
+        ...typeof record.nonce == "string" ? { nonce: record.nonce } : {}
+      };
+    case MESSAGE_TYPES.ADDRESS_CHANGED:
+    case MESSAGE_TYPES.ADDRESS_SELECTED:
+      if (!record.address || typeof record.address != "object") return null;
+      break;
+    case MESSAGE_TYPES.PAYMENT_METHOD_SELECTED:
+      if (!record.method || typeof record.method != "object") return null;
+      break;
+    case MESSAGE_TYPES.CONTACT_PROVIDED:
+    case MESSAGE_TYPES.CONTINUE_WITHOUT_SAVED_DETAILS:
+      if (typeof record.contact != "string" || typeof record.contactType != "string") return null;
+      break;
+    case MESSAGE_TYPES.ERROR:
+      if (typeof record.code != "string" || typeof record.message != "string") return null;
+      break;
+    case MESSAGE_TYPES.CHECKOUT_COMPLETE:
+      if (typeof record.success != "boolean") return null;
+      break;
+    case MESSAGE_TYPES.CHECKOUT_STATUS:
+      if (typeof record.status != "string" || !record.context || typeof record.context != "object")
+        return null;
+      break;
+    case MESSAGE_TYPES.TERMS_CHANGED:
+      if (typeof record.intent_id != "string" || !record.replacement || typeof record.replacement != "object" || !Array.isArray(record.deltas))
+        return null;
+      break;
+    case MESSAGE_TYPES.SELECTION_UNAVAILABLE:
+      if (typeof record.intent_id != "string" || !Array.isArray(record.lines)) return null;
+      break;
+    case MESSAGE_TYPES.READY:
+    case MESSAGE_TYPES.HEIGHT_CHANGE:
+      if (typeof record.height != "number") return null;
+      break;
+    case MESSAGE_TYPES.ORDER_TYPE_CHANGED:
+      if (typeof record.orderType != "string") return null;
+      break;
+  }
+  return data;
+}
+var CimplifyElements = class {
+  constructor(client, businessId, options = {}) {
+    this.elements = /* @__PURE__ */ new Map();
+    this.accessToken = null;
+    this.sessionAuthenticated = false;
+    this.accountId = null;
+    this.customerId = null;
+    this.customerData = null;
+    this.addressData = null;
+    this.paymentData = null;
+    this.checkoutInProgress = false;
+    this.authInProgress = false;
+    this.authGeneration = 0;
+    this.activeCheckoutAbort = null;
+    this.businessIdResolvePromise = null;
+    this.stopSessionSync = () => {
+    };
+    this.client = client, this.businessId = businessId ?? null, this.linkUrl = options.linkUrl || DEFAULT_LINK_URL, this.options = options, this.boundHandleMessage = this.handleMessage.bind(this), typeof window < "u" && window.addEventListener("message", this.boundHandleMessage), this.stopSessionSync = client.events.on(SESSION_CLAIMED, () => {
+      this.authInProgress || this._syncHostSession();
+    }), this.restoreSession();
+  }
+  debug(...args) {
+    this.client.isTestMode() && console.debug(...args);
+  }
+  _syncHostSession(element) {
+    let sessionToken = this.client.getSessionToken();
+    if (!sessionToken) return;
+    let identity = {
+      type: MESSAGE_TYPES.IDENTITY,
+      sessionToken,
+      accessToken: this.client.getAccessToken() ?? this.accessToken,
+      customer: this.identityCustomer()
+    }, targets = element ? [element] : Array.from(this.elements.values());
+    for (let target of targets)
+      target.sendMessage(identity);
+  }
+  identityCustomer() {
+    return !this.isAuthenticated() || !this.customerId || !this.customerData ? null : { id: this.customerId, ...this.customerData };
+  }
+  forgetIdentity() {
+    this.accessToken = null, this.sessionAuthenticated = false, this.accountId = null, this.customerId = null, this.customerData = null, this.addressData = null, this.paymentData = null;
+  }
+  create(type, options = {}) {
+    let existing = this.elements.get(type);
+    if (existing) return existing;
+    let element = new CimplifyElement(type, this.businessId, this.linkUrl, options, this);
+    return this.elements.set(type, element), element;
+  }
+  getElement(type) {
+    return this.elements.get(type);
+  }
+  _removeElement(type, instance) {
+    this.elements.get(type) === instance && this.elements.delete(type);
+  }
+  destroy() {
+    this.authGeneration += 1, this.authInProgress = false, this.stopSessionSync(), this.stopSessionSync = () => {
+    }, this.elements.forEach((element) => element.destroy()), this.elements.clear(), typeof window < "u" && window.removeEventListener("message", this.boundHandleMessage);
+  }
+  async submitCheckout(data) {
+    let result = await this.processCheckout({
+      cart_id: data.cart_id,
+      intent_id: data.intent_id,
+      hosted_session_id: data.hosted_session_id,
+      initial_terms: data.initial_terms,
+      order_type: data.order_type ?? chunkGTJWQAGU_js.ORDER_TYPE.DELIVERY,
+      location_id: data.location_id,
+      notes: data.notes,
+      scheduled_time: data.scheduled_time,
+      tip_amount: data.tip_amount,
+      enroll_in_link: data.enroll_in_link
+    });
+    return result.success ? {
+      success: true,
+      order: {
+        id: result.order?.id || "",
+        status: result.order?.status || chunkGTJWQAGU_js.CHECKOUT_ORDER_RESULT_STATUS.UNKNOWN,
+        total: result.order?.total || ""
+      }
+    } : {
+      success: false,
+      error: {
+        code: result.error?.code || chunkUCR5HRYM_js.ErrorCode.CHECKOUT_FAILED,
+        message: result.error?.message || "Checkout failed"
+      }
+    };
+  }
+  processCheckout(options) {
+    let abortFn = null, abortable = (async () => {
+      if (this.debug("[cimplify:checkout] processCheckout called", {
+        cart_id: options.cart_id,
+        intent_id: options.intent_id,
+        hosted_session_id: options.hosted_session_id,
+        order_type: options.order_type,
+        location_id: options.location_id
+      }), typeof options.tip_amount == "number" && options.tip_amount > 0)
+        return toCheckoutError(
+          chunkUCR5HRYM_js.ErrorCode.TIP_NOT_SUPPORTED,
+          "Tips are not part of checkout. Remove the tip and try again.",
+          false
+        );
+      if (this.checkoutInProgress)
+        return this.debug("[cimplify:checkout] BLOCKED: already processing"), toCheckoutError(
+          chunkUCR5HRYM_js.ErrorCode.ALREADY_PROCESSING,
+          "Checkout is already in progress.",
+          false
+        );
+      if (this.checkoutInProgress = true, !options.cart_id && !options.intent_id)
+        return this.debug("[cimplify:checkout] BLOCKED: no cart_id or intent_id"), this.checkoutInProgress = false, toCheckoutError(
+          chunkUCR5HRYM_js.ErrorCode.CHECKOUT_AUTHORITY_REQUIRED,
+          "A cart or existing purchase intent is required before checkout can start.",
+          false
+        );
+      if (!options.order_type)
+        return this.debug("[cimplify:checkout] BLOCKED: no order_type"), this.checkoutInProgress = false, toCheckoutError(
+          chunkUCR5HRYM_js.ErrorCode.ORDER_TYPE_REQUIRED,
+          "Order type is required before checkout can start.",
+          false
+        );
+      let checkoutElement = this.elements.get(ELEMENT_TYPES.CHECKOUT) || this.elements.get(ELEMENT_TYPES.PAYMENT);
+      if (!checkoutElement)
+        return this.debug("[cimplify:checkout] BLOCKED: no checkout element"), this.checkoutInProgress = false, toCheckoutError(
+          chunkUCR5HRYM_js.ErrorCode.NO_PAYMENT_ELEMENT,
+          "Checkout element must be mounted before checkout.",
+          false
+        );
+      if (!checkoutElement.isMounted())
+        return this.debug("[cimplify:checkout] BLOCKED: checkout element not mounted"), this.checkoutInProgress = false, toCheckoutError(
+          chunkUCR5HRYM_js.ErrorCode.PAYMENT_NOT_MOUNTED,
+          "Checkout element must be mounted before checkout.",
+          false
+        );
+      let isUnifiedCheckout = this.elements.has(ELEMENT_TYPES.CHECKOUT);
+      if (!isUnifiedCheckout) {
+        if (this.elements.get(ELEMENT_TYPES.AUTH) && !this.isAuthenticated())
+          return this.debug("[cimplify:checkout] BLOCKED: auth incomplete"), this.checkoutInProgress = false, toCheckoutError(
+            chunkUCR5HRYM_js.ErrorCode.AUTH_INCOMPLETE,
+            "Authentication must complete before checkout can start.",
+            true
+          );
+        let addressElement = this.elements.get(ELEMENT_TYPES.ADDRESS);
+        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
+      });
+      let processMessage = {
+        type: MESSAGE_TYPES.PROCESS_CHECKOUT,
+        // Existing intent authority wins if a compatibility caller supplied
+        // both values; the iframe must never mint a replacement.
+        cart_id: options.intent_id ? void 0 : options.cart_id,
+        intent_id: options.intent_id,
+        hosted_session_id: options.hosted_session_id,
+        initial_terms: options.intent_id ? options.initial_terms : void 0,
+        order_type: options.order_type,
+        location_id: options.location_id,
+        notes: options.notes,
+        scheduled_time: options.scheduled_time,
+        pay_currency: options.pay_currency,
+        enroll_in_link: options.enroll_in_link,
+        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
+      }, inactivityTimeoutMs = options.timeout_ms ?? 18e4, shopperPendingStatuses = /* @__PURE__ */ new Set([
+        chunkGTJWQAGU_js.CHECKOUT_STATUS.REVIEWING_TERMS,
+        chunkGTJWQAGU_js.CHECKOUT_STATUS.AWAITING_AUTHORIZATION
+      ]);
+      return new Promise((resolve) => {
+        let settled = false, timeout, cleanup = () => {
+          typeof window < "u" && window.removeEventListener("message", handleCheckoutMessage), clearTimeout(timeout), this.checkoutInProgress = false, this.activeCheckoutAbort = null;
+        }, settle = (result) => {
+          settled || (settled = true, cleanup(), resolve(result));
+        }, armTimeout = () => {
+          clearTimeout(timeout), timeout = setTimeout(() => {
+            settle(
+              toCheckoutError(
+                chunkUCR5HRYM_js.ErrorCode.TIMEOUT,
+                "Checkout timed out before receiving a terminal response.",
+                true
+              )
+            );
+          }, inactivityTimeoutMs);
+        }, suspendTimeout = () => {
+          clearTimeout(timeout), timeout = void 0;
+        };
+        armTimeout();
+        let handleCheckoutMessage = (event) => {
+          if (!isAllowedOrigin(event.origin))
+            return;
+          let message = parseIframeMessage(event.data);
+          if (message && checkoutElement._acceptsMessageEvent(event, message)) {
+            if (message.type === MESSAGE_TYPES.CHECKOUT_STATUS) {
+              shopperPendingStatuses.has(message.status) ? suspendTimeout() : armTimeout(), options.on_status_change?.(message.status, message.context);
+              return;
+            }
+            if (message.type === MESSAGE_TYPES.TERMS_CHANGED) {
+              suspendTimeout(), options.on_status_change?.(chunkGTJWQAGU_js.CHECKOUT_STATUS.REVIEWING_TERMS, {
+                intent_id: message.intent_id,
+                replacement_terms: message.replacement,
+                terms_deltas: message.deltas
+              });
+              return;
+            }
+            if (message.type === MESSAGE_TYPES.SELECTION_UNAVAILABLE) {
+              suspendTimeout(), options.on_status_change?.(chunkGTJWQAGU_js.CHECKOUT_STATUS.REVIEWING_TERMS, {
+                intent_id: message.intent_id,
+                unavailable_lines: message.lines
+              });
+              return;
+            }
+            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
+            })), message.type === MESSAGE_TYPES.LOGOUT_COMPLETE && (checkoutElement.sendMessage({ type: MESSAGE_TYPES.ABORT_CHECKOUT }), settle(
+              toCheckoutError(
+                chunkUCR5HRYM_js.ErrorCode.AUTH_LOST,
+                "Authentication was cleared during checkout.",
+                true
+              )
+            ));
+          }
+        };
+        typeof window < "u" && window.addEventListener("message", handleCheckoutMessage), abortFn = () => {
+          checkoutElement.sendMessage({ type: MESSAGE_TYPES.ABORT_CHECKOUT }), settle(toCheckoutError(chunkUCR5HRYM_js.ErrorCode.CANCELLED, "Checkout was cancelled.", true));
+        }, this.activeCheckoutAbort = abortFn, this.debug("[cimplify:checkout] sending process_checkout to checkout iframe", {
+          cart_id: processMessage.cart_id,
+          intent_id: processMessage.intent_id,
+          hosted_session_id: processMessage.hosted_session_id,
+          order_type: processMessage.order_type,
+          hasCustomer: !!processMessage.customer,
+          hasAddress: !!processMessage.address,
+          isUnifiedCheckout
+        }), this._syncHostSession(checkoutElement), checkoutElement.sendMessage(processMessage), this.debug("[cimplify:checkout] postMessage sent, waiting for checkout_complete...");
+      });
+    })();
+    return abortable.abort = () => {
+      abortFn && abortFn();
+    }, abortable;
+  }
+  isAuthenticated() {
+    return this.accessToken !== null || this.sessionAuthenticated;
+  }
+  getAccessToken() {
+    return this.accessToken;
+  }
+  getPublicKey() {
+    return this.client.getPublicKey();
+  }
+  getSessionToken() {
+    return this.client.getSessionToken();
+  }
+  getBusinessId() {
+    return this.businessId;
+  }
+  async resolveBusinessId() {
+    return this.businessId ? this.businessId : this.businessIdResolvePromise ? this.businessIdResolvePromise : (this.businessIdResolvePromise = this.client.resolveBusinessId().then((resolvedBusinessId) => (this.businessId = resolvedBusinessId, resolvedBusinessId)).catch(() => null).finally(() => {
+      this.businessIdResolvePromise = null;
+    }), this.businessIdResolvePromise);
+  }
+  /** @internal Whether a `processCheckout` call is waiting on the checkout element. */
+  _isCheckoutInProgress() {
+    return this.checkoutInProgress;
+  }
+  getAppearance() {
+    return this.options.appearance;
+  }
+  isAuthGenerationCurrent(generation, token) {
+    return this.authGeneration === generation && this.client.getAccessToken() === token;
+  }
+  async hydrateCustomerData(generation = this.authGeneration, token = this.accessToken, force = false) {
+    if (!token || !this.isAuthGenerationCurrent(generation, token)) return false;
+    if (this.customerData && !force) return true;
+    let linkDataResult = await this.client.link.getLinkData();
+    if (!this.isAuthGenerationCurrent(generation, token)) return false;
+    if (!linkDataResult.ok || !linkDataResult.value?.customer)
+      return true;
+    let customer = linkDataResult.value.customer;
+    return this.customerData = {
+      name: customer.name || "",
+      email: customer.email || null,
+      phone: customer.phone || null
+    }, this.customerId = customer.id, true;
+  }
+  sourceElementFor(event, message) {
+    for (let element of this.elements.values())
+      if (element._acceptsMessageEvent(event, message))
+        return element;
+    return null;
+  }
+  /** Earlier SDK versions kept the account-wide Link refresh token here. It
+   * is removed on sight and never read. */
+  dropLegacyRefreshToken() {
+    if (typeof window > "u") return;
+    let key = this.client.getPublicKey().trim();
+    if (key)
+      try {
+        window.localStorage.removeItem(`${LEGACY_REFRESH_TOKEN_PREFIX}${key}`);
+      } catch {
+        return;
+      }
+  }
+  sessionAuthenticatedData() {
+    let sessionToken = this.client.getSessionToken();
+    return !sessionToken || !this.customerId || !this.customerData ? null : {
+      accountId: "",
+      customerId: this.customerId,
+      token: sessionToken,
+      customer: this.customerData
+    };
+  }
+  /**
+   * A reload keeps the shopper signed in through the storefront session the
+   * element claimed for this business. The page asks the storefront API who
+   * that session belongs to; no Link credential is involved.
+   */
+  async restoreSession() {
+    if (this.dropLegacyRefreshToken(), typeof window > "u" || this.isAuthenticated() || !this.client.hasClaimedSessionAuthority()) return;
+    let generation = ++this.authGeneration, sessionEpoch = this.client.getSessionEpoch(), status = await this.client.auth.getStatus();
+    if (this.authGeneration !== generation || this.client.getSessionEpoch() !== sessionEpoch || !status.ok) return;
+    let customer = status.value.customer;
+    if (!status.value.is_authenticated || !customer?.id) {
+      this.forgetIdentity(), this.client.clearSession(), this.broadcastClearedSession();
+      return;
+    }
+    this.sessionAuthenticated = true, this.customerId = customer.id, this.customerData = {
+      name: customer.name || "",
+      email: customer.email || null,
+      phone: customer.phone || null
+    };
+    let data = this.sessionAuthenticatedData();
+    this._syncHostSession(), data && this.elements.forEach((element) => element._emitAuthenticated(data));
+  }
+  async applyAccessToken(token, generation) {
+    if (this.authGeneration !== generation) return { kind: "incomplete" };
+    this.forgetIdentity(), this.client.setAccessToken(token);
+    let claim = await this.client.session.claim();
+    return this.isAuthGenerationCurrent(generation, token) ? !claim.ok && claim.error.code !== "already_claimed" ? (this.client.hasClaimedSessionAuthority() ? this.client.clearSession() : this.client.setAccessToken(null), {
+      kind: "claim_failed",
+      code: claim.error.code,
+      message: claim.error.userMessage
+    }) : (this.accessToken = token, this.accountId = decodeJwtSub(token), await this.hydrateCustomerData(generation, token, true) ? this.isAuthGenerationCurrent(generation, token) ? {
+      kind: "authenticated",
+      data: {
+        accountId: this.accountId ?? "",
+        customerId: this.customerId ?? "",
+        token,
+        customer: this.customerData ?? { name: "", email: null, phone: null }
+      }
+    } : { kind: "incomplete" } : { kind: "incomplete" }) : { kind: "incomplete" };
+  }
+  adoptEstablishedSession(sourceElement, session) {
+    this.authGeneration += 1, this.authInProgress = false;
+    let { id, ...customer } = session.customer;
+    this.forgetIdentity(), this.client.getAccessToken() && this.client.setAccessToken(null), this.sessionAuthenticated = true, this.customerId = id, this.customerData = customer, this.client.session.adopt(null, {
+      sessionToken: session.sessionToken,
+      customerName: session.customer.name,
+      customer: session.customer,
+      cart: null
+    }), sourceElement._emitAuthenticated({
+      accountId: "",
+      customerId: id,
+      token: session.sessionToken,
+      customer
+    });
+  }
+  broadcastClearedSession() {
+    let sessionToken = this.client.getSessionToken();
+    return sessionToken ? (this.elements.forEach((element) => {
+      element.sendMessage({ type: MESSAGE_TYPES.SESSION_CLEARED, sessionToken });
+    }), sessionToken) : null;
+  }
+  startEmbeddedAuth(sourceElement, request) {
+    if (this.authInProgress) return;
+    let auth = this.options.auth ?? {}, clientId = auth.clientId ?? readPublicEnv("NEXT_PUBLIC_CIMPLIFY_CLIENT_ID"), redirectUri = auth.redirectUri ?? readPublicEnv("NEXT_PUBLIC_CIMPLIFY_REDIRECT_URI");
+    if (!clientId || !redirectUri) {
+      sourceElement._emitError({
+        code: chunkUCR5HRYM_js.ErrorCode.AUTH_CONFIG_REQUIRED,
+        message: "Cimplify OAuth clientId and redirectUri are required."
+      });
+      return;
+    }
+    let generation = ++this.authGeneration;
+    this.authInProgress = true, startSignIn({
+      clientId,
+      redirectUri,
+      callbackUri: auth.callbackUri,
+      scope: auth.scope,
+      issuer: auth.issuer,
+      authUrl: auth.authUrl,
+      loginHint: request.loginHint,
+      prompt: request.prompt,
+      uiMode: request.mode,
+      mode: "modal",
+      silentFirst: request.mode === ELEMENTS_AUTH_MODES.CHECKOUT && request.prompt !== ELEMENTS_AUTH_PROMPTS.LOGIN,
+      onSuccess: async ({ accessToken }) => {
+        if (this.authGeneration !== generation) return;
+        if (this.authInProgress = false, !accessToken) {
+          sourceElement._emitError({
+            code: chunkUCR5HRYM_js.ErrorCode.AUTH_CALLBACK_MISSING_TOKEN,
+            message: "Sign-in callback did not return an access token."
+          });
+          return;
+        }
+        let application = await this.applyAccessToken(accessToken, generation);
+        application.kind === "authenticated" ? (this._syncHostSession(), sourceElement._emitAuthenticated(application.data)) : application.kind === "claim_failed" && sourceElement._emitError({
+          code: application.code,
+          message: application.message
+        });
+      },
+      onError: (err2) => {
+        this.authGeneration === generation && (this.authInProgress = false, sourceElement._emitError({
+          code: err2.error,
+          message: err2.description ?? err2.error
+        }));
+      }
+    }).catch((error) => {
+      this.authGeneration === generation && (this.authInProgress = false, sourceElement._emitError({
+        code: chunkUCR5HRYM_js.ErrorCode.AUTH_START_FAILED,
+        message: error instanceof Error ? error.message : "Unable to start sign-in."
+      }));
+    });
+  }
+  handleMessage(event) {
+    if (!isAllowedOrigin(event.origin))
+      return;
+    let message = parseIframeMessage(event.data);
+    if (!message) return;
+    let sourceElement = this.sourceElementFor(event, message);
+    if (sourceElement)
+      switch (message.type) {
+        case MESSAGE_TYPES.AUTH_REQUESTED:
+          this.startEmbeddedAuth(sourceElement, message);
+          break;
+        case MESSAGE_TYPES.SESSION_ESTABLISHED:
+          this.adoptEstablishedSession(sourceElement, message);
+          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:
+          this.customerData || (this.customerData = { name: "", email: null, phone: null }), message.contactType === ELEMENTS_AUTH_CONTACT_TYPES.EMAIL ? this.customerData.email = message.contact : this.customerData.phone = message.contact;
+          break;
+        case MESSAGE_TYPES.CONTINUE_WITHOUT_SAVED_DETAILS: {
+          this.authGeneration += 1, this.authInProgress = false;
+          let carriedIdentityAuthority = !!this.client.getAccessToken() || this.client.hasClaimedSessionAuthority();
+          this.forgetIdentity(), this.customerData = { name: "", email: null, phone: null }, carriedIdentityAuthority ? this.client.clearSession() : this.client.setAccessToken(null), this.broadcastClearedSession(), message.contactType === ELEMENTS_AUTH_CONTACT_TYPES.EMAIL ? this.customerData.email = message.contact : this.customerData.phone = message.contact;
+          break;
+        }
+        case MESSAGE_TYPES.LOGOUT_COMPLETE:
+          this.authGeneration += 1, this.authInProgress = false, this.checkoutInProgress && this.activeCheckoutAbort && this.activeCheckoutAbort(), this.forgetIdentity(), this.client.clearSession(), this.broadcastClearedSession();
+          break;
+      }
+  }
+  _setAddressData(data) {
+    this.addressData = data;
+  }
+  _setPaymentData(data) {
+    this.paymentData = data;
+  }
+  _setGuestContact(contact, contactType) {
+    this.customerData || (this.customerData = { name: "", email: null, phone: null }), contactType === ELEMENTS_AUTH_CONTACT_TYPES.EMAIL ? this.customerData.email = contact : this.customerData.phone = contact;
+  }
+};
+function createEventHandlers() {
+  return {
+    [EVENT_TYPES.READY]: /* @__PURE__ */ new Set(),
+    [EVENT_TYPES.AUTHENTICATED]: /* @__PURE__ */ new Set(),
+    [EVENT_TYPES.ERROR]: /* @__PURE__ */ new Set(),
+    [EVENT_TYPES.CHANGE]: /* @__PURE__ */ new Set(),
+    [EVENT_TYPES.BLUR]: /* @__PURE__ */ new Set(),
+    [EVENT_TYPES.FOCUS]: /* @__PURE__ */ new Set(),
+    [EVENT_TYPES.ORDER_TYPE_CHANGED]: /* @__PURE__ */ new Set(),
+    [EVENT_TYPES.REQUEST_SUBMIT]: /* @__PURE__ */ new Set(),
+    [EVENT_TYPES.CHECKOUT_STATUS]: /* @__PURE__ */ new Set(),
+    [EVENT_TYPES.CHECKOUT_COMPLETE]: /* @__PURE__ */ new Set()
+  };
+}
+var CimplifyElement = class {
+  constructor(type, businessId, linkUrl, options, parent) {
+    this.iframe = null;
+    this.container = null;
+    this.mounted = false;
+    this.ready = false;
+    this.pendingMessages = [];
+    this.pendingInit = null;
+    this.destroyed = false;
+    this.eventHandlers = createEventHandlers();
+    this.resolvers = /* @__PURE__ */ new Map();
+    this.lastReportedHeight = 0;
+    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), this.boundHandleResize = () => this.applyHeight(), typeof window < "u" && (window.addEventListener("message", this.boundHandleMessage), window.addEventListener("resize", this.boundHandleResize), this.listening = true);
+  }
+  /**
+   * Size the iframe to the element's reported content height (in pixels). We do
+   * NOT cap checkout at the viewport: capping forced a tall checkout to scroll
+   * *inside* a viewport-height iframe — a nested scroll-within-scroll. Sizing to
+   * content lets the iframe grow and the host page scroll naturally as one
+   * surface, which is the standard embedded-checkout behaviour.
+   */
+  applyHeight(reportedHeight) {
+    if (!this.iframe) return;
+    typeof reportedHeight == "number" && reportedHeight > 0 && (this.lastReportedHeight = reportedHeight);
+    let content = this.lastReportedHeight;
+    content && (this.iframe.style.height = `${Math.max(320, content)}px`);
+  }
+  mount(container) {
+    if (this.mounted) {
+      console.warn(`Element ${this.type} is already mounted`);
+      return;
+    }
+    let target = typeof container == "string" ? document.querySelector(container) : container;
+    if (!target) {
+      console.error(`Container not found: ${container}`);
+      return;
+    }
+    this.container = target, this.mounted = true, !this.listening && typeof window < "u" && (window.addEventListener("message", this.boundHandleMessage), this.listening = true), this.createIframe();
+  }
+  destroy() {
+    this.iframe && (this.iframe.remove(), this.iframe = null), this.container = null, this.mounted = false, this.ready = false, this.destroyed = true, this.pendingMessages = [], this.eventHandlers = createEventHandlers(), this.resolvers.forEach((entry) => clearTimeout(entry.timeoutId)), this.resolvers.clear(), this.listening && typeof window < "u" && (window.removeEventListener("message", this.boundHandleMessage), window.removeEventListener("resize", this.boundHandleResize), this.listening = false), this.parent._removeElement(this.type, this);
+  }
+  on(event, handler) {
+    this.eventHandlers[event].add(handler);
+  }
+  off(event, handler) {
+    this.eventHandlers[event].delete(handler);
+  }
+  async getData() {
+    return this.isMounted() ? new Promise((resolve) => {
+      let id = Math.random().toString(36).slice(2), timeoutId = setTimeout(() => {
+        let entry = this.resolvers.get(id);
+        entry && (this.resolvers.delete(id), entry.resolve(null));
+      }, 5e3);
+      this.resolvers.set(id, { resolve, timeoutId }), this.sendMessage({ type: MESSAGE_TYPES.GET_DATA });
+    }) : null;
+  }
+  setCart(cart) {
+    this.sendMessage({ type: MESSAGE_TYPES.SET_CART, cart });
+  }
+  /**
+   * Posts to the element. Until its iframe exists and reports READY (before
+   * `mount`, while the business id resolves, or while the iframe loads) the
+   * message is queued and sent on READY; a newer cart replaces a queued one.
+   * A destroyed element, or one whose iframe was removed from the page, drops it.
+   */
+  sendMessage(message) {
+    if (this.destroyed) return;
+    let iframe = this.iframe;
+    if (iframe && !iframe.isConnected) {
+      console.warn("[cimplify:checkout] sendMessage DROPPED \u2014 iframe detached", {
+        type: message.type
+      });
+      return;
+    }
+    if (!iframe || !this.ready || !iframe.contentWindow) {
+      this.queue(message);
+      return;
+    }
+    iframe.contentWindow.postMessage(message, this.linkUrl);
+  }
+  queue(message) {
+    message.type === MESSAGE_TYPES.SET_CART && (this.pendingMessages = this.pendingMessages.filter(
+      (queued) => queued.type !== MESSAGE_TYPES.SET_CART
+    )), this.pendingMessages.push(message);
+  }
+  flushPending() {
+    if (!this.ready || !this.iframe?.contentWindow) return;
+    let queue = this.pendingMessages;
+    this.pendingMessages = [];
+    for (let message of queue)
+      this.iframe.contentWindow.postMessage(message, this.linkUrl);
+  }
+  getContentWindow() {
+    return this.iframe?.contentWindow ?? null;
+  }
+  isMounted() {
+    return this.mounted && !!this.iframe && this.iframe?.isConnected === true;
+  }
+  _acceptsMessageEvent(event, message) {
+    let iframeWindow = this.iframe?.contentWindow;
+    return !iframeWindow || event.source !== iframeWindow ? false : message.nonce === this.nonce;
+  }
+  _emitAuthenticated(data) {
+    this.emit(EVENT_TYPES.AUTHENTICATED, data);
+  }
+  _emitError(error) {
+    this.emit(EVENT_TYPES.ERROR, error);
+  }
+  async createIframe() {
+    if (!this.container) return;
+    let 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: chunkUCR5HRYM_js.ErrorCode.BUSINESS_ID_REQUIRED,
+        message: "Unable to initialize checkout without a business ID."
+      });
+      return;
+    }
+    this.businessId = resolvedBusinessId;
+    let iframe = document.createElement("iframe"), url = new URL(`${this.linkUrl}/elements/${this.type}`);
+    url.searchParams.set("businessId", resolvedBusinessId), url.searchParams.set("nonce", this.nonce);
+    let publicKey = this.parent.getPublicKey().trim();
+    publicKey && url.searchParams.set("publicKey", publicKey), this.options.prefillEmail && url.searchParams.set("email", this.options.prefillEmail), 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", ELEMENT_IFRAME_PERMISSIONS), 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;
+    let message = parseIframeMessage(event.data);
+    if (message && this._acceptsMessageEvent(event, message))
+      switch (message.type) {
+        case MESSAGE_TYPES.READY:
+          if (this.ready = true, message.height && this.applyHeight(message.height), this.pendingInit) {
+            let { publicKey } = this.pendingInit;
+            this.sendMessage({
+              type: MESSAGE_TYPES.INIT,
+              businessId: this.pendingInit.businessId,
+              publicKey,
+              prefillEmail: this.options.prefillEmail,
+              appearance: this.parent.getAppearance(),
+              orderTypes: this.options.orderTypes,
+              defaultOrderType: this.options.defaultOrderType,
+              renderSubmitButton: true,
+              submitLabel: this.options.submitLabel,
+              intentId: this.options.intentId,
+              hostedSessionId: this.options.hostedSessionId,
+              initialTerms: this.options.initialTerms,
+              offerSaveDetails: this.options.offerSaveDetails ?? false
+            }), this.parent._syncHostSession(this), this.pendingInit = null;
+          }
+          this.flushPending(), this.emit(EVENT_TYPES.READY, { height: message.height });
+          break;
+        case MESSAGE_TYPES.HEIGHT_CHANGE:
+          this.applyHeight(message.height);
+          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;
+        case MESSAGE_TYPES.CHECKOUT_STATUS:
+          this.parent._isCheckoutInProgress() || this.emit(EVENT_TYPES.CHECKOUT_STATUS, {
+            status: message.status,
+            context: message.context
+          });
+          break;
+        case MESSAGE_TYPES.CHECKOUT_COMPLETE:
+          this.parent._isCheckoutInProgress() || this.emit(EVENT_TYPES.CHECKOUT_COMPLETE, {
+            success: message.success,
+            order: message.order,
+            error: message.error,
+            enrolled_in_link: message.enrolled_in_link
+          });
+          break;
+      }
+  }
+  emit(event, data) {
+    this.eventHandlers[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.AUTH_TOKEN_CHANGED = AUTH_TOKEN_CHANGED;
+exports.AuthService = AuthService;
+exports.BusinessService = BusinessService;
+exports.CartOperations = CartOperations;
+exports.CatalogueQueries = CatalogueQueries;
+exports.CheckoutService = CheckoutService;
+exports.CimplifyElement = CimplifyElement;
+exports.CimplifyElements = CimplifyElements;
+exports.DEFAULT_ISSUER = DEFAULT_ISSUER;
+exports.ELEMENTS_AUTH_CONTACT_TYPES = ELEMENTS_AUTH_CONTACT_TYPES;
+exports.ELEMENTS_AUTH_MODES = ELEMENTS_AUTH_MODES;
+exports.ELEMENTS_AUTH_PROMPTS = ELEMENTS_AUTH_PROMPTS;
+exports.ELEMENT_TYPES = ELEMENT_TYPES;
+exports.EVENT_TYPES = EVENT_TYPES;
+exports.FxService = FxService;
+exports.InventoryService = InventoryService;
+exports.LinkService = LinkService;
+exports.LiteService = LiteService;
+exports.MESSAGE_TYPES = MESSAGE_TYPES;
+exports.MUTATION_ERROR = MUTATION_ERROR;
+exports.OrderQueries = OrderQueries;
+exports.PAYMENT_AUTHORIZATION_OUTCOME_STATUS = PAYMENT_AUTHORIZATION_OUTCOME_STATUS;
+exports.PAYMENT_AUTHORIZATION_PROVIDER = PAYMENT_AUTHORIZATION_PROVIDER;
+exports.PKCE_COOKIE = PKCE_COOKIE;
+exports.PKCE_COOKIE_PATH = PKCE_COOKIE_PATH;
+exports.PaymentAuthorizationAdapterRegistry = PaymentAuthorizationAdapterRegistry;
+exports.PaystackAuthorizationAdapter = PaystackAuthorizationAdapter;
+exports.SESSION_CLAIMED = SESSION_CLAIMED;
+exports.SESSION_CLEARED = SESSION_CLEARED;
+exports.SchedulingService = SchedulingService;
+exports.StripeAuthorizationAdapter = StripeAuthorizationAdapter;
+exports.clearIntentIdempotencyKey = clearIntentIdempotencyKey;
+exports.combine = combine;
+exports.combineObject = combineObject;
+exports.confirmationForUnchangedReplacement = confirmationForUnchangedReplacement;
+exports.createClientEvents = createClientEvents;
+exports.createDefaultPaymentAuthorizationAdapterRegistry = createDefaultPaymentAuthorizationAdapterRegistry;
+exports.createElements = createElements;
+exports.createPurchaseIntentConfirmation = createPurchaseIntentConfirmation;
+exports.decodePkceState = decodePkceState;
+exports.err = err;
+exports.flatMap = flatMap;
+exports.fromPromise = fromPromise;
+exports.generateIdempotencyKey = generateIdempotencyKey;
+exports.generatePkce = generatePkce;
+exports.generateState = generateState;
+exports.getAuthorizationEndpoint = getAuthorizationEndpoint;
+exports.getOrElse = getOrElse;
+exports.intentIdempotencyKey = intentIdempotencyKey;
+exports.isErr = isErr;
+exports.isOk = isOk;
+exports.mapError = mapError;
+exports.mapResult = mapResult;
+exports.ok = ok;
+exports.purchaseIntentRequiresPaymentOption = purchaseIntentRequiresPaymentOption;
+exports.safe = safe;
+exports.selectPurchaseIntentPaymentOption = selectPurchaseIntentPaymentOption;
+exports.startSignIn = startSignIn;
+exports.toNullable = toNullable;
+exports.tryCatch = tryCatch;
+exports.unwrap = unwrap;