@cimplify/sdk 0.6.11 → 0.7.0

package/dist/index.js

@@ -33,6 +33,11 @@ var ErrorCode = {
   CHECKOUT_VALIDATION_FAILED: "CHECKOUT_VALIDATION_FAILED",
   DELIVERY_ADDRESS_REQUIRED: "DELIVERY_ADDRESS_REQUIRED",
   CUSTOMER_INFO_REQUIRED: "CUSTOMER_INFO_REQUIRED",
+  // Quote
+  QUOTE_NOT_FOUND: "QUOTE_NOT_FOUND",
+  QUOTE_EXPIRED: "QUOTE_EXPIRED",
+  QUOTE_CONSUMED: "QUOTE_CONSUMED",
+  QUOTE_STORAGE_UNAVAILABLE: "QUOTE_STORAGE_UNAVAILABLE",
   // Payment
   PAYMENT_FAILED: "PAYMENT_FAILED",
   PAYMENT_CANCELLED: "PAYMENT_CANCELLED",
@@ -73,6 +78,10 @@ var ERROR_SUGGESTIONS = {
   CHECKOUT_VALIDATION_FAILED: "Checkout payload failed validation. Verify customer, order type, and address fields are complete.",
   DELIVERY_ADDRESS_REQUIRED: "Delivery orders require an address. Collect and pass address info before processing checkout.",
   CUSTOMER_INFO_REQUIRED: "Customer details are required. Ensure name/email/phone are available before checkout.",
+  QUOTE_NOT_FOUND: "Quote could not be found. Refresh pricing and create a new quote before checkout.",
+  QUOTE_EXPIRED: "Quote has expired. Re-fetch pricing to generate a new quote with a valid expiry window.",
+  QUOTE_CONSUMED: "Quote has already been used. Request a fresh quote to prevent duplicate checkout attempts.",
+  QUOTE_STORAGE_UNAVAILABLE: "Quote storage is temporarily unavailable. Retry shortly and avoid charging until quote fetch succeeds.",
   PAYMENT_FAILED: "Payment provider rejected or failed processing. Show retry/change-method options to the shopper.",
   PAYMENT_CANCELLED: "Payment was cancelled by the shopper or provider flow. Allow a safe retry path.",
   INSUFFICIENT_FUNDS: "Payment method has insufficient funds. Prompt shopper to use another method.",
@@ -312,6 +321,23 @@ async function safe(promise) {
     return err(toCimplifyError(error));
   }
 }
+async function safeWithFallback(primary, fallback) {
+  const primaryResult = await safe(primary());
+  if (primaryResult.ok) return primaryResult;
+  if (primaryResult.error.code !== "HTTP_404" && primaryResult.error.code !== "API_ERROR") {
+    return primaryResult;
+  }
+  return safe(fallback());
+}
+function withQuery(path, params) {
+  const query2 = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0) continue;
+    query2.set(key, String(value));
+  }
+  const queryString = query2.toString();
+  return queryString ? `${path}?${queryString}` : path;
+}
 function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
@@ -369,6 +395,69 @@ function findProductBySlug(products, slug) {
     return typeof value === "string" && value === slug;
   });
 }
+function findCategoryBySlug(categories, slug) {
+  return categories.find((category) => {
+    const value = category["slug"];
+    return typeof value === "string" && value === slug;
+  });
+}
+function hasCategorySlug(category) {
+  const value = category["slug"];
+  return typeof value === "string" && value.trim().length > 0;
+}
+function toFiniteNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
+  }
+  return void 0;
+}
+function normalizePagination(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const totalCount = toFiniteNumber(value.total_count);
+  const currentPage = toFiniteNumber(value.current_page);
+  const pageSize = toFiniteNumber(value.page_size);
+  const totalPages = toFiniteNumber(value.total_pages);
+  if (totalCount === void 0 || currentPage === void 0 || pageSize === void 0 || totalPages === void 0) {
+    return void 0;
+  }
+  return {
+    total_count: totalCount,
+    current_page: currentPage,
+    page_size: pageSize,
+    total_pages: totalPages,
+    has_more: value.has_more === true,
+    next_cursor: typeof value.next_cursor === "string" ? value.next_cursor : void 0
+  };
+}
+function normalizeCatalogueResult(payload) {
+  if (Array.isArray(payload)) {
+    return {
+      items: payload.map((product) => normalizeCatalogueProductPayload(product)),
+      is_complete: true
+    };
+  }
+  if (!isRecord(payload)) {
+    return {
+      items: [],
+      is_complete: true
+    };
+  }
+  const rawItems = Array.isArray(payload.products) ? payload.products : Array.isArray(payload.items) ? payload.items : [];
+  return {
+    items: rawItems.map((product) => normalizeCatalogueProductPayload(product)),
+    is_complete: typeof payload.is_complete === "boolean" ? payload.is_complete : true,
+    total_available: toFiniteNumber(payload.total_available),
+    pagination: normalizePagination(payload.pagination)
+  };
+}
 var CatalogueQueries = class {
   constructor(client) {
     this.client = client;
@@ -388,6 +477,13 @@ var CatalogueQueries = class {
     if (options?.search) {
       filters.push(`@.name contains '${escapeQueryValue(options.search)}'`);
     }
+    if (options?.tags?.length) {
+      for (const tag of options.tags) {
+        if (tag.trim().length > 0) {
+          filters.push(`@.tags contains '${escapeQueryValue(tag)}'`);
+        }
+      }
+    }
     if (options?.min_price !== void 0) {
       filters.push(`@.price>=${options.min_price}`);
     }
@@ -400,25 +496,57 @@ var CatalogueQueries = class {
     if (options?.sort_by) {
       query2 += `#sort(${options.sort_by},${options.sort_order || "asc"})`;
     }
-    if (options?.limit) {
+    if (options?.limit !== void 0) {
       query2 += `#limit(${options.limit})`;
     }
-    if (options?.offset) {
+    if (options?.offset !== void 0) {
       query2 += `#offset(${options.offset})`;
     }
-    const result = await safe(this.client.query(query2));
+    const path = withQuery("/api/v1/catalogue/products", {
+      category_id: options?.category,
+      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
+    });
+    const result = await safeWithFallback(
+      () => this.client.get(path),
+      () => this.client.query(query2)
+    );
     if (!result.ok) return result;
-    return ok(result.value.map((product) => normalizeCatalogueProductPayload(product)));
+    return ok(normalizeCatalogueResult(result.value));
   }
   async getProduct(id) {
-    const result = await safe(this.client.query(`products.${id}`));
+    const encodedId = encodeURIComponent(id);
+    const result = await safeWithFallback(
+      () => this.client.get(`/api/v1/catalogue/products/${encodedId}`),
+      () => this.client.query(`products.${id}`)
+    );
     if (!result.ok) return result;
     return ok(normalizeCatalogueProductPayload(result.value));
   }
   async getProductBySlug(slug) {
+    const encodedSlug = encodeURIComponent(slug);
+    const restResult = await safe(
+      this.client.get(`/api/v1/catalogue/products/slug/${encodedSlug}`)
+    );
+    if (restResult.ok) {
+      return ok(normalizeCatalogueProductPayload(restResult.value));
+    }
+    if (restResult.error.code !== "HTTP_404" && restResult.error.code !== "API_ERROR") {
+      return restResult;
+    }
     const filteredResult = await safe(
       this.client.query(
-        `products[?(@.slug=='${escapeQueryValue(slug)}')]`
+        `products[?(@.slug=='${escapeQueryValue(slug)}')]#limit(50)`
       )
     );
     if (!filteredResult.ok) return filteredResult;
@@ -429,7 +557,9 @@ var CatalogueQueries = class {
     if (filteredResult.value.length === 1) {
       return ok(normalizeCatalogueProductPayload(filteredResult.value[0]));
     }
-    const unfilteredResult = await safe(this.client.query("products"));
+    const unfilteredResult = await safe(
+      this.client.query("products#limit(200)")
+    );
     if (!unfilteredResult.ok) return unfilteredResult;
     const fallbackMatch = findProductBySlug(unfilteredResult.value, slug);
     if (!fallbackMatch) {
@@ -438,18 +568,33 @@ var CatalogueQueries = class {
     return ok(normalizeCatalogueProductPayload(fallbackMatch));
   }
   async getVariants(productId) {
-    return safe(this.client.query(`products.${productId}.variants`));
+    const encodedId = encodeURIComponent(productId);
+    return safeWithFallback(
+      () => this.client.get(`/api/v1/catalogue/products/${encodedId}/variants`),
+      () => this.client.query(`products.${productId}.variants`)
+    );
   }
   async getVariantAxes(productId) {
-    return safe(this.client.query(`products.${productId}.variant_axes`));
+    const encodedId = encodeURIComponent(productId);
+    return safeWithFallback(
+      () => this.client.get(`/api/v1/catalogue/products/${encodedId}/variant-axes`),
+      () => this.client.query(`products.${productId}.variant_axes`)
+    );
   }
   /**
    * Find a variant by axis selections (e.g., { "Size": "Large", "Color": "Red" })
    * Returns the matching variant or null if no match found.
    */
   async getVariantByAxisSelections(productId, selections) {
-    return safe(
-      this.client.query(`products.${productId}.variant`, {
+    const encodedId = encodeURIComponent(productId);
+    return safeWithFallback(
+      () => this.client.post(
+        `/api/v1/catalogue/products/${encodedId}/variants/find`,
+        {
+          axis_selections: selections
+        }
+      ),
+      () => this.client.query(`products.${productId}.variant`, {
         axis_selections: selections
       })
     );
@@ -458,45 +603,107 @@ var CatalogueQueries = class {
    * Get a specific variant by its ID
    */
   async getVariantById(productId, variantId) {
-    return safe(this.client.query(`products.${productId}.variant.${variantId}`));
+    const encodedProductId = encodeURIComponent(productId);
+    const encodedVariantId = encodeURIComponent(variantId);
+    return safeWithFallback(
+      () => this.client.get(
+        `/api/v1/catalogue/products/${encodedProductId}/variants/${encodedVariantId}`
+      ),
+      () => this.client.query(`products.${productId}.variant.${variantId}`)
+    );
   }
   async getAddOns(productId) {
-    return safe(this.client.query(`products.${productId}.add_ons`));
+    const encodedId = encodeURIComponent(productId);
+    return safeWithFallback(
+      () => this.client.get(`/api/v1/catalogue/products/${encodedId}/add-ons`),
+      () => this.client.query(`products.${productId}.add_ons`)
+    );
   }
   async getCategories() {
-    return safe(this.client.query("categories"));
+    const result = await safeWithFallback(
+      () => this.client.get("/api/v1/catalogue/categories"),
+      () => this.client.query("categories")
+    );
+    if (!result.ok) return result;
+    if (result.value.some(hasCategorySlug)) {
+      return result;
+    }
+    const catalogueResult = await safe(
+      this.client.query("catalogue#limit(1)")
+    );
+    if (!catalogueResult.ok) {
+      return result;
+    }
+    const fallbackCategories = Array.isArray(catalogueResult.value.categories) ? catalogueResult.value.categories : [];
+    return fallbackCategories.length > 0 ? ok(fallbackCategories) : result;
   }
   async getCategory(id) {
-    return safe(this.client.query(`categories.${id}`));
+    const encodedId = encodeURIComponent(id);
+    return safeWithFallback(
+      () => this.client.get(`/api/v1/catalogue/categories/${encodedId}`),
+      () => this.client.query(`categories.${id}`)
+    );
   }
   async getCategoryBySlug(slug) {
+    const encodedSlug = encodeURIComponent(slug);
+    const restResult = await safe(this.client.get(`/api/v1/catalogue/categories/slug/${encodedSlug}`));
+    if (restResult.ok) {
+      return restResult;
+    }
+    if (restResult.error.code !== "HTTP_404" && restResult.error.code !== "API_ERROR") {
+      return restResult;
+    }
     const result = await safe(
       this.client.query(`categories[?(@.slug=='${escapeQueryValue(slug)}')]`)
     );
     if (!result.ok) return result;
-    if (!result.value.length) {
+    const exactMatch = findCategoryBySlug(result.value, slug);
+    if (exactMatch) {
+      return ok(exactMatch);
+    }
+    const categoriesResult = await this.getCategories();
+    if (!categoriesResult.ok) {
+      return categoriesResult;
+    }
+    const fallbackMatch = findCategoryBySlug(categoriesResult.value, slug);
+    if (!fallbackMatch) {
       return err(new CimplifyError("NOT_FOUND", `Category not found: ${slug}`, false));
     }
-    return ok(result.value[0]);
+    return ok(fallbackMatch);
   }
   async getCategoryProducts(categoryId) {
-    return safe(
-      this.client.query(
+    const encodedId = encodeURIComponent(categoryId);
+    return safeWithFallback(
+      () => this.client.get(`/api/v1/catalogue/categories/${encodedId}/products`),
+      () => this.client.query(
         `products[?(@.category_id=='${escapeQueryValue(categoryId)}')]`
       )
     );
   }
   async getCollections() {
-    return safe(this.client.query("collections"));
+    return safeWithFallback(
+      () => this.client.get("/api/v1/catalogue/collections"),
+      () => this.client.query("collections")
+    );
   }
   async getCollection(id) {
-    return safe(this.client.query(`collections.${id}`));
+    const encodedId = encodeURIComponent(id);
+    return safeWithFallback(
+      () => this.client.get(`/api/v1/catalogue/collections/${encodedId}`),
+      () => this.client.query(`collections.${id}`)
+    );
   }
   async getCollectionBySlug(slug) {
+    const encodedSlug = encodeURIComponent(slug);
+    const restResult = await safe(
+      this.client.get(`/api/v1/catalogue/collections/slug/${encodedSlug}`)
+    );
+    if (restResult.ok) return restResult;
+    if (restResult.error.code !== "HTTP_404" && restResult.error.code !== "API_ERROR") {
+      return restResult;
+    }
     const result = await safe(
-      this.client.query(
-        `collections[?(@.slug=='${escapeQueryValue(slug)}')]`
-      )
+      this.client.query(`collections[?(@.slug=='${escapeQueryValue(slug)}')]`)
     );
     if (!result.ok) return result;
     if (!result.value.length) {
@@ -505,22 +712,43 @@ var CatalogueQueries = class {
     return ok(result.value[0]);
   }
   async getCollectionProducts(collectionId) {
-    return safe(this.client.query(`collections.${collectionId}.products`));
+    const encodedId = encodeURIComponent(collectionId);
+    return safeWithFallback(
+      () => this.client.get(`/api/v1/catalogue/collections/${encodedId}/products`),
+      () => this.client.query(`collections.${collectionId}.products`)
+    );
   }
   async searchCollections(query2, limit = 20) {
-    return safe(
-      this.client.query(
+    const path = withQuery("/api/v1/catalogue/collections", { search: query2, limit });
+    return safeWithFallback(
+      () => this.client.get(path),
+      () => this.client.query(
         `collections[?(@.name contains '${escapeQueryValue(query2)}')]#limit(${limit})`
       )
     );
   }
   async getBundles() {
-    return safe(this.client.query("bundles"));
+    return safeWithFallback(
+      () => this.client.get("/api/v1/catalogue/bundles"),
+      () => this.client.query("bundles")
+    );
   }
   async getBundle(id) {
-    return safe(this.client.query(`bundles.${id}`));
+    const encodedId = encodeURIComponent(id);
+    return safeWithFallback(
+      () => this.client.get(`/api/v1/catalogue/bundles/${encodedId}`),
+      () => this.client.query(`bundles.${id}`)
+    );
   }
   async getBundleBySlug(slug) {
+    const encodedSlug = encodeURIComponent(slug);
+    const restResult = await safe(
+      this.client.get(`/api/v1/catalogue/bundles/slug/${encodedSlug}`)
+    );
+    if (restResult.ok) return restResult;
+    if (restResult.error.code !== "HTTP_404" && restResult.error.code !== "API_ERROR") {
+      return restResult;
+    }
     const result = await safe(
       this.client.query(
         `bundles[?(@.slug=='${escapeQueryValue(slug)}')]`
@@ -533,8 +761,10 @@ var CatalogueQueries = class {
     return ok(result.value[0]);
   }
   async searchBundles(query2, limit = 20) {
-    return safe(
-      this.client.query(
+    const path = withQuery("/api/v1/catalogue/bundles", { search: query2, limit });
+    return safeWithFallback(
+      () => this.client.get(path),
+      () => this.client.query(
         `bundles[?(@.name contains '${escapeQueryValue(query2)}')]#limit(${limit})`
       )
     );
@@ -544,17 +774,39 @@ var CatalogueQueries = class {
     if (options?.limit) {
       query2 += `#limit(${options.limit})`;
     }
-    return safe(this.client.query(query2));
+    const path = withQuery("/api/v1/catalogue/composites", { limit: options?.limit });
+    return safeWithFallback(
+      () => this.client.get(path),
+      () => this.client.query(query2)
+    );
   }
   async getComposite(id) {
-    return safe(this.client.query(`composites.${id}`));
+    const encodedId = encodeURIComponent(id);
+    return safeWithFallback(
+      () => this.client.get(`/api/v1/catalogue/composites/${encodedId}`),
+      () => this.client.query(`composites.${id}`)
+    );
   }
   async getCompositeByProductId(productId) {
-    return safe(this.client.query(`composites.by_product.${productId}`));
+    const encodedId = encodeURIComponent(productId);
+    return safeWithFallback(
+      () => this.client.get(
+        `/api/v1/catalogue/composites/by-product/${encodedId}`
+      ),
+      () => this.client.query(`composites.by_product.${productId}`)
+    );
   }
   async calculateCompositePrice(compositeId, selections, locationId) {
-    return safe(
-      this.client.call("composite.calculatePrice", {
+    const encodedId = encodeURIComponent(compositeId);
+    return safeWithFallback(
+      () => this.client.post(
+        `/api/v1/catalogue/composites/${encodedId}/calculate-price`,
+        {
+          selections,
+          location_id: locationId
+        }
+      ),
+      () => this.client.call("composite.calculatePrice", {
         composite_id: compositeId,
         selections,
         location_id: locationId
@@ -562,35 +814,41 @@ var CatalogueQueries = class {
     );
   }
   async fetchQuote(input) {
-    return safe(this.client.call("catalogue.createQuote", input));
+    return safeWithFallback(
+      () => this.client.post("/api/v1/catalogue/quotes", input),
+      () => this.client.call("catalogue.createQuote", input)
+    );
   }
   async getQuote(quoteId) {
-    return safe(
-      this.client.call("catalogue.getQuote", {
+    const encodedQuoteId = encodeURIComponent(quoteId);
+    return safeWithFallback(
+      () => this.client.get(`/api/v1/catalogue/quotes/${encodedQuoteId}`),
+      () => this.client.call("catalogue.getQuote", {
         quote_id: quoteId
       })
     );
   }
   async refreshQuote(input) {
-    return safe(this.client.call("catalogue.refreshQuote", input));
+    const encodedQuoteId = encodeURIComponent(input.quote_id);
+    return safeWithFallback(
+      () => this.client.post(
+        `/api/v1/catalogue/quotes/${encodedQuoteId}/refresh`,
+        input
+      ),
+      () => this.client.call("catalogue.refreshQuote", input)
+    );
   }
   async search(query2, options) {
-    const limit = options?.limit ?? 20;
-    let searchQuery = `products[?(@.name contains '${escapeQueryValue(query2)}')]`;
-    if (options?.category) {
-      searchQuery = `products[?(@.name contains '${escapeQueryValue(query2)}' && @.category_id=='${escapeQueryValue(options.category)}')]`;
-    }
-    searchQuery += `#limit(${limit})`;
-    return safe(this.client.query(searchQuery));
+    const result = await this.getProducts({
+      search: query2,
+      category: options?.category,
+      limit: options?.limit ?? 20
+    });
+    if (!result.ok) return result;
+    return ok(result.value.items);
   }
   async searchProducts(query2, options) {
-    return safe(
-      this.client.call("catalogue.search", {
-        query: query2,
-        limit: options?.limit ?? 20,
-        category: options?.category
-      })
-    );
+    return this.search(query2, options);
   }
   async getMenu(options) {
     let query2 = "menu";
@@ -600,13 +858,28 @@ var CatalogueQueries = class {
     if (options?.limit) {
       query2 += `#limit(${options.limit})`;
     }
-    return safe(this.client.query(query2));
+    const path = withQuery("/api/v1/catalogue/menu", {
+      category_id: options?.category,
+      limit: options?.limit
+    });
+    return safeWithFallback(
+      () => this.client.get(path),
+      () => this.client.query(query2)
+    );
   }
   async getMenuCategory(categoryId) {
-    return safe(this.client.query(`menu.category.${categoryId}`));
+    const encodedId = encodeURIComponent(categoryId);
+    return safeWithFallback(
+      () => this.client.get(`/api/v1/catalogue/menu/categories/${encodedId}`),
+      () => this.client.query(`menu.category.${categoryId}`)
+    );
   }
   async getMenuItem(itemId) {
-    return safe(this.client.query(`menu.${itemId}`));
+    const encodedId = encodeURIComponent(itemId);
+    return safeWithFallback(
+      () => this.client.get(`/api/v1/catalogue/menu/items/${encodedId}`),
+      () => this.client.query(`menu.${itemId}`)
+    );
   }
 };
 
@@ -625,6 +898,14 @@ async function safe2(promise) {
     return err(toCimplifyError2(error));
   }
 }
+async function safeWithFallback2(primary, fallback) {
+  const primaryResult = await safe2(primary());
+  if (primaryResult.ok) return primaryResult;
+  if (primaryResult.error.code !== "HTTP_404" && primaryResult.error.code !== "API_ERROR") {
+    return primaryResult;
+  }
+  return safe2(fallback());
+}
 function isUICartResponse(value) {
   return "cart" in value;
 }
@@ -636,21 +917,36 @@ var CartOperations = class {
     this.client = client;
   }
   async get() {
-    const result = await safe2(this.client.query("cart#enriched"));
+    const result = await safeWithFallback2(
+      () => this.client.get("/api/v1/cart"),
+      () => this.client.query("cart#enriched")
+    );
     if (!result.ok) return result;
     return ok(unwrapEnrichedCart(result.value));
   }
   async getRaw() {
-    return safe2(this.client.query("cart"));
+    return safeWithFallback2(
+      () => this.client.get("/api/v1/cart"),
+      () => this.client.query("cart")
+    );
   }
   async getItems() {
-    return safe2(this.client.query("cart_items"));
+    return safeWithFallback2(
+      () => this.client.get("/api/v1/cart/items"),
+      () => this.client.query("cart_items")
+    );
   }
   async getCount() {
-    return safe2(this.client.query("cart#count"));
+    return safeWithFallback2(
+      () => this.client.get("/api/v1/cart/count"),
+      () => this.client.query("cart#count")
+    );
   }
   async getTotal() {
-    return safe2(this.client.query("cart#total"));
+    return safeWithFallback2(
+      () => this.client.get("/api/v1/cart/total"),
+      () => this.client.query("cart#total")
+    );
   }
   async getSummary() {
     const cartResult = await this.get();
@@ -667,43 +963,66 @@ var CartOperations = class {
     });
   }
   async addItem(input) {
-    return safe2(this.client.call("cart.addItem", input));
+    return safeWithFallback2(
+      () => this.client.post("/api/v1/cart/items", input),
+      () => this.client.call("cart.addItem", input)
+    );
   }
   async updateItem(cartItemId, updates) {
-    return safe2(
-      this.client.call("cart.updateItem", {
+    if (typeof updates.quantity === "number") {
+      return this.updateQuantity(cartItemId, updates.quantity);
+    }
+    const encodedId = encodeURIComponent(cartItemId);
+    return safeWithFallback2(
+      () => this.client.patch(`/api/v1/cart/items/${encodedId}`, updates),
+      () => this.client.call("cart.updateItem", {
         cart_item_id: cartItemId,
         ...updates
       })
     );
   }
   async updateQuantity(cartItemId, quantity) {
-    return safe2(
-      this.client.call("cart.updateItemQuantity", {
+    const encodedId = encodeURIComponent(cartItemId);
+    return safeWithFallback2(
+      () => this.client.patch(`/api/v1/cart/items/${encodedId}`, {
+        quantity
+      }),
+      () => this.client.call("cart.updateItemQuantity", {
         cart_item_id: cartItemId,
         quantity
       })
     );
   }
   async removeItem(cartItemId) {
-    return safe2(
-      this.client.call("cart.removeItem", {
+    const encodedId = encodeURIComponent(cartItemId);
+    return safeWithFallback2(
+      () => this.client.delete(`/api/v1/cart/items/${encodedId}`),
+      () => this.client.call("cart.removeItem", {
         cart_item_id: cartItemId
       })
     );
   }
   async clear() {
-    return safe2(this.client.call("cart.clearCart"));
+    return safeWithFallback2(
+      () => this.client.delete("/api/v1/cart"),
+      () => this.client.call("cart.clearCart")
+    );
   }
   async applyCoupon(code) {
-    return safe2(
-      this.client.call("cart.applyCoupon", {
+    return safeWithFallback2(
+      () => this.client.post("/api/v1/cart/coupons", {
+        coupon_code: code
+      }),
+      () => this.client.call("cart.applyCoupon", {
         coupon_code: code
       })
     );
   }
   async removeCoupon() {
-    return safe2(this.client.call("cart.removeCoupon"));
+    return safeWithFallback2(
+      () => this.client.delete("/api/v1/cart/coupons/current"),
+      () => this.client.call("cart.removeCoupon")
+    );
   }
   async isEmpty() {
     const countResult = await this.getCount();
@@ -984,6 +1303,25 @@ function parsePrice(value) {
   const parsed = parseFloat(cleaned);
   return isNaN(parsed) ? 0 : parsed;
 }
+function hasTaxInfo(priceInfo) {
+  return priceInfo.tax_info !== void 0 && priceInfo.tax_info !== null;
+}
+function getTaxAmount(priceInfo) {
+  return parsePrice(priceInfo.tax_info?.tax_amount);
+}
+function isTaxInclusive(priceInfo) {
+  return priceInfo.tax_info?.is_inclusive === true;
+}
+function formatPriceWithTax(priceInfo, currency = "GHS") {
+  const finalPrice = formatPrice(priceInfo.final_price, currency);
+  if (!hasTaxInfo(priceInfo)) {
+    return finalPrice;
+  }
+  if (isTaxInclusive(priceInfo)) {
+    return `${finalPrice} (incl. tax)`;
+  }
+  return `${finalPrice} + ${formatPrice(getTaxAmount(priceInfo), currency)} tax`;
+}
 function getDisplayPrice(product) {
   if (product.price_info) {
     return parsePrice(product.price_info.final_price);
@@ -1846,6 +2184,14 @@ async function safe3(promise) {
     return err(toCimplifyError3(error));
   }
 }
+async function safeWithFallback3(primary, fallback) {
+  const primaryResult = await safe3(primary());
+  if (primaryResult.ok) return primaryResult;
+  if (primaryResult.error.code !== "HTTP_404" && primaryResult.error.code !== "API_ERROR") {
+    return primaryResult;
+  }
+  return safe3(fallback());
+}
 function toTerminalFailure(code, message, recoverable) {
   return {
     success: false,
@@ -1873,8 +2219,11 @@ var CheckoutService = class {
       ...data,
       idempotency_key: data.idempotency_key || generateIdempotencyKey()
     };
-    return safe3(
-      this.client.call(CHECKOUT_MUTATION.PROCESS, {
+    return safeWithFallback3(
+      () => this.client.post("/api/v1/checkout", {
+        checkout_data: checkoutData
+      }),
+      () => this.client.call(CHECKOUT_MUTATION.PROCESS, {
         checkout_data: checkoutData
       })
     );
@@ -1888,18 +2237,23 @@ var CheckoutService = class {
     );
   }
   async submitAuthorization(input) {
-    return safe3(
-      this.client.call(PAYMENT_MUTATION.SUBMIT_AUTHORIZATION, input)
+    return safeWithFallback3(
+      () => this.client.post("/api/v1/payments/authorization", input),
+      () => this.client.call(PAYMENT_MUTATION.SUBMIT_AUTHORIZATION, input)
     );
   }
   async pollPaymentStatus(orderId) {
-    return safe3(
-      this.client.call(PAYMENT_MUTATION.CHECK_STATUS, orderId)
+    const encodedId = encodeURIComponent(orderId);
+    return safeWithFallback3(
+      () => this.client.get(`/api/v1/orders/${encodedId}/payment-status`),
+      () => this.client.call(PAYMENT_MUTATION.CHECK_STATUS, orderId)
     );
   }
   async updateOrderCustomer(orderId, customer) {
-    return safe3(
-      this.client.call(ORDER_MUTATION.UPDATE_CUSTOMER, {
+    const encodedId = encodeURIComponent(orderId);
+    return safeWithFallback3(
+      () => this.client.post(`/api/v1/orders/${encodedId}/customer`, customer),
+      () => this.client.call(ORDER_MUTATION.UPDATE_CUSTOMER, {
         order_id: orderId,
         ...customer
       })
@@ -2029,6 +2383,14 @@ async function safe4(promise) {
     return err(toCimplifyError4(error));
   }
 }
+async function safeWithFallback4(primary, fallback) {
+  const primaryResult = await safe4(primary());
+  if (primaryResult.ok) return primaryResult;
+  if (primaryResult.error.code !== "HTTP_404" && primaryResult.error.code !== "API_ERROR") {
+    return primaryResult;
+  }
+  return safe4(fallback());
+}
 var OrderQueries = class {
   constructor(client) {
     this.client = client;
@@ -2045,20 +2407,36 @@ var OrderQueries = class {
     if (options?.offset) {
       query2 += `#offset(${options.offset})`;
     }
-    return safe4(this.client.query(query2));
+    const params = new URLSearchParams();
+    if (options?.status) params.set("status", options.status);
+    if (options?.limit) params.set("limit", String(options.limit));
+    if (options?.offset) params.set("offset", String(options.offset));
+    const path = params.toString() ? `/api/v1/orders?${params.toString()}` : "/api/v1/orders";
+    return safeWithFallback4(
+      () => this.client.get(path),
+      () => this.client.query(query2)
+    );
   }
   async get(orderId) {
-    return safe4(this.client.query(`orders.${orderId}`));
+    const encodedId = encodeURIComponent(orderId);
+    return safeWithFallback4(
+      () => this.client.get(`/api/v1/orders/${encodedId}`),
+      () => this.client.query(`orders.${orderId}`)
+    );
   }
   async getRecent(limit = 5) {
     return safe4(this.client.query(`orders#sort(created_at,desc)#limit(${limit})`));
   }
   async getByStatus(status) {
-    return safe4(this.client.query(`orders[?(@.status=='${status}')]`));
+    return this.list({ status });
   }
   async cancel(orderId, reason) {
-    return safe4(
-      this.client.call("order.cancelOrder", {
+    const encodedId = encodeURIComponent(orderId);
+    return safeWithFallback4(
+      () => this.client.post(`/api/v1/orders/${encodedId}/cancel`, {
+        reason
+      }),
+      () => this.client.call("order.cancelOrder", {
         order_id: orderId,
         reason
       })
@@ -2233,12 +2611,23 @@ async function safe6(promise) {
     return err(toCimplifyError6(error));
   }
 }
+async function safeWithFallback5(primary, fallback) {
+  const primaryResult = await safe6(primary());
+  if (primaryResult.ok) return primaryResult;
+  if (primaryResult.error.code !== "HTTP_404" && primaryResult.error.code !== "API_ERROR") {
+    return primaryResult;
+  }
+  return safe6(fallback());
+}
 var AuthService = class {
   constructor(client) {
     this.client = client;
   }
   async getStatus() {
-    return safe6(this.client.query("auth"));
+    return safeWithFallback5(
+      () => this.client.get("/api/v1/auth/status"),
+      () => this.client.query("auth")
+    );
   }
   async getCurrentUser() {
     const result = await this.getStatus();
@@ -2251,23 +2640,34 @@ var AuthService = class {
     return ok(result.value.is_authenticated);
   }
   async requestOtp(contact, contactType) {
-    return safe6(
-      this.client.call(AUTH_MUTATION.REQUEST_OTP, {
+    return safeWithFallback5(
+      () => this.client.post("/api/v1/auth/request-otp", {
+        contact,
+        contact_type: contactType
+      }),
+      () => this.client.call(AUTH_MUTATION.REQUEST_OTP, {
         contact,
         contact_type: contactType
       })
     );
   }
   async verifyOtp(code, contact) {
-    return safe6(
-      this.client.call(AUTH_MUTATION.VERIFY_OTP, {
+    return safeWithFallback5(
+      () => this.client.post("/api/v1/auth/verify-otp", {
+        otp_code: code,
+        contact
+      }),
+      () => this.client.call(AUTH_MUTATION.VERIFY_OTP, {
         otp_code: code,
         contact
       })
     );
   }
   async logout() {
-    return safe6(this.client.call("auth.logout"));
+    return safeWithFallback5(
+      () => this.client.post("/api/v1/auth/logout"),
+      () => this.client.call("auth.logout")
+    );
   }
   async updateProfile(input) {
     return safe6(this.client.call("auth.update_profile", input));
@@ -2295,12 +2695,23 @@ async function safe7(promise) {
     return err(toCimplifyError7(error));
   }
 }
+async function safeWithFallback6(primary, fallback) {
+  const primaryResult = await safe7(primary());
+  if (primaryResult.ok) return primaryResult;
+  if (primaryResult.error.code !== "HTTP_404" && primaryResult.error.code !== "API_ERROR") {
+    return primaryResult;
+  }
+  return safe7(fallback());
+}
 var BusinessService = class {
   constructor(client) {
     this.client = client;
   }
   async getInfo() {
-    return safe7(this.client.query("business.info"));
+    return safeWithFallback6(
+      () => this.client.get("/api/v1/business"),
+      () => this.client.query("business.info")
+    );
   }
   async getByHandle(handle) {
     return safe7(this.client.query(`business.handle.${handle}`));
@@ -2309,24 +2720,48 @@ var BusinessService = class {
     return safe7(this.client.query("business.domain", { domain }));
   }
   async getSettings() {
-    return safe7(this.client.query("business.settings"));
+    return safeWithFallback6(
+      () => this.client.get("/api/v1/business/settings"),
+      () => this.client.query("business.settings")
+    );
   }
   async getTheme() {
-    return safe7(this.client.query("business.theme"));
+    return safeWithFallback6(
+      () => this.client.get("/api/v1/business/theme"),
+      () => this.client.query("business.theme")
+    );
   }
   async getLocations() {
-    return safe7(this.client.query("business.locations"));
+    return safeWithFallback6(
+      () => this.client.get("/api/v1/business/locations"),
+      () => this.client.query("business.locations")
+    );
   }
   async getLocation(locationId) {
-    return safe7(this.client.query(`business.locations.${locationId}`));
+    const result = await this.getLocations();
+    if (!result.ok) return err(result.error);
+    const location = result.value.find((item) => item.id === locationId);
+    if (!location) {
+      return err(new CimplifyError(ErrorCode.NOT_FOUND, `Location not found: ${locationId}`, false));
+    }
+    return ok(location);
   }
   async getHours() {
-    return safe7(this.client.query("business.hours"));
+    return safeWithFallback6(
+      () => this.client.get("/api/v1/business/hours"),
+      () => this.client.query("business.hours")
+    );
   }
   async getLocationHours(locationId) {
-    return safe7(this.client.query(`business.locations.${locationId}.hours`));
+    const result = await this.getHours();
+    if (!result.ok) return result;
+    return ok(result.value.filter((hour) => hour.location_id === locationId));
   }
   async getBootstrap() {
+    const restBootstrap = await safe7(this.client.get("/api/v1/bootstrap"));
+    if (restBootstrap.ok) {
+      return restBootstrap;
+    }
     const [businessResult, locationsResult, categoriesResult] = await Promise.all([
       this.getInfo(),
       this.getLocations(),
@@ -2619,15 +3054,30 @@ async function safe11(promise) {
     return err(toCimplifyError11(error));
   }
 }
+async function safeWithFallback7(primary, fallback) {
+  const primaryResult = await safe11(primary());
+  if (primaryResult.ok) return primaryResult;
+  if (primaryResult.error.code !== "HTTP_404" && primaryResult.error.code !== "API_ERROR") {
+    return primaryResult;
+  }
+  return safe11(fallback());
+}
 var FxService = class {
   constructor(client) {
     this.client = client;
   }
   async getRate(from, to) {
-    return safe11(this.client.call("fx.getRate", { from, to }));
+    const path = `/api/v1/fx/rate?from=${encodeURIComponent(from)}&to=${encodeURIComponent(to)}`;
+    return safeWithFallback7(
+      () => this.client.get(path),
+      () => this.client.call("fx.getRate", { from, to })
+    );
   }
   async lockQuote(request) {
-    return safe11(this.client.call("fx.lockQuote", request));
+    return safeWithFallback7(
+      () => this.client.post("/api/v1/fx/quotes", request),
+      () => this.client.call("fx.lockQuote", request)
+    );
   }
 };
 
@@ -3635,6 +4085,15 @@ var CimplifyClient = class {
     });
     return this.handleRestResponse(response);
   }
+  async patch(path, body) {
+    const response = await this.resilientFetch(`${this.baseUrl}${path}`, {
+      method: "PATCH",
+      credentials: this.credentials,
+      headers: this.getHeaders(),
+      body: body ? JSON.stringify(body) : void 0
+    });
+    return this.handleRestResponse(response);
+  }
   async delete(path) {
     const response = await this.resilientFetch(`${this.baseUrl}${path}`, {
       method: "DELETE",
@@ -3674,11 +4133,14 @@ var CimplifyClient = class {
   async handleRestResponse(response) {
     const json = await response.json();
     if (!response.ok) {
+      const errorCode = typeof json.error === "object" && json.error?.error_code || typeof json.error === "object" && json.error?.code || "API_ERROR";
+      const errorMessage = typeof json.error === "object" && json.error?.error_message || typeof json.error === "object" && json.error?.message || typeof json.error === "string" && json.error || typeof json.message === "string" && json.message || "An error occurred";
+      const retryable = typeof json.error === "object" && typeof json.error?.retryable === "boolean" ? json.error.retryable : false;
       const error = enrichError(
         new CimplifyError(
-          json.error?.error_code || "API_ERROR",
-          json.error?.error_message || "An error occurred",
-          false
+          errorCode,
+          errorMessage,
+          retryable
         ),
         { isTestMode: this.isTestMode() }
       );
@@ -3689,7 +4151,21 @@ var CimplifyClient = class {
       }
       throw error;
     }
-    return json.data;
+    if (json?.success === false || json?.error?.code || json?.error?.message) {
+      const error = enrichError(
+        new CimplifyError(
+          json.error?.code || "API_ERROR",
+          json.error?.message || "An error occurred",
+          json.error?.retryable || false
+        ),
+        { isTestMode: this.isTestMode() }
+      );
+      throw error;
+    }
+    if (json?.data !== void 0) {
+      return json.data;
+    }
+    return json;
   }
   async handleResponse(response) {
     const json = await response.json();
@@ -3860,6 +4336,7 @@ exports.formatNumberCompact = formatNumberCompact;
 exports.formatPrice = formatPrice;
 exports.formatPriceAdjustment = formatPriceAdjustment;
 exports.formatPriceCompact = formatPriceCompact;
+exports.formatPriceWithTax = formatPriceWithTax;
 exports.formatProductPrice = formatProductPrice;
 exports.fromPromise = fromPromise;
 exports.generateIdempotencyKey = generateIdempotencyKey;
@@ -3871,6 +4348,8 @@ exports.getErrorHint = getErrorHint;
 exports.getMarkupPercentage = getMarkupPercentage;
 exports.getOrElse = getOrElse;
 exports.getProductCurrency = getProductCurrency;
+exports.getTaxAmount = getTaxAmount;
+exports.hasTaxInfo = hasTaxInfo;
 exports.isCimplifyError = isCimplifyError;
 exports.isErr = isErr;
 exports.isOk = isOk;
@@ -3879,6 +4358,7 @@ exports.isPaymentStatusFailure = isPaymentStatusFailure;
 exports.isPaymentStatusRequiresAction = isPaymentStatusRequiresAction;
 exports.isPaymentStatusSuccess = isPaymentStatusSuccess;
 exports.isRetryableError = isRetryableError;
+exports.isTaxInclusive = isTaxInclusive;
 exports.mapError = mapError;
 exports.mapResult = mapResult;
 exports.money = money;