@cimplify/sdk 0.7.1 → 0.7.3

package/dist/index.js

@@ -238,74 +238,6 @@ function combineObject(results) {
   return ok(values);
 }
 
-// src/query/builder.ts
-function escapeQueryValue(value) {
-  return value.replace(/'/g, "\\'");
-}
-var QueryBuilder = class {
-  constructor(entity) {
-    this.filters = [];
-    this.modifiers = [];
-    this.pathSegments = [];
-    this.entity = entity;
-  }
-  path(segment) {
-    this.pathSegments.push(segment);
-    return this;
-  }
-  where(field, op, value) {
-    const v = typeof value === "string" ? `'${escapeQueryValue(value)}'` : value;
-    if (op === "contains" || op === "startsWith") {
-      this.filters.push(`@.${field} ${op} ${v}`);
-    } else {
-      this.filters.push(`@.${field}${op}${v}`);
-    }
-    return this;
-  }
-  and(field, op, value) {
-    return this.where(field, op, value);
-  }
-  sort(field, order = "asc") {
-    this.modifiers.push(`sort(${field},${order})`);
-    return this;
-  }
-  limit(n) {
-    this.modifiers.push(`limit(${n})`);
-    return this;
-  }
-  offset(n) {
-    this.modifiers.push(`offset(${n})`);
-    return this;
-  }
-  count() {
-    this.modifiers.push("count");
-    return this;
-  }
-  enriched() {
-    this.modifiers.push("enriched");
-    return this;
-  }
-  build() {
-    let query2 = this.entity;
-    if (this.pathSegments.length > 0) {
-      query2 += "." + this.pathSegments.join(".");
-    }
-    if (this.filters.length > 0) {
-      query2 += `[?(${this.filters.join(" && ")})]`;
-    }
-    for (const mod of this.modifiers) {
-      query2 += `#${mod}`;
-    }
-    return query2;
-  }
-  toString() {
-    return this.build();
-  }
-};
-function query(entity) {
-  return new QueryBuilder(entity);
-}
-
 // src/catalogue.ts
 function toCimplifyError(error) {
   if (error instanceof CimplifyError) return enrichError(error);
@@ -321,14 +253,6 @@ 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)) {
@@ -390,22 +314,6 @@ function normalizeCatalogueProductPayload(product) {
   }
   return normalized;
 }
-function findProductBySlug(products, slug) {
-  return products.find((product) => {
-    const value = product["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;
@@ -493,53 +401,11 @@ var CatalogueQueries = class {
     this.client = client;
   }
   async getCatalogue() {
-    const result = await safeWithFallback(
-      () => this.client.get("/api/v1/catalogue"),
-      () => this.client.query("catalogue")
-    );
+    const result = await safe(this.client.get("/api/v1/catalogue"));
     if (!result.ok) return result;
     return ok(normalizeCatalogueSnapshot(result.value));
   }
   async getProducts(options) {
-    let query2 = "products";
-    const filters = [];
-    if (options?.category) {
-      filters.push(`@.category_id=='${escapeQueryValue(options.category)}'`);
-    }
-    if (options?.featured !== void 0) {
-      filters.push(`@.featured==${options.featured}`);
-    }
-    if (options?.in_stock !== void 0) {
-      filters.push(`@.in_stock==${options.in_stock}`);
-    }
-    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}`);
-    }
-    if (options?.max_price !== void 0) {
-      filters.push(`@.price<=${options.max_price}`);
-    }
-    if (filters.length > 0) {
-      query2 += `[?(${filters.join(" && ")})]`;
-    }
-    if (options?.sort_by) {
-      query2 += `#sort(${options.sort_by},${options.sort_order || "asc"})`;
-    }
-    if (options?.limit !== void 0) {
-      query2 += `#limit(${options.limit})`;
-    }
-    if (options?.offset !== void 0) {
-      query2 += `#offset(${options.offset})`;
-    }
     const path = withQuery("/api/v1/catalogue/products", {
       category_id: options?.category,
       search: options?.search,
@@ -555,325 +421,145 @@ var CatalogueQueries = class {
       offset: options?.offset,
       cursor: options?.cursor
     });
-    const result = await safeWithFallback(
-      () => this.client.get(path),
-      () => this.client.query(query2)
-    );
+    const result = await safe(this.client.get(path));
     if (!result.ok) return result;
     return ok(normalizeCatalogueResult(result.value));
   }
   async getProduct(id) {
     const encodedId = encodeURIComponent(id);
-    const result = await safeWithFallback(
-      () => this.client.get(`/api/v1/catalogue/products/${encodedId}`),
-      () => this.client.query(`products.${id}`)
-    );
+    const result = await safe(this.client.get(`/api/v1/catalogue/products/${encodedId}`));
     if (!result.ok) return result;
     return ok(normalizeCatalogueProductPayload(result.value));
   }
   async getProductBySlug(slug) {
     const encodedSlug = encodeURIComponent(slug);
-    const 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)}')]#limit(50)`
-      )
-    );
-    if (!filteredResult.ok) return filteredResult;
-    const exactMatch = findProductBySlug(filteredResult.value, slug);
-    if (exactMatch) {
-      return ok(normalizeCatalogueProductPayload(exactMatch));
-    }
-    if (filteredResult.value.length === 1) {
-      return ok(normalizeCatalogueProductPayload(filteredResult.value[0]));
-    }
-    const unfilteredResult = await safe(
-      this.client.query("products#limit(200)")
-    );
-    if (!unfilteredResult.ok) return unfilteredResult;
-    const fallbackMatch = findProductBySlug(unfilteredResult.value, slug);
-    if (!fallbackMatch) {
-      return err(new CimplifyError("NOT_FOUND", `Product not found: ${slug}`, false));
-    }
-    return ok(normalizeCatalogueProductPayload(fallbackMatch));
+    const result = await safe(this.client.get(`/api/v1/catalogue/products/slug/${encodedSlug}`));
+    if (!result.ok) return result;
+    return ok(normalizeCatalogueProductPayload(result.value));
   }
   async getVariants(productId) {
     const encodedId = encodeURIComponent(productId);
-    return safeWithFallback(
-      () => this.client.get(`/api/v1/catalogue/products/${encodedId}/variants`),
-      () => this.client.query(`products.${productId}.variants`)
-    );
+    return safe(this.client.get(`/api/v1/catalogue/products/${encodedId}/variants`));
   }
   async getVariantAxes(productId) {
     const encodedId = encodeURIComponent(productId);
-    return safeWithFallback(
-      () => this.client.get(`/api/v1/catalogue/products/${encodedId}/variant-axes`),
-      () => this.client.query(`products.${productId}.variant_axes`)
-    );
+    return safe(this.client.get(`/api/v1/catalogue/products/${encodedId}/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) {
     const encodedId = encodeURIComponent(productId);
-    return safeWithFallback(
-      () => this.client.post(
+    return safe(
+      this.client.post(
         `/api/v1/catalogue/products/${encodedId}/variants/find`,
         {
           axis_selections: selections
         }
-      ),
-      () => this.client.query(`products.${productId}.variant`, {
-        axis_selections: selections
-      })
+      )
     );
   }
-  /**
-   * Get a specific variant by its ID
-   */
   async getVariantById(productId, variantId) {
     const encodedProductId = encodeURIComponent(productId);
     const encodedVariantId = encodeURIComponent(variantId);
-    return safeWithFallback(
-      () => this.client.get(
+    return safe(
+      this.client.get(
         `/api/v1/catalogue/products/${encodedProductId}/variants/${encodedVariantId}`
-      ),
-      () => this.client.query(`products.${productId}.variant.${variantId}`)
+      )
     );
   }
   async getAddOns(productId) {
     const encodedId = encodeURIComponent(productId);
-    return safeWithFallback(
-      () => this.client.get(`/api/v1/catalogue/products/${encodedId}/add-ons`),
-      () => this.client.query(`products.${productId}.add_ons`)
-    );
+    return safe(this.client.get(`/api/v1/catalogue/products/${encodedId}/add-ons`));
   }
   async getCategories() {
-    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;
+    return safe(this.client.get("/api/v1/catalogue/categories"));
   }
   async getCategory(id) {
     const encodedId = encodeURIComponent(id);
-    return safeWithFallback(
-      () => this.client.get(`/api/v1/catalogue/categories/${encodedId}`),
-      () => this.client.query(`categories.${id}`)
-    );
+    return safe(this.client.get(`/api/v1/catalogue/categories/${encodedId}`));
   }
   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;
-    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(fallbackMatch);
+    return safe(this.client.get(`/api/v1/catalogue/categories/slug/${encodedSlug}`));
   }
   async getCategoryProducts(categoryId) {
     const encodedId = encodeURIComponent(categoryId);
-    return safeWithFallback(
-      () => this.client.get(`/api/v1/catalogue/categories/${encodedId}/products`),
-      () => this.client.query(
-        `products[?(@.category_id=='${escapeQueryValue(categoryId)}')]`
-      )
-    );
+    return safe(this.client.get(`/api/v1/catalogue/categories/${encodedId}/products`));
   }
   async getCollections() {
-    return safeWithFallback(
-      () => this.client.get("/api/v1/catalogue/collections"),
-      () => this.client.query("collections")
-    );
+    return safe(this.client.get("/api/v1/catalogue/collections"));
   }
   async getCollection(id) {
     const encodedId = encodeURIComponent(id);
-    return safeWithFallback(
-      () => this.client.get(`/api/v1/catalogue/collections/${encodedId}`),
-      () => this.client.query(`collections.${id}`)
-    );
+    return safe(this.client.get(`/api/v1/catalogue/collections/${encodedId}`));
   }
   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)}')]`)
-    );
-    if (!result.ok) return result;
-    if (!result.value.length) {
-      return err(new CimplifyError("NOT_FOUND", `Collection not found: ${slug}`, false));
-    }
-    return ok(result.value[0]);
+    return safe(this.client.get(`/api/v1/catalogue/collections/slug/${encodedSlug}`));
   }
   async getCollectionProducts(collectionId) {
     const encodedId = encodeURIComponent(collectionId);
-    return safeWithFallback(
-      () => this.client.get(`/api/v1/catalogue/collections/${encodedId}/products`),
-      () => this.client.query(`collections.${collectionId}.products`)
-    );
+    return safe(this.client.get(`/api/v1/catalogue/collections/${encodedId}/products`));
   }
   async searchCollections(query2, limit = 20) {
     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})`
-      )
-    );
+    return safe(this.client.get(path));
   }
   async getBundles() {
-    return safeWithFallback(
-      () => this.client.get("/api/v1/catalogue/bundles"),
-      () => this.client.query("bundles")
-    );
+    return safe(this.client.get("/api/v1/catalogue/bundles"));
   }
   async getBundle(id) {
     const encodedId = encodeURIComponent(id);
-    return safeWithFallback(
-      () => this.client.get(`/api/v1/catalogue/bundles/${encodedId}`),
-      () => this.client.query(`bundles.${id}`)
-    );
+    return safe(this.client.get(`/api/v1/catalogue/bundles/${encodedId}`));
   }
   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)}')]`
-      )
-    );
-    if (!result.ok) return result;
-    if (!result.value.length) {
-      return err(new CimplifyError("NOT_FOUND", `Bundle not found: ${slug}`, false));
-    }
-    return ok(result.value[0]);
+    return safe(this.client.get(`/api/v1/catalogue/bundles/slug/${encodedSlug}`));
   }
   async searchBundles(query2, limit = 20) {
     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})`
-      )
-    );
+    return safe(this.client.get(path));
   }
   async getComposites(options) {
-    let query2 = "composites";
-    if (options?.limit) {
-      query2 += `#limit(${options.limit})`;
-    }
     const path = withQuery("/api/v1/catalogue/composites", { limit: options?.limit });
-    return safeWithFallback(
-      () => this.client.get(path),
-      () => this.client.query(query2)
-    );
+    return safe(this.client.get(path));
   }
   async getComposite(id) {
     const encodedId = encodeURIComponent(id);
-    return safeWithFallback(
-      () => this.client.get(`/api/v1/catalogue/composites/${encodedId}`),
-      () => this.client.query(`composites.${id}`)
-    );
+    return safe(this.client.get(`/api/v1/catalogue/composites/${encodedId}`));
   }
   async getCompositeByProductId(productId) {
     const encodedId = encodeURIComponent(productId);
-    return safeWithFallback(
-      () => this.client.get(
+    return safe(
+      this.client.get(
         `/api/v1/catalogue/composites/by-product/${encodedId}`
-      ),
-      () => this.client.query(`composites.by_product.${productId}`)
+      )
     );
   }
   async calculateCompositePrice(compositeId, selections, locationId) {
     const encodedId = encodeURIComponent(compositeId);
-    return safeWithFallback(
-      () => this.client.post(
+    return safe(
+      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
-      })
+      )
     );
   }
   async fetchQuote(input) {
-    return safeWithFallback(
-      () => this.client.post("/api/v1/catalogue/quotes", input),
-      () => this.client.call("catalogue.createQuote", input)
-    );
+    return safe(this.client.post("/api/v1/catalogue/quotes", input));
   }
   async getQuote(quoteId) {
     const encodedQuoteId = encodeURIComponent(quoteId);
-    return safeWithFallback(
-      () => this.client.get(`/api/v1/catalogue/quotes/${encodedQuoteId}`),
-      () => this.client.call("catalogue.getQuote", {
-        quote_id: quoteId
-      })
-    );
+    return safe(this.client.get(`/api/v1/catalogue/quotes/${encodedQuoteId}`));
   }
   async refreshQuote(input) {
     const encodedQuoteId = encodeURIComponent(input.quote_id);
-    return safeWithFallback(
-      () => this.client.post(
+    return safe(
+      this.client.post(
         `/api/v1/catalogue/quotes/${encodedQuoteId}/refresh`,
         input
-      ),
-      () => this.client.call("catalogue.refreshQuote", input)
+      )
     );
   }
   async search(query2, options) {
@@ -889,35 +575,19 @@ var CatalogueQueries = class {
     return this.search(query2, options);
   }
   async getMenu(options) {
-    let query2 = "menu";
-    if (options?.category) {
-      query2 = `menu[?(@.category=='${escapeQueryValue(options.category)}')]`;
-    }
-    if (options?.limit) {
-      query2 += `#limit(${options.limit})`;
-    }
     const path = withQuery("/api/v1/catalogue/menu", {
       category_id: options?.category,
       limit: options?.limit
     });
-    return safeWithFallback(
-      () => this.client.get(path),
-      () => this.client.query(query2)
-    );
+    return safe(this.client.get(path));
   }
   async getMenuCategory(categoryId) {
     const encodedId = encodeURIComponent(categoryId);
-    return safeWithFallback(
-      () => this.client.get(`/api/v1/catalogue/menu/categories/${encodedId}`),
-      () => this.client.query(`menu.category.${categoryId}`)
-    );
+    return safe(this.client.get(`/api/v1/catalogue/menu/categories/${encodedId}`));
   }
   async getMenuItem(itemId) {
     const encodedId = encodeURIComponent(itemId);
-    return safeWithFallback(
-      () => this.client.get(`/api/v1/catalogue/menu/items/${encodedId}`),
-      () => this.client.query(`menu.${itemId}`)
-    );
+    return safe(this.client.get(`/api/v1/catalogue/menu/items/${encodedId}`));
   }
 };
 
@@ -936,14 +606,6 @@ 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;
 }
@@ -955,36 +617,21 @@ var CartOperations = class {
     this.client = client;
   }
   async get() {
-    const result = await safeWithFallback2(
-      () => this.client.get("/api/v1/cart"),
-      () => this.client.query("cart#enriched")
-    );
+    const result = await safe2(this.client.get("/api/v1/cart"));
     if (!result.ok) return result;
     return ok(unwrapEnrichedCart(result.value));
   }
   async getRaw() {
-    return safeWithFallback2(
-      () => this.client.get("/api/v1/cart"),
-      () => this.client.query("cart")
-    );
+    return safe2(this.client.get("/api/v1/cart"));
   }
   async getItems() {
-    return safeWithFallback2(
-      () => this.client.get("/api/v1/cart/items"),
-      () => this.client.query("cart_items")
-    );
+    return safe2(this.client.get("/api/v1/cart/items"));
   }
   async getCount() {
-    return safeWithFallback2(
-      () => this.client.get("/api/v1/cart/count"),
-      () => this.client.query("cart#count")
-    );
+    return safe2(this.client.get("/api/v1/cart/count"));
   }
   async getTotal() {
-    return safeWithFallback2(
-      () => this.client.get("/api/v1/cart/total"),
-      () => this.client.query("cart#total")
-    );
+    return safe2(this.client.get("/api/v1/cart/total"));
   }
   async getSummary() {
     const cartResult = await this.get();
@@ -1001,66 +648,39 @@ var CartOperations = class {
     });
   }
   async addItem(input) {
-    return safeWithFallback2(
-      () => this.client.post("/api/v1/cart/items", input),
-      () => this.client.call("cart.addItem", input)
-    );
+    return safe2(this.client.post("/api/v1/cart/items", input));
   }
   async updateItem(cartItemId, updates) {
     if (typeof updates.quantity === "number") {
       return this.updateQuantity(cartItemId, updates.quantity);
     }
     const encodedId = encodeURIComponent(cartItemId);
-    return safeWithFallback2(
-      () => this.client.patch(`/api/v1/cart/items/${encodedId}`, updates),
-      () => this.client.call("cart.updateItem", {
-        cart_item_id: cartItemId,
-        ...updates
-      })
-    );
+    return safe2(this.client.patch(`/api/v1/cart/items/${encodedId}`, updates));
   }
   async updateQuantity(cartItemId, quantity) {
     const encodedId = encodeURIComponent(cartItemId);
-    return safeWithFallback2(
-      () => this.client.patch(`/api/v1/cart/items/${encodedId}`, {
-        quantity
-      }),
-      () => this.client.call("cart.updateItemQuantity", {
-        cart_item_id: cartItemId,
+    return safe2(
+      this.client.patch(`/api/v1/cart/items/${encodedId}`, {
         quantity
       })
     );
   }
   async removeItem(cartItemId) {
     const encodedId = encodeURIComponent(cartItemId);
-    return safeWithFallback2(
-      () => this.client.delete(`/api/v1/cart/items/${encodedId}`),
-      () => this.client.call("cart.removeItem", {
-        cart_item_id: cartItemId
-      })
-    );
+    return safe2(this.client.delete(`/api/v1/cart/items/${encodedId}`));
   }
   async clear() {
-    return safeWithFallback2(
-      () => this.client.delete("/api/v1/cart"),
-      () => this.client.call("cart.clearCart")
-    );
+    return safe2(this.client.delete("/api/v1/cart"));
   }
   async applyCoupon(code) {
-    return safeWithFallback2(
-      () => this.client.post("/api/v1/cart/coupons", {
-        coupon_code: code
-      }),
-      () => this.client.call("cart.applyCoupon", {
+    return safe2(
+      this.client.post("/api/v1/cart/coupons", {
         coupon_code: code
       })
     );
   }
   async removeCoupon() {
-    return safeWithFallback2(
-      () => this.client.delete("/api/v1/cart/coupons/current"),
-      () => this.client.call("cart.removeCoupon")
-    );
+    return safe2(this.client.delete("/api/v1/cart/coupons/current"));
   }
   async isEmpty() {
     const countResult = await this.getCount();
@@ -1097,105 +717,6 @@ var CartOperations = class {
   }
 };
 
-// src/constants.ts
-var CHECKOUT_MODE = {
-  LINK: "link",
-  GUEST: "guest"
-};
-var ORDER_TYPE = {
-  DELIVERY: "delivery",
-  PICKUP: "pickup",
-  DINE_IN: "dine-in",
-  WALK_IN: "walk-in"
-};
-var PAYMENT_METHOD = {
-  MOBILE_MONEY: "mobile_money",
-  CARD: "card"
-};
-var CHECKOUT_STEP = {
-  AUTHENTICATION: "authentication",
-  ORDER_DETAILS: "order_details",
-  PAYMENT_METHOD: "payment_method",
-  PAYMENT: "payment",
-  CONFIRMATION: "confirmation"
-};
-var PAYMENT_STATE = {
-  INITIAL: "initial",
-  PREPARING: "preparing",
-  PROCESSING: "processing",
-  VERIFYING: "verifying",
-  AWAITING_AUTHORIZATION: "awaiting_authorization",
-  SUCCESS: "success",
-  ERROR: "error",
-  TIMEOUT: "timeout"
-};
-var PICKUP_TIME_TYPE = {
-  ASAP: "asap",
-  SCHEDULED: "scheduled"
-};
-var MOBILE_MONEY_PROVIDER = {
-  MTN: "mtn",
-  VODAFONE: "vodafone",
-  AIRTEL: "airtel"
-};
-var AUTHORIZATION_TYPE = {
-  OTP: "otp",
-  PIN: "pin",
-  PHONE: "phone",
-  BIRTHDAY: "birthday",
-  ADDRESS: "address"
-};
-var DEVICE_TYPE = {
-  MOBILE: "mobile",
-  DESKTOP: "desktop",
-  TABLET: "tablet"
-};
-var CONTACT_TYPE = {
-  PHONE: "phone",
-  EMAIL: "email"
-};
-var LINK_QUERY = {
-  DATA: "link.data",
-  ADDRESSES: "link.addresses",
-  MOBILE_MONEY: "link.mobile_money",
-  PREFERENCES: "link.preferences",
-  SESSIONS: "link.sessions"
-};
-var LINK_MUTATION = {
-  CHECK_STATUS: "link.check_status",
-  ENROLL: "link.enroll",
-  ENROLL_AND_LINK_ORDER: "link.enroll_and_link_order",
-  UPDATE_PREFERENCES: "link.update_preferences",
-  CREATE_ADDRESS: "link.create_address",
-  UPDATE_ADDRESS: "link.update_address",
-  DELETE_ADDRESS: "link.delete_address",
-  SET_DEFAULT_ADDRESS: "link.set_default_address",
-  TRACK_ADDRESS_USAGE: "link.track_address_usage",
-  CREATE_MOBILE_MONEY: "link.create_mobile_money",
-  DELETE_MOBILE_MONEY: "link.delete_mobile_money",
-  SET_DEFAULT_MOBILE_MONEY: "link.set_default_mobile_money",
-  TRACK_MOBILE_MONEY_USAGE: "link.track_mobile_money_usage",
-  VERIFY_MOBILE_MONEY: "link.verify_mobile_money",
-  REVOKE_SESSION: "link.revoke_session",
-  REVOKE_ALL_SESSIONS: "link.revoke_all_sessions"
-};
-var AUTH_MUTATION = {
-  REQUEST_OTP: "auth.request_otp",
-  VERIFY_OTP: "auth.verify_otp"
-};
-var CHECKOUT_MUTATION = {
-  PROCESS: "checkout.process"
-};
-var PAYMENT_MUTATION = {
-  SUBMIT_AUTHORIZATION: "payment.submit_authorization",
-  CHECK_STATUS: "order.poll_payment_status"
-};
-var ORDER_MUTATION = {
-  UPDATE_CUSTOMER: "order.update_order_customer"
-};
-var DEFAULT_CURRENCY = "GHS";
-var DEFAULT_COUNTRY = "GHA";
-
 // src/utils/price.ts
 var CURRENCY_SYMBOLS = {
   // Major world currencies
@@ -2222,14 +1743,6 @@ 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,
@@ -2252,57 +1765,51 @@ var CheckoutService = class {
   constructor(client) {
     this.client = client;
   }
+  orderTokenParam(orderId) {
+    const token = this.client.getOrderToken(orderId);
+    return token ? `?token=${encodeURIComponent(token)}` : "";
+  }
   async process(data) {
     const checkoutData = {
       ...data,
       idempotency_key: data.idempotency_key || generateIdempotencyKey()
     };
-    return safeWithFallback3(
-      () => this.client.post("/api/v1/checkout", {
-        checkout_data: checkoutData
-      }),
-      () => this.client.call(CHECKOUT_MUTATION.PROCESS, {
+    const result = await safe3(
+      this.client.post("/api/v1/checkout", {
         checkout_data: checkoutData
       })
     );
+    if (result.ok && result.value.bill_token) {
+      this.client.setOrderToken(result.value.order_id, result.value.bill_token);
+    }
+    return result;
   }
-  async initializePayment(orderId, method) {
-    return safe3(
-      this.client.call("order.initializePayment", {
-        order_id: orderId,
-        payment_method: method
-      })
+  async initializePayment(_orderId, _method) {
+    return err(
+      new CimplifyError(
+        "NOT_IMPLEMENTED",
+        "initializePayment is not available in REST mode.",
+        false
+      )
     );
   }
   async submitAuthorization(input) {
-    return safeWithFallback3(
-      () => this.client.post("/api/v1/payments/authorization", input),
-      () => this.client.call(PAYMENT_MUTATION.SUBMIT_AUTHORIZATION, input)
-    );
+    return safe3(this.client.post("/api/v1/payments/authorization", input));
   }
   async pollPaymentStatus(orderId) {
     const encodedId = encodeURIComponent(orderId);
-    return safeWithFallback3(
-      () => this.client.get(`/api/v1/orders/${encodedId}/payment-status`),
-      () => this.client.call(PAYMENT_MUTATION.CHECK_STATUS, orderId)
-    );
+    const tokenParam = this.orderTokenParam(orderId);
+    return safe3(this.client.get(`/api/v1/orders/${encodedId}/payment-status${tokenParam}`));
   }
   async updateOrderCustomer(orderId, 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
-      })
-    );
+    const tokenParam = this.orderTokenParam(orderId);
+    return safe3(this.client.post(`/api/v1/orders/${encodedId}/customer${tokenParam}`, customer));
   }
   async verifyPayment(orderId) {
-    return safe3(
-      this.client.call("order.verifyPayment", {
-        order_id: orderId
-      })
-    );
+    const encodedId = encodeURIComponent(orderId);
+    const tokenParam = this.orderTokenParam(orderId);
+    return safe3(this.client.post(`/api/v1/orders/${encodedId}/verify-payment${tokenParam}`));
   }
   async processAndResolve(data) {
     data.on_status_change?.("preparing", {});
@@ -2421,61 +1928,38 @@ 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;
   }
+  orderTokenParam(orderId) {
+    const token = this.client.getOrderToken(orderId);
+    return token ? `?token=${encodeURIComponent(token)}` : "";
+  }
   async list(options) {
-    let query2 = "orders";
-    if (options?.status) {
-      query2 += `[?(@.status=='${options.status}')]`;
-    }
-    query2 += "#sort(created_at,desc)";
-    if (options?.limit) {
-      query2 += `#limit(${options.limit})`;
-    }
-    if (options?.offset) {
-      query2 += `#offset(${options.offset})`;
-    }
     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)
-    );
+    return safe4(this.client.get(path));
   }
   async get(orderId) {
     const encodedId = encodeURIComponent(orderId);
-    return safeWithFallback4(
-      () => this.client.get(`/api/v1/orders/${encodedId}`),
-      () => this.client.query(`orders.${orderId}`)
-    );
+    const tokenParam = this.orderTokenParam(orderId);
+    return safe4(this.client.get(`/api/v1/orders/${encodedId}${tokenParam}`));
   }
   async getRecent(limit = 5) {
-    return safe4(this.client.query(`orders#sort(created_at,desc)#limit(${limit})`));
+    return this.list({ limit });
   }
   async getByStatus(status) {
     return this.list({ status });
   }
   async cancel(orderId, reason) {
     const encodedId = encodeURIComponent(orderId);
-    return safeWithFallback4(
-      () => this.client.post(`/api/v1/orders/${encodedId}/cancel`, {
-        reason
-      }),
-      () => this.client.call("order.cancelOrder", {
-        order_id: orderId,
+    const tokenParam = this.orderTokenParam(orderId);
+    return safe4(
+      this.client.post(`/api/v1/orders/${encodedId}/cancel${tokenParam}`, {
         reason
       })
     );
@@ -2497,6 +1981,38 @@ async function safe5(promise) {
     return err(toCimplifyError5(error));
   }
 }
+function encodePathSegment(value) {
+  return encodeURIComponent(value);
+}
+function toCreateAddressPayload(input) {
+  return {
+    label: input.label,
+    street_address: input.address_line1,
+    apartment: input.address_line2,
+    city: input.city,
+    region: input.state ?? "",
+    postal_code: input.postal_code,
+    country: input.country
+  };
+}
+function toUpdateAddressPayload(input) {
+  return {
+    label: input.label,
+    street_address: input.address_line1,
+    apartment: input.address_line2,
+    city: input.city,
+    region: input.state,
+    postal_code: input.postal_code,
+    country: input.country
+  };
+}
+function toCreateMobileMoneyPayload(input) {
+  return {
+    phone_number: input.phone_number,
+    provider: input.provider,
+    label: input.account_name
+  };
+}
 var LinkService = class {
   constructor(client) {
     this.client = client;
@@ -2524,11 +2040,7 @@ var LinkService = class {
     return result;
   }
   async checkStatus(contact) {
-    return safe5(
-      this.client.call(LINK_MUTATION.CHECK_STATUS, {
-        contact
-      })
-    );
+    return safe5(this.client.linkPost("/v1/link/check-status", { contact }));
   }
   async getLinkData() {
     return safe5(this.client.linkGet("/v1/link/data"));
@@ -2540,61 +2052,85 @@ var LinkService = class {
     return safe5(this.client.linkGet("/v1/link/mobile-money"));
   }
   async getPreferences() {
-    return safe5(this.client.query(LINK_QUERY.PREFERENCES));
+    return safe5(this.client.linkGet("/v1/link/preferences"));
   }
   async enroll(data) {
-    return safe5(this.client.call(LINK_MUTATION.ENROLL, data));
+    return safe5(this.client.linkPost("/v1/link/enroll", data));
   }
   async enrollAndLinkOrder(data) {
     return safe5(
-      this.client.call(LINK_MUTATION.ENROLL_AND_LINK_ORDER, data)
+      this.client.linkPost("/v1/link/enroll-and-link-order", data)
     );
   }
   async updatePreferences(preferences) {
-    return safe5(this.client.call(LINK_MUTATION.UPDATE_PREFERENCES, preferences));
+    return safe5(this.client.linkPost("/v1/link/preferences", preferences));
   }
   async createAddress(input) {
-    return safe5(this.client.call(LINK_MUTATION.CREATE_ADDRESS, input));
+    return safe5(
+      this.client.linkPost("/v1/link/addresses", toCreateAddressPayload(input))
+    );
   }
   async updateAddress(input) {
-    return safe5(this.client.call(LINK_MUTATION.UPDATE_ADDRESS, input));
+    return safe5(
+      this.client.linkPost(
+        `/v1/link/addresses/${encodePathSegment(input.address_id)}`,
+        toUpdateAddressPayload(input)
+      )
+    );
   }
   async deleteAddress(addressId) {
-    return safe5(this.client.linkDelete(`/v1/link/addresses/${addressId}`));
+    return safe5(
+      this.client.linkDelete(`/v1/link/addresses/${encodePathSegment(addressId)}`)
+    );
   }
   async setDefaultAddress(addressId) {
-    return safe5(this.client.linkPost(`/v1/link/addresses/${addressId}/default`));
+    return safe5(
+      this.client.linkPost(
+        `/v1/link/addresses/${encodePathSegment(addressId)}/default`
+      )
+    );
   }
   async trackAddressUsage(addressId) {
     return safe5(
-      this.client.call(LINK_MUTATION.TRACK_ADDRESS_USAGE, {
-        address_id: addressId
-      })
+      this.client.linkPost(
+        `/v1/link/addresses/${encodePathSegment(addressId)}/track-usage`
+      )
     );
   }
   async createMobileMoney(input) {
-    return safe5(this.client.call(LINK_MUTATION.CREATE_MOBILE_MONEY, input));
+    return safe5(
+      this.client.linkPost(
+        "/v1/link/mobile-money",
+        toCreateMobileMoneyPayload(input)
+      )
+    );
   }
   async deleteMobileMoney(mobileMoneyId) {
     return safe5(
-      this.client.linkDelete(`/v1/link/mobile-money/${mobileMoneyId}`)
+      this.client.linkDelete(
+        `/v1/link/mobile-money/${encodePathSegment(mobileMoneyId)}`
+      )
     );
   }
   async setDefaultMobileMoney(mobileMoneyId) {
     return safe5(
-      this.client.linkPost(`/v1/link/mobile-money/${mobileMoneyId}/default`)
+      this.client.linkPost(
+        `/v1/link/mobile-money/${encodePathSegment(mobileMoneyId)}/default`
+      )
     );
   }
   async trackMobileMoneyUsage(mobileMoneyId) {
     return safe5(
-      this.client.call(LINK_MUTATION.TRACK_MOBILE_MONEY_USAGE, {
-        mobile_money_id: mobileMoneyId
-      })
+      this.client.linkPost(
+        `/v1/link/mobile-money/${encodePathSegment(mobileMoneyId)}/track-usage`
+      )
     );
   }
   async verifyMobileMoney(mobileMoneyId) {
     return safe5(
-      this.client.call(LINK_MUTATION.VERIFY_MOBILE_MONEY, mobileMoneyId)
+      this.client.linkPost(
+        `/v1/link/mobile-money/${encodePathSegment(mobileMoneyId)}/verify`
+      )
     );
   }
   async getSessions() {
@@ -2607,30 +2143,28 @@ var LinkService = class {
     return safe5(this.client.linkDelete("/v1/link/sessions"));
   }
   async getAddressesRest() {
-    return safe5(this.client.linkGet("/v1/link/addresses"));
+    return this.getAddresses();
   }
   async createAddressRest(input) {
-    return safe5(this.client.linkPost("/v1/link/addresses", input));
+    return this.createAddress(input);
   }
   async deleteAddressRest(addressId) {
-    return safe5(this.client.linkDelete(`/v1/link/addresses/${addressId}`));
+    return this.deleteAddress(addressId);
   }
   async setDefaultAddressRest(addressId) {
-    return safe5(this.client.linkPost(`/v1/link/addresses/${addressId}/default`));
+    return this.setDefaultAddress(addressId);
   }
   async getMobileMoneyRest() {
-    return safe5(this.client.linkGet("/v1/link/mobile-money"));
+    return this.getMobileMoney();
   }
   async createMobileMoneyRest(input) {
-    return safe5(this.client.linkPost("/v1/link/mobile-money", input));
+    return this.createMobileMoney(input);
   }
   async deleteMobileMoneyRest(mobileMoneyId) {
-    return safe5(this.client.linkDelete(`/v1/link/mobile-money/${mobileMoneyId}`));
+    return this.deleteMobileMoney(mobileMoneyId);
   }
   async setDefaultMobileMoneyRest(mobileMoneyId) {
-    return safe5(
-      this.client.linkPost(`/v1/link/mobile-money/${mobileMoneyId}/default`)
-    );
+    return this.setDefaultMobileMoney(mobileMoneyId);
   }
 };
 
@@ -2649,23 +2183,12 @@ 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 safeWithFallback5(
-      () => this.client.get("/api/v1/auth/status"),
-      () => this.client.query("auth")
-    );
+    return safe6(this.client.get("/api/v1/auth/status"));
   }
   async getCurrentUser() {
     const result = await this.getStatus();
@@ -2678,43 +2201,26 @@ var AuthService = class {
     return ok(result.value.is_authenticated);
   }
   async requestOtp(contact, contactType) {
-    return safeWithFallback5(
-      () => this.client.post("/api/v1/auth/request-otp", {
-        contact,
-        contact_type: contactType
-      }),
-      () => this.client.call(AUTH_MUTATION.REQUEST_OTP, {
+    return safe6(
+      this.client.post("/api/v1/auth/request-otp", {
         contact,
         contact_type: contactType
       })
     );
   }
   async verifyOtp(code, contact) {
-    return safeWithFallback5(
-      () => this.client.post("/api/v1/auth/verify-otp", {
-        otp_code: code,
-        contact
-      }),
-      () => this.client.call(AUTH_MUTATION.VERIFY_OTP, {
+    return safe6(
+      this.client.post("/api/v1/auth/verify-otp", {
         otp_code: code,
         contact
       })
     );
   }
   async logout() {
-    return safeWithFallback5(
-      () => this.client.post("/api/v1/auth/logout"),
-      () => this.client.call("auth.logout")
-    );
+    return safe6(this.client.post("/api/v1/auth/logout"));
   }
   async updateProfile(input) {
-    return safe6(this.client.call("auth.update_profile", input));
-  }
-  async changePassword(input) {
-    return safe6(this.client.call("auth.change_password", input));
-  }
-  async resetPassword(email) {
-    return safe6(this.client.call("auth.reset_password", { email }));
+    return safe6(this.client.post("/api/v1/auth/profile", input));
   }
 };
 
@@ -2733,47 +2239,29 @@ 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 safeWithFallback6(
-      () => this.client.get("/api/v1/business"),
-      () => this.client.query("business.info")
-    );
+    return safe7(this.client.get("/api/v1/business"));
   }
   async getByHandle(handle) {
-    return safe7(this.client.query(`business.handle.${handle}`));
+    const encodedHandle = encodeURIComponent(handle);
+    return safe7(this.client.get(`/api/v1/business/by-handle/${encodedHandle}`));
   }
   async getByDomain(domain) {
-    return safe7(this.client.query("business.domain", { domain }));
+    const encodedDomain = encodeURIComponent(domain);
+    return safe7(this.client.get(`/api/v1/business/by-domain?domain=${encodedDomain}`));
   }
   async getSettings() {
-    return safeWithFallback6(
-      () => this.client.get("/api/v1/business/settings"),
-      () => this.client.query("business.settings")
-    );
+    return safe7(this.client.get("/api/v1/business/settings"));
   }
   async getTheme() {
-    return safeWithFallback6(
-      () => this.client.get("/api/v1/business/theme"),
-      () => this.client.query("business.theme")
-    );
+    return safe7(this.client.get("/api/v1/business/theme"));
   }
   async getLocations() {
-    return safeWithFallback6(
-      () => this.client.get("/api/v1/business/locations"),
-      () => this.client.query("business.locations")
-    );
+    return safe7(this.client.get("/api/v1/business/locations"));
   }
   async getLocation(locationId) {
     const result = await this.getLocations();
@@ -2785,10 +2273,7 @@ var BusinessService = class {
     return ok(location);
   }
   async getHours() {
-    return safeWithFallback6(
-      () => this.client.get("/api/v1/business/hours"),
-      () => this.client.query("business.hours")
-    );
+    return safe7(this.client.get("/api/v1/business/hours"));
   }
   async getLocationHours(locationId) {
     const result = await this.getHours();
@@ -2796,31 +2281,7 @@ var BusinessService = class {
     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(),
-      safe7(this.client.query("categories#select(id,name,slug)"))
-    ]);
-    if (!businessResult.ok) return businessResult;
-    if (!locationsResult.ok) return locationsResult;
-    if (!categoriesResult.ok) return categoriesResult;
-    const business = businessResult.value;
-    const locations = locationsResult.value;
-    const categories = categoriesResult.value;
-    const defaultLocation = locations[0];
-    return ok({
-      business,
-      location: defaultLocation,
-      locations,
-      categories,
-      currency: business.default_currency,
-      is_open: defaultLocation?.accepts_online_orders ?? false,
-      accepts_orders: defaultLocation?.accepts_online_orders ?? false
-    });
+    return safe7(this.client.get("/api/v1/bootstrap"));
   }
 };
 
@@ -2843,49 +2304,47 @@ var InventoryService = class {
   constructor(client) {
     this.client = client;
   }
+  withQuery(path, params) {
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+      if (value === void 0) continue;
+      searchParams.set(key, String(value));
+    }
+    const query2 = searchParams.toString();
+    return query2 ? `${path}?${query2}` : path;
+  }
   async getStockLevels() {
-    return safe8(this.client.query("inventory.stock_levels"));
+    return safe8(this.client.get("/api/v1/inventory/stock-levels"));
   }
   async getProductStock(productId, locationId) {
-    if (locationId) {
-      return safe8(
-        this.client.query("inventory.product", {
-          product_id: productId,
-          location_id: locationId
-        })
-      );
-    }
-    return safe8(
-      this.client.query("inventory.product", {
-        product_id: productId
-      })
-    );
+    const encodedId = encodeURIComponent(productId);
+    const path = this.withQuery(`/api/v1/inventory/products/${encodedId}/stock`, {
+      location_id: locationId
+    });
+    return safe8(this.client.get(path));
   }
   async getVariantStock(variantId, locationId) {
-    return safe8(
-      this.client.query("inventory.variant", {
-        variant_id: variantId,
-        location_id: locationId
-      })
-    );
+    const encodedId = encodeURIComponent(variantId);
+    const path = this.withQuery(`/api/v1/inventory/variants/${encodedId}/stock`, {
+      location_id: locationId
+    });
+    return safe8(this.client.get(path));
   }
   async checkProductAvailability(productId, quantity, locationId) {
-    return safe8(
-      this.client.query("inventory.check_availability", {
-        product_id: productId,
-        quantity,
-        location_id: locationId
-      })
-    );
+    const encodedId = encodeURIComponent(productId);
+    const path = this.withQuery(`/api/v1/inventory/products/${encodedId}/availability`, {
+      quantity,
+      location_id: locationId
+    });
+    return safe8(this.client.get(path));
   }
   async checkVariantAvailability(variantId, quantity, locationId) {
-    return safe8(
-      this.client.query("inventory.check_availability", {
-        variant_id: variantId,
-        quantity,
-        location_id: locationId
-      })
-    );
+    const encodedId = encodeURIComponent(variantId);
+    const path = this.withQuery(`/api/v1/inventory/variants/${encodedId}/availability`, {
+      quantity,
+      location_id: locationId
+    });
+    return safe8(this.client.get(path));
   }
   async checkMultipleAvailability(items, locationId) {
     const results = await Promise.all(
@@ -2899,7 +2358,7 @@ var InventoryService = class {
     return ok(results.map((r) => r.value));
   }
   async getSummary() {
-    return safe8(this.client.query("inventory.summary"));
+    return safe8(this.client.get("/api/v1/inventory/summary"));
   }
   async isInStock(productId, locationId) {
     const result = await this.checkProductAvailability(productId, 1, locationId);
@@ -2914,9 +2373,6 @@ var InventoryService = class {
 };
 
 // src/scheduling.ts
-function toVariables(input) {
-  return Object.fromEntries(Object.entries(input));
-}
 function toCimplifyError9(error) {
   if (error instanceof CimplifyError) return error;
   if (error instanceof Error) {
@@ -2931,68 +2387,110 @@ async function safe9(promise) {
     return err(toCimplifyError9(error));
   }
 }
+function withQuery2(path, params) {
+  const searchParams = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0) continue;
+    searchParams.set(key, String(value));
+  }
+  const query2 = searchParams.toString();
+  return query2 ? `${path}?${query2}` : path;
+}
+function normalizeServiceAvailability(result) {
+  if (Array.isArray(result.days) && result.days.length > 0) {
+    return result;
+  }
+  const days = Array.isArray(result.availability) ? result.availability.map((day) => ({
+    ...day,
+    is_fully_booked: day.is_fully_booked ?? (typeof day.has_availability === "boolean" ? !day.has_availability : void 0)
+  })) : [];
+  return { ...result, days };
+}
+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 safe9(this.client.query("scheduling.services"));
+    return safe9(this.client.get("/api/v1/scheduling/services"));
   }
   /**
-   * Get a specific service by ID
-   * Note: Filters from all services client-side (no single-service endpoint)
+   * Get a specific service by ID.
    */
   async getService(serviceId) {
     const result = await this.getServices();
     if (!result.ok) return result;
-    return ok(result.value.find((s) => s.id === serviceId) || null);
+    return ok(result.value.find((service) => service.id === serviceId) || null);
   }
   async getAvailableSlots(input) {
-    return safe9(
-      this.client.query("scheduling.slots", toVariables(input))
-    );
+    const path = withQuery2("/api/v1/scheduling/slots", {
+      service_id: input.service_id,
+      date: input.date,
+      participant_count: input.participant_count,
+      duration_minutes: input.duration_minutes
+    });
+    return safe9(this.client.get(path));
   }
   async checkSlotAvailability(input) {
-    return safe9(
-      this.client.query(
-        "scheduling.check_availability",
-        toVariables(input)
-      )
-    );
+    const path = withQuery2("/api/v1/scheduling/slots/check", {
+      service_id: input.service_id,
+      slot_time: input.slot_time,
+      duration_minutes: input.duration_minutes,
+      participant_count: input.participant_count
+    });
+    return safe9(this.client.get(path));
   }
   async getServiceAvailability(params) {
+    const path = withQuery2("/api/v1/scheduling/availability", {
+      service_id: params.service_id,
+      start_date: params.start_date,
+      end_date: params.end_date,
+      location_id: params.location_id,
+      participant_count: params.participant_count
+    });
     return safe9(
-      this.client.query(
-        "scheduling.availability",
-        toVariables(params)
-      )
+      this.client.get(path).then((result) => normalizeServiceAvailability(result))
     );
   }
   async getBooking(bookingId) {
-    return safe9(this.client.query(`scheduling.${bookingId}`));
+    const encodedId = encodeURIComponent(bookingId);
+    return safe9(this.client.get(`/api/v1/scheduling/bookings/${encodedId}`));
   }
-  async getCustomerBookings() {
-    return safe9(this.client.query("scheduling"));
+  async getCustomerBookings(customerId) {
+    const path = withQuery2("/api/v1/scheduling/bookings", {
+      customer_id: customerId
+    });
+    return safe9(this.client.get(path));
   }
   async getUpcomingBookings() {
-    return safe9(
-      this.client.query(
-        "scheduling[?(@.status!='completed' && @.status!='cancelled')]#sort(start_time,asc)"
-      )
-    );
+    const result = await this.getCustomerBookings();
+    if (!result.ok) return result;
+    const upcoming = result.value.filter((booking) => {
+      const status = String(booking.status).toLowerCase();
+      return status !== "completed" && status !== "cancelled";
+    }).sort((a, b) => firstScheduledTime(a).localeCompare(firstScheduledTime(b)));
+    return ok(upcoming);
   }
   async getPastBookings(limit = 10) {
-    return safe9(
-      this.client.query(
-        `scheduling[?(@.status=='completed')]#sort(start_time,desc)#limit(${limit})`
-      )
-    );
+    const result = await this.getCustomerBookings();
+    if (!result.ok) return result;
+    const past = result.value.filter((booking) => String(booking.status).toLowerCase() === "completed").sort((a, b) => firstScheduledTime(b).localeCompare(firstScheduledTime(a))).slice(0, Math.max(0, limit));
+    return ok(past);
   }
   async cancelBooking(input) {
-    return safe9(this.client.call("scheduling.cancel_booking", input));
+    const encodedId = encodeURIComponent(input.booking_id);
+    return safe9(
+      this.client.post(`/api/v1/scheduling/bookings/${encodedId}/cancel`, {
+        reason: input.reason
+      })
+    );
   }
   async rescheduleBooking(input) {
-    return safe9(this.client.call("scheduling.reschedule_booking", input));
+    return safe9(
+      this.client.post("/api/v1/scheduling/bookings/reschedule", input)
+    );
   }
   async getNextAvailableSlot(serviceId, fromDate) {
     const date = fromDate || (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -3011,6 +2509,12 @@ var SchedulingService = class {
     if (!result.ok) return result;
     return ok(result.value.some((slot) => slot.is_available));
   }
+  // Compatibility alias for callers typed against the older Booking shape.
+  async getBookingLegacy(bookingId) {
+    const result = await this.getBooking(bookingId);
+    if (!result.ok) return result;
+    return ok(result.value);
+  }
 };
 
 // src/lite.ts
@@ -3033,47 +2537,18 @@ var LiteService = class {
     this.client = client;
   }
   async getBootstrap() {
-    return safe10(this.client.query("lite.bootstrap"));
+    return safe10(this.client.get("/api/v1/lite/bootstrap"));
   }
   async getTable(tableId) {
-    return safe10(this.client.query(`lite.table.${tableId}`));
-  }
-  async getTableByNumber(tableNumber, locationId) {
-    return safe10(
-      this.client.query("lite.table_by_number", {
-        table_number: tableNumber,
-        location_id: locationId
-      })
-    );
-  }
-  async sendToKitchen(tableId, items) {
-    return safe10(
-      this.client.call("lite.send_to_kitchen", {
-        table_id: tableId,
-        items
-      })
-    );
-  }
-  async callWaiter(tableId, reason) {
-    return safe10(
-      this.client.call("lite.call_waiter", {
-        table_id: tableId,
-        reason
-      })
-    );
-  }
-  async requestBill(tableId) {
-    return safe10(
-      this.client.call("lite.request_bill", {
-        table_id: tableId
-      })
-    );
+    const encodedId = encodeURIComponent(tableId);
+    return safe10(this.client.get(`/api/v1/lite/tables/${encodedId}`));
   }
   async getMenu() {
-    return safe10(this.client.query("lite.menu"));
+    return safe10(this.client.get("/api/v1/lite/menu"));
   }
   async getMenuByCategory(categoryId) {
-    return safe10(this.client.query(`lite.menu.category.${categoryId}`));
+    const encodedId = encodeURIComponent(categoryId);
+    return safe10(this.client.get(`/api/v1/lite/menu/categories/${encodedId}`));
   }
 };
 
@@ -3092,30 +2567,16 @@ 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) {
     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 })
-    );
+    return safe11(this.client.get(path));
   }
   async lockQuote(request) {
-    return safeWithFallback7(
-      () => this.client.post("/api/v1/fx/quotes", request),
-      () => this.client.call("fx.lockQuote", request)
-    );
+    return safe11(this.client.post("/api/v1/fx/quotes", request));
   }
 };
 
@@ -3726,6 +3187,7 @@ function createElements(client, businessId, options) {
 
 // src/client.ts
 var ACCESS_TOKEN_STORAGE_KEY = "cimplify_access_token";
+var ORDER_TOKEN_PREFIX = "cimplify_ot_";
 var DEFAULT_TIMEOUT_MS = 3e4;
 var DEFAULT_MAX_RETRIES = 3;
 var DEFAULT_RETRY_DELAY_MS = 1e3;
@@ -3867,7 +3329,29 @@ var CimplifyClient = class {
       source: "clear"
     });
   }
-  /** Set the active location/branch for all subsequent requests */
+  setOrderToken(orderId, token) {
+    if (typeof window !== "undefined" && window.localStorage) {
+      localStorage.setItem(`${ORDER_TOKEN_PREFIX}${orderId}`, token);
+    }
+  }
+  getOrderToken(orderId) {
+    if (typeof window !== "undefined" && window.localStorage) {
+      return localStorage.getItem(`${ORDER_TOKEN_PREFIX}${orderId}`);
+    }
+    return null;
+  }
+  clearOrderTokens() {
+    if (typeof window !== "undefined" && window.localStorage) {
+      const keysToRemove = [];
+      for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i);
+        if (key?.startsWith(ORDER_TOKEN_PREFIX)) {
+          keysToRemove.push(key);
+        }
+      }
+      keysToRemove.forEach((k) => localStorage.removeItem(k));
+    }
+  }
   setLocationId(locationId) {
     if (locationId) {
       this.context.location_id = locationId;
@@ -4068,41 +3552,6 @@ var CimplifyClient = class {
     this.inflightRequests.set(key, request);
     return request;
   }
-  async query(query2, variables) {
-    const body = { query: query2 };
-    if (variables) {
-      body.variables = variables;
-    }
-    if (Object.keys(this.context).length > 0) {
-      body.context = this.context;
-    }
-    const key = this.getDedupeKey("query", body);
-    return this.deduplicatedRequest(key, async () => {
-      const response = await this.resilientFetch(`${this.baseUrl}/api/q`, {
-        method: "POST",
-        credentials: this.credentials,
-        headers: this.getHeaders(),
-        body: JSON.stringify(body)
-      });
-      return this.handleResponse(response);
-    });
-  }
-  async call(method, args) {
-    const body = {
-      method,
-      args: args !== void 0 ? [args] : []
-    };
-    if (Object.keys(this.context).length > 0) {
-      body.context = this.context;
-    }
-    const response = await this.resilientFetch(`${this.baseUrl}/api/m`, {
-      method: "POST",
-      credentials: this.credentials,
-      headers: this.getHeaders(),
-      body: JSON.stringify(body)
-    });
-    return this.handleResponse(response);
-  }
   async get(path) {
     const key = this.getDedupeKey("get", path);
     return this.deduplicatedRequest(key, async () => {
@@ -4205,26 +3654,6 @@ var CimplifyClient = class {
     }
     return json;
   }
-  async handleResponse(response) {
-    const json = await response.json();
-    if (!json.success || json.error) {
-      const error = enrichError(
-        new CimplifyError(
-          json.error?.code || "UNKNOWN_ERROR",
-          json.error?.message || "An unknown error occurred",
-          json.error?.retryable || false
-        ),
-        { isTestMode: this.isTestMode() }
-      );
-      if (response.status === 401 || error.code === ErrorCode.UNAUTHORIZED) {
-        console.warn(
-          "[Cimplify] Received 401 Unauthorized. Access token may be missing/expired. Refresh authentication and retry the request."
-        );
-      }
-      throw error;
-    }
-    return json.data;
-  }
   get catalogue() {
     if (!this._catalogue) {
       this._catalogue = new CatalogueQueries(this);
@@ -4316,6 +3745,173 @@ function createCimplifyClient(config = {}) {
   return new CimplifyClient(config);
 }
 
+// src/query/builder.ts
+function escapeQueryValue(value) {
+  return value.replace(/'/g, "\\'");
+}
+var QueryBuilder = class {
+  constructor(entity) {
+    this.filters = [];
+    this.modifiers = [];
+    this.pathSegments = [];
+    this.entity = entity;
+  }
+  path(segment) {
+    this.pathSegments.push(segment);
+    return this;
+  }
+  where(field, op, value) {
+    const v = typeof value === "string" ? `'${escapeQueryValue(value)}'` : value;
+    if (op === "contains" || op === "startsWith") {
+      this.filters.push(`@.${field} ${op} ${v}`);
+    } else {
+      this.filters.push(`@.${field}${op}${v}`);
+    }
+    return this;
+  }
+  and(field, op, value) {
+    return this.where(field, op, value);
+  }
+  sort(field, order = "asc") {
+    this.modifiers.push(`sort(${field},${order})`);
+    return this;
+  }
+  limit(n) {
+    this.modifiers.push(`limit(${n})`);
+    return this;
+  }
+  offset(n) {
+    this.modifiers.push(`offset(${n})`);
+    return this;
+  }
+  count() {
+    this.modifiers.push("count");
+    return this;
+  }
+  enriched() {
+    this.modifiers.push("enriched");
+    return this;
+  }
+  build() {
+    let query2 = this.entity;
+    if (this.pathSegments.length > 0) {
+      query2 += "." + this.pathSegments.join(".");
+    }
+    if (this.filters.length > 0) {
+      query2 += `[?(${this.filters.join(" && ")})]`;
+    }
+    for (const mod of this.modifiers) {
+      query2 += `#${mod}`;
+    }
+    return query2;
+  }
+  toString() {
+    return this.build();
+  }
+};
+function query(entity) {
+  return new QueryBuilder(entity);
+}
+
+// src/constants.ts
+var CHECKOUT_MODE = {
+  LINK: "link",
+  GUEST: "guest"
+};
+var ORDER_TYPE = {
+  DELIVERY: "delivery",
+  PICKUP: "pickup",
+  DINE_IN: "dine-in",
+  WALK_IN: "walk-in"
+};
+var PAYMENT_METHOD = {
+  MOBILE_MONEY: "mobile_money",
+  CARD: "card"
+};
+var CHECKOUT_STEP = {
+  AUTHENTICATION: "authentication",
+  ORDER_DETAILS: "order_details",
+  PAYMENT_METHOD: "payment_method",
+  PAYMENT: "payment",
+  CONFIRMATION: "confirmation"
+};
+var PAYMENT_STATE = {
+  INITIAL: "initial",
+  PREPARING: "preparing",
+  PROCESSING: "processing",
+  VERIFYING: "verifying",
+  AWAITING_AUTHORIZATION: "awaiting_authorization",
+  SUCCESS: "success",
+  ERROR: "error",
+  TIMEOUT: "timeout"
+};
+var PICKUP_TIME_TYPE = {
+  ASAP: "asap",
+  SCHEDULED: "scheduled"
+};
+var MOBILE_MONEY_PROVIDER = {
+  MTN: "mtn",
+  VODAFONE: "vodafone",
+  AIRTEL: "airtel"
+};
+var AUTHORIZATION_TYPE = {
+  OTP: "otp",
+  PIN: "pin",
+  PHONE: "phone",
+  BIRTHDAY: "birthday",
+  ADDRESS: "address"
+};
+var DEVICE_TYPE = {
+  MOBILE: "mobile",
+  DESKTOP: "desktop",
+  TABLET: "tablet"
+};
+var CONTACT_TYPE = {
+  PHONE: "phone",
+  EMAIL: "email"
+};
+var LINK_QUERY = {
+  DATA: "link.data",
+  ADDRESSES: "link.addresses",
+  MOBILE_MONEY: "link.mobile_money",
+  PREFERENCES: "link.preferences",
+  SESSIONS: "link.sessions"
+};
+var LINK_MUTATION = {
+  CHECK_STATUS: "link.check_status",
+  ENROLL: "link.enroll",
+  ENROLL_AND_LINK_ORDER: "link.enroll_and_link_order",
+  UPDATE_PREFERENCES: "link.update_preferences",
+  CREATE_ADDRESS: "link.create_address",
+  UPDATE_ADDRESS: "link.update_address",
+  DELETE_ADDRESS: "link.delete_address",
+  SET_DEFAULT_ADDRESS: "link.set_default_address",
+  TRACK_ADDRESS_USAGE: "link.track_address_usage",
+  CREATE_MOBILE_MONEY: "link.create_mobile_money",
+  DELETE_MOBILE_MONEY: "link.delete_mobile_money",
+  SET_DEFAULT_MOBILE_MONEY: "link.set_default_mobile_money",
+  TRACK_MOBILE_MONEY_USAGE: "link.track_mobile_money_usage",
+  VERIFY_MOBILE_MONEY: "link.verify_mobile_money",
+  REVOKE_SESSION: "link.revoke_session",
+  REVOKE_ALL_SESSIONS: "link.revoke_all_sessions"
+};
+var AUTH_MUTATION = {
+  REQUEST_OTP: "auth.request_otp",
+  VERIFY_OTP: "auth.verify_otp"
+};
+var CHECKOUT_MUTATION = {
+  PROCESS: "checkout.process"
+};
+var PAYMENT_MUTATION = {
+  SUBMIT_AUTHORIZATION: "payment.submit_authorization",
+  CHECK_STATUS: "order.poll_payment_status"
+};
+var ORDER_MUTATION = {
+  UPDATE_CUSTOMER: "order.update_order_customer"
+};
+var DEFAULT_CURRENCY = "GHS";
+var DEFAULT_COUNTRY = "GHA";
+
 exports.AUTHORIZATION_TYPE = AUTHORIZATION_TYPE;
 exports.AUTH_MUTATION = AUTH_MUTATION;
 exports.AuthService = AuthService;