@cimplify/sdk 0.7.1 → 0.7.3

package/dist/react.mjs

@@ -835,11 +835,6 @@ function err(error) {
   return { ok: false, error };
 }
 
-// src/query/builder.ts
-function escapeQueryValue(value) {
-  return value.replace(/'/g, "\\'");
-}
-
 // src/catalogue.ts
 function toCimplifyError(error) {
   if (error instanceof CimplifyError) return enrichError(error);
@@ -855,14 +850,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 query = new URLSearchParams();
   for (const [key, value] of Object.entries(params)) {
@@ -924,22 +911,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;
@@ -1027,53 +998,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 query = "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) {
-      query += `[?(${filters.join(" && ")})]`;
-    }
-    if (options?.sort_by) {
-      query += `#sort(${options.sort_by},${options.sort_order || "asc"})`;
-    }
-    if (options?.limit !== void 0) {
-      query += `#limit(${options.limit})`;
-    }
-    if (options?.offset !== void 0) {
-      query += `#offset(${options.offset})`;
-    }
     const path = withQuery("/api/v1/catalogue/products", {
       category_id: options?.category,
       search: options?.search,
@@ -1089,325 +1018,145 @@ var CatalogueQueries = class {
       offset: options?.offset,
       cursor: options?.cursor
     });
-    const result = await safeWithFallback(
-      () => this.client.get(path),
-      () => this.client.query(query)
-    );
+    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(query, limit = 20) {
     const path = withQuery("/api/v1/catalogue/collections", { search: query, limit });
-    return safeWithFallback(
-      () => this.client.get(path),
-      () => this.client.query(
-        `collections[?(@.name contains '${escapeQueryValue(query)}')]#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(query, limit = 20) {
     const path = withQuery("/api/v1/catalogue/bundles", { search: query, limit });
-    return safeWithFallback(
-      () => this.client.get(path),
-      () => this.client.query(
-        `bundles[?(@.name contains '${escapeQueryValue(query)}')]#limit(${limit})`
-      )
-    );
+    return safe(this.client.get(path));
   }
   async getComposites(options) {
-    let query = "composites";
-    if (options?.limit) {
-      query += `#limit(${options.limit})`;
-    }
     const path = withQuery("/api/v1/catalogue/composites", { limit: options?.limit });
-    return safeWithFallback(
-      () => this.client.get(path),
-      () => this.client.query(query)
-    );
+    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(query, options) {
@@ -1423,35 +1172,19 @@ var CatalogueQueries = class {
     return this.search(query, options);
   }
   async getMenu(options) {
-    let query = "menu";
-    if (options?.category) {
-      query = `menu[?(@.category=='${escapeQueryValue(options.category)}')]`;
-    }
-    if (options?.limit) {
-      query += `#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(query)
-    );
+    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}`));
   }
 };
 
@@ -1470,14 +1203,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;
 }
@@ -1489,36 +1214,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();
@@ -1535,66 +1245,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();
@@ -1631,35 +1314,6 @@ var CartOperations = class {
   }
 };
 
-// src/constants.ts
-var LINK_QUERY = {
-  PREFERENCES: "link.preferences"};
-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",
-  TRACK_ADDRESS_USAGE: "link.track_address_usage",
-  CREATE_MOBILE_MONEY: "link.create_mobile_money",
-  TRACK_MOBILE_MONEY_USAGE: "link.track_mobile_money_usage",
-  VERIFY_MOBILE_MONEY: "link.verify_mobile_money"};
-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"
-};
-
 // src/utils/price.ts
 function parsePrice(value) {
   if (value === void 0 || value === null) {
@@ -2367,14 +2021,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,
@@ -2397,57 +2043,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", {});
@@ -2566,61 +2206,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 query = "orders";
-    if (options?.status) {
-      query += `[?(@.status=='${options.status}')]`;
-    }
-    query += "#sort(created_at,desc)";
-    if (options?.limit) {
-      query += `#limit(${options.limit})`;
-    }
-    if (options?.offset) {
-      query += `#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(query)
-    );
+    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
       })
     );
@@ -2642,6 +2259,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;
@@ -2669,11 +2318,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"));
@@ -2685,61 +2330,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() {
@@ -2752,30 +2421,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);
   }
 };
 
@@ -2794,23 +2461,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();
@@ -2823,43 +2479,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));
   }
 };
 
@@ -2878,47 +2517,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();
@@ -2930,10 +2551,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();
@@ -2941,31 +2559,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"));
   }
 };
 
@@ -2988,49 +2582,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 query = searchParams.toString();
+    return query ? `${path}?${query}` : 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(
@@ -3044,7 +2636,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);
@@ -3059,9 +2651,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) {
@@ -3076,68 +2665,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 query = searchParams.toString();
+  return query ? `${path}?${query}` : 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];
@@ -3156,6 +2787,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
@@ -3178,47 +2815,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}`));
   }
 };
 
@@ -3237,30 +2845,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));
   }
 };
 
@@ -3832,6 +3426,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;
@@ -3973,7 +3568,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;
@@ -4174,41 +3791,6 @@ var CimplifyClient = class {
     this.inflightRequests.set(key, request);
     return request;
   }
-  async query(query, variables) {
-    const body = { query };
-    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 () => {
@@ -4311,26 +3893,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);