@cimplify/sdk 0.2.5 → 0.3.1

package/dist/index.js

@@ -66,7 +66,91 @@ function isRetryableError(error) {
   return false;
 }
 
+// src/types/result.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+function isOk(result) {
+  return result.ok === true;
+}
+function isErr(result) {
+  return result.ok === false;
+}
+function mapResult(result, fn) {
+  return result.ok ? ok(fn(result.value)) : result;
+}
+function mapError(result, fn) {
+  return result.ok ? result : err(fn(result.error));
+}
+function flatMap(result, fn) {
+  return result.ok ? fn(result.value) : result;
+}
+function getOrElse(result, defaultFn) {
+  return result.ok ? result.value : defaultFn();
+}
+function unwrap(result) {
+  if (result.ok) {
+    return result.value;
+  }
+  throw result.error;
+}
+function toNullable(result) {
+  return result.ok ? result.value : void 0;
+}
+async function fromPromise(promise, mapError2) {
+  try {
+    const value = await promise;
+    return ok(value);
+  } catch (error) {
+    return err(mapError2(error));
+  }
+}
+function tryCatch(fn, mapError2) {
+  try {
+    return ok(fn());
+  } catch (error) {
+    return err(mapError2(error));
+  }
+}
+function combine(results) {
+  const values = [];
+  for (const result of results) {
+    if (!result.ok) {
+      return result;
+    }
+    values.push(result.value);
+  }
+  return ok(values);
+}
+function combineObject(results) {
+  const values = {};
+  for (const [key, result] of Object.entries(results)) {
+    if (!result.ok) {
+      return result;
+    }
+    values[key] = result.value;
+  }
+  return ok(values);
+}
+
 // src/catalogue.ts
+function toCimplifyError(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError(error));
+  }
+}
 var CatalogueQueries = class {
   constructor(client) {
     this.client = client;
@@ -107,111 +191,125 @@ var CatalogueQueries = class {
     if (options?.offset) {
       query2 += `#offset(${options.offset})`;
     }
-    return this.client.query(query2);
+    return safe(this.client.query(query2));
   }
   async getProduct(id) {
-    return this.client.query(`products.${id}`);
+    return safe(this.client.query(`products.${id}`));
   }
   async getProductBySlug(slug) {
-    const products = await this.client.query(
-      `products[?(@.slug=='${slug}')]`
+    const result = await safe(
+      this.client.query(`products[?(@.slug=='${slug}')]`)
     );
-    if (!products.length) {
-      throw new Error(`Product not found: ${slug}`);
+    if (!result.ok) return result;
+    if (!result.value.length) {
+      return err(new CimplifyError("NOT_FOUND", `Product not found: ${slug}`, false));
     }
-    return products[0];
+    return ok(result.value[0]);
   }
   // --------------------------------------------------------------------------
   // VARIANTS
   // --------------------------------------------------------------------------
   async getVariants(productId) {
-    return this.client.query(`products.${productId}.variants`);
+    return safe(this.client.query(`products.${productId}.variants`));
   }
   async getVariantAxes(productId) {
-    return this.client.query(`products.${productId}.variant_axes`);
+    return safe(this.client.query(`products.${productId}.variant_axes`));
   }
   /**
    * Find a variant by axis selections (e.g., { "Size": "Large", "Color": "Red" })
    * Returns the matching variant or null if no match found.
    */
   async getVariantByAxisSelections(productId, selections) {
-    return this.client.query(`products.${productId}.variant`, {
-      axis_selections: selections
-    });
+    return safe(
+      this.client.query(`products.${productId}.variant`, {
+        axis_selections: selections
+      })
+    );
   }
   /**
    * Get a specific variant by its ID
    */
   async getVariantById(productId, variantId) {
-    return this.client.query(`products.${productId}.variant.${variantId}`);
+    return safe(this.client.query(`products.${productId}.variant.${variantId}`));
   }
   // --------------------------------------------------------------------------
   // ADD-ONS
   // --------------------------------------------------------------------------
   async getAddOns(productId) {
-    return this.client.query(`products.${productId}.add_ons`);
+    return safe(this.client.query(`products.${productId}.add_ons`));
   }
   // --------------------------------------------------------------------------
   // CATEGORIES
   // --------------------------------------------------------------------------
   async getCategories() {
-    return this.client.query("categories");
+    return safe(this.client.query("categories"));
   }
   async getCategory(id) {
-    return this.client.query(`categories.${id}`);
+    return safe(this.client.query(`categories.${id}`));
   }
   async getCategoryBySlug(slug) {
-    const categories = await this.client.query(`categories[?(@.slug=='${slug}')]`);
-    if (!categories.length) {
-      throw new Error(`Category not found: ${slug}`);
+    const result = await safe(
+      this.client.query(`categories[?(@.slug=='${slug}')]`)
+    );
+    if (!result.ok) return result;
+    if (!result.value.length) {
+      return err(new CimplifyError("NOT_FOUND", `Category not found: ${slug}`, false));
     }
-    return categories[0];
+    return ok(result.value[0]);
   }
   async getCategoryProducts(categoryId) {
-    return this.client.query(`products[?(@.category_id=='${categoryId}')]`);
+    return safe(this.client.query(`products[?(@.category_id=='${categoryId}')]`));
   }
   // --------------------------------------------------------------------------
   // COLLECTIONS
   // --------------------------------------------------------------------------
   async getCollections() {
-    return this.client.query("collections");
+    return safe(this.client.query("collections"));
   }
   async getCollection(id) {
-    return this.client.query(`collections.${id}`);
+    return safe(this.client.query(`collections.${id}`));
   }
   async getCollectionBySlug(slug) {
-    const collections = await this.client.query(`collections[?(@.slug=='${slug}')]`);
-    if (!collections.length) {
-      throw new Error(`Collection not found: ${slug}`);
+    const result = await safe(
+      this.client.query(`collections[?(@.slug=='${slug}')]`)
+    );
+    if (!result.ok) return result;
+    if (!result.value.length) {
+      return err(new CimplifyError("NOT_FOUND", `Collection not found: ${slug}`, false));
     }
-    return collections[0];
+    return ok(result.value[0]);
   }
   async getCollectionProducts(collectionId) {
-    return this.client.query(`collections.${collectionId}.products`);
+    return safe(this.client.query(`collections.${collectionId}.products`));
   }
   async searchCollections(query2, limit = 20) {
-    return this.client.query(
-      `collections[?(@.name contains '${query2}')]#limit(${limit})`
+    return safe(
+      this.client.query(`collections[?(@.name contains '${query2}')]#limit(${limit})`)
     );
   }
   // --------------------------------------------------------------------------
   // BUNDLES
   // --------------------------------------------------------------------------
   async getBundles() {
-    return this.client.query("bundles");
+    return safe(this.client.query("bundles"));
   }
   async getBundle(id) {
-    return this.client.query(`bundles.${id}`);
+    return safe(this.client.query(`bundles.${id}`));
   }
   async getBundleBySlug(slug) {
-    const bundles = await this.client.query(`bundles[?(@.slug=='${slug}')]`);
-    if (!bundles.length) {
-      throw new Error(`Bundle not found: ${slug}`);
+    const result = await safe(
+      this.client.query(`bundles[?(@.slug=='${slug}')]`)
+    );
+    if (!result.ok) return result;
+    if (!result.value.length) {
+      return err(new CimplifyError("NOT_FOUND", `Bundle not found: ${slug}`, false));
     }
-    return bundles[0];
+    return ok(result.value[0]);
   }
   async searchBundles(query2, limit = 20) {
-    return this.client.query(`bundles[?(@.name contains '${query2}')]#limit(${limit})`);
+    return safe(
+      this.client.query(`bundles[?(@.name contains '${query2}')]#limit(${limit})`)
+    );
   }
   // --------------------------------------------------------------------------
   // COMPOSITES (Build-Your-Own)
@@ -221,20 +319,22 @@ var CatalogueQueries = class {
     if (options?.limit) {
       query2 += `#limit(${options.limit})`;
     }
-    return this.client.query(query2);
+    return safe(this.client.query(query2));
   }
   async getComposite(id) {
-    return this.client.query(`composites.${id}`);
+    return safe(this.client.query(`composites.${id}`));
   }
   async getCompositeByProductId(productId) {
-    return this.client.query(`composites.by_product.${productId}`);
+    return safe(this.client.query(`composites.by_product.${productId}`));
   }
   async calculateCompositePrice(compositeId, selections, locationId) {
-    return this.client.call("composite.calculatePrice", {
-      composite_id: compositeId,
-      selections,
-      location_id: locationId
-    });
+    return safe(
+      this.client.call("composite.calculatePrice", {
+        composite_id: compositeId,
+        selections,
+        location_id: locationId
+      })
+    );
   }
   // --------------------------------------------------------------------------
   // SEARCH
@@ -246,14 +346,16 @@ var CatalogueQueries = class {
       searchQuery = `products[?(@.name contains '${query2}' && @.category_id=='${options.category}')]`;
     }
     searchQuery += `#limit(${limit})`;
-    return this.client.query(searchQuery);
+    return safe(this.client.query(searchQuery));
   }
   async searchProducts(query2, options) {
-    return this.client.call("catalogue.search", {
-      query: query2,
-      limit: options?.limit ?? 20,
-      category: options?.category
-    });
+    return safe(
+      this.client.call("catalogue.search", {
+        query: query2,
+        limit: options?.limit ?? 20,
+        category: options?.category
+      })
+    );
   }
   // --------------------------------------------------------------------------
   // MENU (Restaurant-specific)
@@ -266,17 +368,31 @@ var CatalogueQueries = class {
     if (options?.limit) {
       query2 += `#limit(${options.limit})`;
     }
-    return this.client.query(query2);
+    return safe(this.client.query(query2));
   }
   async getMenuCategory(categoryId) {
-    return this.client.query(`menu.category.${categoryId}`);
+    return safe(this.client.query(`menu.category.${categoryId}`));
   }
   async getMenuItem(itemId) {
-    return this.client.query(`menu.${itemId}`);
+    return safe(this.client.query(`menu.${itemId}`));
   }
 };
 
 // src/cart.ts
+function toCimplifyError2(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe2(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError2(error));
+  }
+}
 var CartOperations = class {
   constructor(client) {
     this.client = client;
@@ -289,23 +405,25 @@ var CartOperations = class {
    * This is the main method for storefront display.
    */
   async get() {
-    return this.client.query("cart#enriched");
+    return safe2(this.client.query("cart#enriched"));
   }
   async getRaw() {
-    return this.client.query("cart");
+    return safe2(this.client.query("cart"));
   }
   async getItems() {
-    return this.client.query("cart_items");
+    return safe2(this.client.query("cart_items"));
   }
   async getCount() {
-    return this.client.query("cart#count");
+    return safe2(this.client.query("cart#count"));
   }
   async getTotal() {
-    return this.client.query("cart#total");
+    return safe2(this.client.query("cart#total"));
   }
   async getSummary() {
-    const cart = await this.get();
-    return {
+    const cartResult = await this.get();
+    if (!cartResult.ok) return cartResult;
+    const cart = cartResult.value;
+    return ok({
       item_count: cart.items.length,
       total_items: cart.items.reduce((sum, item) => sum + item.quantity, 0),
       subtotal: cart.pricing.subtotal,
@@ -313,55 +431,89 @@ var CartOperations = class {
       tax_amount: cart.pricing.tax_amount,
       total: cart.pricing.total_price,
       currency: cart.pricing.currency
-    };
+    });
   }
   // --------------------------------------------------------------------------
   // CART MUTATIONS
   // --------------------------------------------------------------------------
+  /**
+   * Add an item to the cart.
+   *
+   * @example
+   * ```typescript
+   * const result = await client.cart.addItem({
+   *   item_id: "prod_burger",
+   *   quantity: 2,
+   *   variant_id: "var_large",
+   *   add_on_options: ["addon_cheese", "addon_bacon"],
+   * });
+   *
+   * if (!result.ok) {
+   *   switch (result.error.code) {
+   *     case ErrorCode.ITEM_UNAVAILABLE:
+   *       toast.error("Item no longer available");
+   *       break;
+   *     case ErrorCode.VARIANT_OUT_OF_STOCK:
+   *       toast.error("Selected option is out of stock");
+   *       break;
+   *   }
+   * }
+   * ```
+   */
   async addItem(input) {
-    return this.client.call("cart.addItem", input);
+    return safe2(this.client.call("cart.addItem", input));
   }
   async updateItem(cartItemId, updates) {
-    return this.client.call("cart.updateItem", {
-      cart_item_id: cartItemId,
-      ...updates
-    });
+    return safe2(
+      this.client.call("cart.updateItem", {
+        cart_item_id: cartItemId,
+        ...updates
+      })
+    );
   }
   async updateQuantity(cartItemId, quantity) {
-    return this.client.call("cart.updateItemQuantity", {
-      cart_item_id: cartItemId,
-      quantity
-    });
+    return safe2(
+      this.client.call("cart.updateItemQuantity", {
+        cart_item_id: cartItemId,
+        quantity
+      })
+    );
   }
   async removeItem(cartItemId) {
-    return this.client.call("cart.removeItem", {
-      cart_item_id: cartItemId
-    });
+    return safe2(
+      this.client.call("cart.removeItem", {
+        cart_item_id: cartItemId
+      })
+    );
   }
   async clear() {
-    return this.client.call("cart.clearCart");
+    return safe2(this.client.call("cart.clearCart"));
   }
   // --------------------------------------------------------------------------
   // COUPONS & DISCOUNTS
   // --------------------------------------------------------------------------
   async applyCoupon(code) {
-    return this.client.call("cart.applyCoupon", {
-      coupon_code: code
-    });
+    return safe2(
+      this.client.call("cart.applyCoupon", {
+        coupon_code: code
+      })
+    );
   }
   async removeCoupon() {
-    return this.client.call("cart.removeCoupon");
+    return safe2(this.client.call("cart.removeCoupon"));
   }
   // --------------------------------------------------------------------------
   // CONVENIENCE METHODS
   // --------------------------------------------------------------------------
   async isEmpty() {
-    const count = await this.getCount();
-    return count === 0;
+    const countResult = await this.getCount();
+    if (!countResult.ok) return countResult;
+    return ok(countResult.value === 0);
   }
   async hasItem(productId, variantId) {
-    const items = await this.getItems();
-    return items.some((item) => {
+    const itemsResult = await this.getItems();
+    if (!itemsResult.ok) return itemsResult;
+    const found = itemsResult.value.some((item) => {
       const matchesProduct = item.item_id === productId;
       if (!variantId) return matchesProduct;
       const config = item.configuration;
@@ -370,10 +522,12 @@ var CartOperations = class {
       }
       return matchesProduct;
     });
+    return ok(found);
   }
   async findItem(productId, variantId) {
-    const items = await this.getItems();
-    return items.find((item) => {
+    const itemsResult = await this.getItems();
+    if (!itemsResult.ok) return itemsResult;
+    const found = itemsResult.value.find((item) => {
       const matchesProduct = item.item_id === productId;
       if (!variantId) return matchesProduct;
       const config = item.configuration;
@@ -382,6 +536,7 @@ var CartOperations = class {
       }
       return matchesProduct;
     });
+    return ok(found);
   }
 };
 
@@ -476,41 +631,106 @@ var DEFAULT_CURRENCY = "GHS";
 var DEFAULT_COUNTRY = "GHA";
 
 // src/checkout.ts
+function toCimplifyError3(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe3(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError3(error));
+  }
+}
 var CheckoutService = class {
   constructor(client) {
     this.client = client;
   }
+  /**
+   * Process checkout with cart data.
+   *
+   * @example
+   * ```typescript
+   * const result = await client.checkout.process({
+   *   cart_id: cart.id,
+   *   customer: { name, email, phone, save_details: true },
+   *   order_type: "pickup",
+   *   payment_method: "mobile_money",
+   *   mobile_money_details: { phone_number, provider: "mtn" },
+   * });
+   *
+   * if (!result.ok) {
+   *   switch (result.error.code) {
+   *     case ErrorCode.CART_EMPTY:
+   *       toast.error("Your cart is empty");
+   *       break;
+   *     case ErrorCode.PAYMENT_FAILED:
+   *       toast.error("Payment failed. Please try again.");
+   *       break;
+   *   }
+   * }
+   * ```
+   */
   async process(data) {
-    return this.client.call(CHECKOUT_MUTATION.PROCESS, {
-      checkout_data: data
-    });
+    return safe3(
+      this.client.call(CHECKOUT_MUTATION.PROCESS, {
+        checkout_data: data
+      })
+    );
   }
   async initializePayment(orderId, method) {
-    return this.client.call("order.initializePayment", {
-      order_id: orderId,
-      payment_method: method
-    });
+    return safe3(
+      this.client.call("order.initializePayment", {
+        order_id: orderId,
+        payment_method: method
+      })
+    );
   }
   async submitAuthorization(input) {
-    return this.client.call(PAYMENT_MUTATION.SUBMIT_AUTHORIZATION, input);
+    return safe3(
+      this.client.call(PAYMENT_MUTATION.SUBMIT_AUTHORIZATION, input)
+    );
   }
   async pollPaymentStatus(orderId) {
-    return this.client.call(PAYMENT_MUTATION.CHECK_STATUS, orderId);
+    return safe3(
+      this.client.call(PAYMENT_MUTATION.CHECK_STATUS, orderId)
+    );
   }
   async updateOrderCustomer(orderId, customer) {
-    return this.client.call(ORDER_MUTATION.UPDATE_CUSTOMER, {
-      order_id: orderId,
-      ...customer
-    });
+    return safe3(
+      this.client.call(ORDER_MUTATION.UPDATE_CUSTOMER, {
+        order_id: orderId,
+        ...customer
+      })
+    );
   }
   async verifyPayment(orderId) {
-    return this.client.call("order.verifyPayment", {
-      order_id: orderId
-    });
+    return safe3(
+      this.client.call("order.verifyPayment", {
+        order_id: orderId
+      })
+    );
   }
 };
 
 // src/orders.ts
+function toCimplifyError4(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe4(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError4(error));
+  }
+}
 var OrderQueries = class {
   constructor(client) {
     this.client = client;
@@ -527,141 +747,213 @@ var OrderQueries = class {
     if (options?.offset) {
       query2 += `#offset(${options.offset})`;
     }
-    return this.client.query(query2);
+    return safe4(this.client.query(query2));
   }
   async get(orderId) {
-    return this.client.query(`orders.${orderId}`);
+    return safe4(this.client.query(`orders.${orderId}`));
   }
   async getRecent(limit = 5) {
-    return this.client.query(`orders#sort(created_at,desc)#limit(${limit})`);
+    return safe4(this.client.query(`orders#sort(created_at,desc)#limit(${limit})`));
   }
   async getByStatus(status) {
-    return this.client.query(`orders[?(@.status=='${status}')]`);
+    return safe4(this.client.query(`orders[?(@.status=='${status}')]`));
   }
   async cancel(orderId, reason) {
-    return this.client.call("order.cancelOrder", {
-      order_id: orderId,
-      reason
-    });
+    return safe4(
+      this.client.call("order.cancelOrder", {
+        order_id: orderId,
+        reason
+      })
+    );
   }
 };
 
 // src/link.ts
+function toCimplifyError5(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe5(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError5(error));
+  }
+}
 var LinkService = class {
   constructor(client) {
     this.client = client;
   }
+  // --------------------------------------------------------------------------
+  // AUTHENTICATION
+  // --------------------------------------------------------------------------
   async requestOtp(input) {
-    return this.client.linkPost("/v1/link/auth/request-otp", input);
+    return safe5(this.client.linkPost("/v1/link/auth/request-otp", input));
   }
   async verifyOtp(input) {
-    const response = await this.client.linkPost("/v1/link/auth/verify-otp", input);
-    if (response.session_token) {
-      this.client.setSessionToken(response.session_token);
+    const result = await safe5(
+      this.client.linkPost("/v1/link/auth/verify-otp", input)
+    );
+    if (result.ok && result.value.session_token) {
+      this.client.setSessionToken(result.value.session_token);
     }
-    return response;
+    return result;
   }
   async logout() {
-    const result = await this.client.linkPost("/v1/link/auth/logout");
-    this.client.clearSession();
+    const result = await safe5(this.client.linkPost("/v1/link/auth/logout"));
+    if (result.ok) {
+      this.client.clearSession();
+    }
     return result;
   }
+  // --------------------------------------------------------------------------
+  // STATUS & DATA
+  // --------------------------------------------------------------------------
   async checkStatus(contact) {
-    return this.client.call(LINK_MUTATION.CHECK_STATUS, {
-      contact
-    });
+    return safe5(
+      this.client.call(LINK_MUTATION.CHECK_STATUS, {
+        contact
+      })
+    );
   }
   async getLinkData() {
-    return this.client.query(LINK_QUERY.DATA);
+    return safe5(this.client.query(LINK_QUERY.DATA));
   }
   async getAddresses() {
-    return this.client.query(LINK_QUERY.ADDRESSES);
+    return safe5(this.client.query(LINK_QUERY.ADDRESSES));
   }
   async getMobileMoney() {
-    return this.client.query(LINK_QUERY.MOBILE_MONEY);
+    return safe5(this.client.query(LINK_QUERY.MOBILE_MONEY));
   }
   async getPreferences() {
-    return this.client.query(LINK_QUERY.PREFERENCES);
+    return safe5(this.client.query(LINK_QUERY.PREFERENCES));
   }
+  // --------------------------------------------------------------------------
+  // ENROLLMENT
+  // --------------------------------------------------------------------------
   async enroll(data) {
-    return this.client.call(LINK_MUTATION.ENROLL, data);
+    return safe5(this.client.call(LINK_MUTATION.ENROLL, data));
   }
   async enrollAndLinkOrder(data) {
-    return this.client.call(LINK_MUTATION.ENROLL_AND_LINK_ORDER, data);
+    return safe5(
+      this.client.call(LINK_MUTATION.ENROLL_AND_LINK_ORDER, data)
+    );
   }
+  // --------------------------------------------------------------------------
+  // PREFERENCES
+  // --------------------------------------------------------------------------
   async updatePreferences(preferences) {
-    return this.client.call(LINK_MUTATION.UPDATE_PREFERENCES, preferences);
+    return safe5(this.client.call(LINK_MUTATION.UPDATE_PREFERENCES, preferences));
   }
+  // --------------------------------------------------------------------------
+  // ADDRESSES
+  // --------------------------------------------------------------------------
   async createAddress(input) {
-    return this.client.call(LINK_MUTATION.CREATE_ADDRESS, input);
+    return safe5(this.client.call(LINK_MUTATION.CREATE_ADDRESS, input));
   }
   async updateAddress(input) {
-    return this.client.call(LINK_MUTATION.UPDATE_ADDRESS, input);
+    return safe5(this.client.call(LINK_MUTATION.UPDATE_ADDRESS, input));
   }
   async deleteAddress(addressId) {
-    return this.client.call(LINK_MUTATION.DELETE_ADDRESS, addressId);
+    return safe5(this.client.call(LINK_MUTATION.DELETE_ADDRESS, addressId));
   }
   async setDefaultAddress(addressId) {
-    return this.client.call(LINK_MUTATION.SET_DEFAULT_ADDRESS, addressId);
+    return safe5(this.client.call(LINK_MUTATION.SET_DEFAULT_ADDRESS, addressId));
   }
   async trackAddressUsage(addressId) {
-    return this.client.call(LINK_MUTATION.TRACK_ADDRESS_USAGE, {
-      address_id: addressId
-    });
+    return safe5(
+      this.client.call(LINK_MUTATION.TRACK_ADDRESS_USAGE, {
+        address_id: addressId
+      })
+    );
   }
+  // --------------------------------------------------------------------------
+  // MOBILE MONEY
+  // --------------------------------------------------------------------------
   async createMobileMoney(input) {
-    return this.client.call(LINK_MUTATION.CREATE_MOBILE_MONEY, input);
+    return safe5(this.client.call(LINK_MUTATION.CREATE_MOBILE_MONEY, input));
   }
   async deleteMobileMoney(mobileMoneyId) {
-    return this.client.call(LINK_MUTATION.DELETE_MOBILE_MONEY, mobileMoneyId);
+    return safe5(this.client.call(LINK_MUTATION.DELETE_MOBILE_MONEY, mobileMoneyId));
   }
   async setDefaultMobileMoney(mobileMoneyId) {
-    return this.client.call(LINK_MUTATION.SET_DEFAULT_MOBILE_MONEY, mobileMoneyId);
+    return safe5(
+      this.client.call(LINK_MUTATION.SET_DEFAULT_MOBILE_MONEY, mobileMoneyId)
+    );
   }
   async trackMobileMoneyUsage(mobileMoneyId) {
-    return this.client.call(LINK_MUTATION.TRACK_MOBILE_MONEY_USAGE, {
-      mobile_money_id: mobileMoneyId
-    });
+    return safe5(
+      this.client.call(LINK_MUTATION.TRACK_MOBILE_MONEY_USAGE, {
+        mobile_money_id: mobileMoneyId
+      })
+    );
   }
   async verifyMobileMoney(mobileMoneyId) {
-    return this.client.call(LINK_MUTATION.VERIFY_MOBILE_MONEY, mobileMoneyId);
+    return safe5(
+      this.client.call(LINK_MUTATION.VERIFY_MOBILE_MONEY, mobileMoneyId)
+    );
   }
+  // --------------------------------------------------------------------------
+  // SESSIONS
+  // --------------------------------------------------------------------------
   async getSessions() {
-    return this.client.linkGet("/v1/link/sessions");
+    return safe5(this.client.linkGet("/v1/link/sessions"));
   }
   async revokeSession(sessionId) {
-    return this.client.linkDelete(`/v1/link/sessions/${sessionId}`);
+    return safe5(this.client.linkDelete(`/v1/link/sessions/${sessionId}`));
   }
   async revokeAllSessions() {
-    return this.client.linkDelete("/v1/link/sessions");
+    return safe5(this.client.linkDelete("/v1/link/sessions"));
   }
+  // --------------------------------------------------------------------------
+  // REST ALTERNATIVES (for direct API access)
+  // --------------------------------------------------------------------------
   async getAddressesRest() {
-    return this.client.linkGet("/v1/link/addresses");
+    return safe5(this.client.linkGet("/v1/link/addresses"));
   }
   async createAddressRest(input) {
-    return this.client.linkPost("/v1/link/addresses", input);
+    return safe5(this.client.linkPost("/v1/link/addresses", input));
   }
   async deleteAddressRest(addressId) {
-    return this.client.linkDelete(`/v1/link/addresses/${addressId}`);
+    return safe5(this.client.linkDelete(`/v1/link/addresses/${addressId}`));
   }
   async setDefaultAddressRest(addressId) {
-    return this.client.linkPost(`/v1/link/addresses/${addressId}/default`);
+    return safe5(this.client.linkPost(`/v1/link/addresses/${addressId}/default`));
   }
   async getMobileMoneyRest() {
-    return this.client.linkGet("/v1/link/mobile-money");
+    return safe5(this.client.linkGet("/v1/link/mobile-money"));
   }
   async createMobileMoneyRest(input) {
-    return this.client.linkPost("/v1/link/mobile-money", input);
+    return safe5(this.client.linkPost("/v1/link/mobile-money", input));
   }
   async deleteMobileMoneyRest(mobileMoneyId) {
-    return this.client.linkDelete(`/v1/link/mobile-money/${mobileMoneyId}`);
+    return safe5(this.client.linkDelete(`/v1/link/mobile-money/${mobileMoneyId}`));
   }
   async setDefaultMobileMoneyRest(mobileMoneyId) {
-    return this.client.linkPost(`/v1/link/mobile-money/${mobileMoneyId}/default`);
+    return safe5(
+      this.client.linkPost(`/v1/link/mobile-money/${mobileMoneyId}/default`)
+    );
   }
 };
 
 // src/auth.ts
+function toCimplifyError6(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe6(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError6(error));
+  }
+}
 var AuthService = class {
   constructor(client) {
     this.client = client;
@@ -670,52 +962,72 @@ var AuthService = class {
   // STATUS & USER
   // --------------------------------------------------------------------------
   async getStatus() {
-    return this.client.query("auth");
+    return safe6(this.client.query("auth"));
   }
   async getCurrentUser() {
-    const status = await this.getStatus();
-    return status.customer || null;
+    const result = await this.getStatus();
+    if (!result.ok) return result;
+    return ok(result.value.customer || null);
   }
   async isAuthenticated() {
-    const status = await this.getStatus();
-    return status.is_authenticated;
+    const result = await this.getStatus();
+    if (!result.ok) return result;
+    return ok(result.value.is_authenticated);
   }
   // --------------------------------------------------------------------------
   // OTP AUTHENTICATION
   // --------------------------------------------------------------------------
   async requestOtp(contact, contactType) {
-    await this.client.call(AUTH_MUTATION.REQUEST_OTP, {
-      contact,
-      contact_type: contactType
-    });
+    return safe6(
+      this.client.call(AUTH_MUTATION.REQUEST_OTP, {
+        contact,
+        contact_type: contactType
+      })
+    );
   }
   async verifyOtp(code, contact) {
-    return this.client.call(AUTH_MUTATION.VERIFY_OTP, {
-      otp_code: code,
-      contact
-    });
+    return safe6(
+      this.client.call(AUTH_MUTATION.VERIFY_OTP, {
+        otp_code: code,
+        contact
+      })
+    );
   }
   // --------------------------------------------------------------------------
   // SESSION MANAGEMENT
   // --------------------------------------------------------------------------
   async logout() {
-    return this.client.call("auth.logout");
+    return safe6(this.client.call("auth.logout"));
   }
   // --------------------------------------------------------------------------
   // PROFILE MANAGEMENT
   // --------------------------------------------------------------------------
   async updateProfile(input) {
-    return this.client.call("auth.update_profile", input);
+    return safe6(this.client.call("auth.update_profile", input));
   }
   async changePassword(input) {
-    return this.client.call("auth.change_password", input);
+    return safe6(this.client.call("auth.change_password", input));
   }
   async resetPassword(email) {
-    return this.client.call("auth.reset_password", { email });
+    return safe6(this.client.call("auth.reset_password", { email }));
   }
 };
 
 // src/business.ts
+function toCimplifyError7(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe7(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError7(error));
+  }
+}
 var BusinessService = class {
   constructor(client) {
     this.client = client;
@@ -724,49 +1036,55 @@ var BusinessService = class {
   // BUSINESS INFO
   // --------------------------------------------------------------------------
   async getInfo() {
-    return this.client.query("business.info");
+    return safe7(this.client.query("business.info"));
   }
   async getByHandle(handle) {
-    return this.client.query(`business.handle.${handle}`);
+    return safe7(this.client.query(`business.handle.${handle}`));
   }
   async getByDomain(domain) {
-    return this.client.query("business.domain", { domain });
+    return safe7(this.client.query("business.domain", { domain }));
   }
   async getSettings() {
-    return this.client.query("business.settings");
+    return safe7(this.client.query("business.settings"));
   }
   async getTheme() {
-    return this.client.query("business.theme");
+    return safe7(this.client.query("business.theme"));
   }
   // --------------------------------------------------------------------------
   // LOCATIONS
   // --------------------------------------------------------------------------
   async getLocations() {
-    return this.client.query("business.locations");
+    return safe7(this.client.query("business.locations"));
   }
   async getLocation(locationId) {
-    return this.client.query(`business.locations.${locationId}`);
+    return safe7(this.client.query(`business.locations.${locationId}`));
   }
   // --------------------------------------------------------------------------
   // HOURS
   // --------------------------------------------------------------------------
   async getHours() {
-    return this.client.query("business.hours");
+    return safe7(this.client.query("business.hours"));
   }
   async getLocationHours(locationId) {
-    return this.client.query(`business.locations.${locationId}.hours`);
+    return safe7(this.client.query(`business.locations.${locationId}.hours`));
   }
   // --------------------------------------------------------------------------
   // BOOTSTRAP (for storefront initialization)
   // --------------------------------------------------------------------------
   async getBootstrap() {
-    const [business, locations, categories] = await Promise.all([
+    const [businessResult, locationsResult, categoriesResult] = await Promise.all([
       this.getInfo(),
       this.getLocations(),
-      this.client.query("categories#select(id,name,slug)")
+      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 {
+    return ok({
       business,
       location: defaultLocation,
       locations,
@@ -774,11 +1092,25 @@ var BusinessService = class {
       currency: business.default_currency,
       is_open: defaultLocation?.accepts_online_orders ?? false,
       accepts_orders: defaultLocation?.accepts_online_orders ?? false
-    };
+    });
   }
 };
 
 // src/inventory.ts
+function toCimplifyError8(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe8(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError8(error));
+  }
+}
 var InventoryService = class {
   constructor(client) {
     this.client = client;
@@ -787,41 +1119,51 @@ var InventoryService = class {
   // STOCK QUERIES
   // --------------------------------------------------------------------------
   async getStockLevels() {
-    return this.client.query("inventory.stock_levels");
+    return safe8(this.client.query("inventory.stock_levels"));
   }
   async getProductStock(productId, locationId) {
     if (locationId) {
-      return this.client.query("inventory.product", {
-        product_id: productId,
-        location_id: locationId
-      });
+      return safe8(
+        this.client.query("inventory.product", {
+          product_id: productId,
+          location_id: locationId
+        })
+      );
     }
-    return this.client.query("inventory.product", {
-      product_id: productId
-    });
+    return safe8(
+      this.client.query("inventory.product", {
+        product_id: productId
+      })
+    );
   }
   async getVariantStock(variantId, locationId) {
-    return this.client.query("inventory.variant", {
-      variant_id: variantId,
-      location_id: locationId
-    });
+    return safe8(
+      this.client.query("inventory.variant", {
+        variant_id: variantId,
+        location_id: locationId
+      })
+    );
   }
   // --------------------------------------------------------------------------
   // AVAILABILITY CHECKS
   // --------------------------------------------------------------------------
   async checkProductAvailability(productId, quantity, locationId) {
-    return this.client.query("inventory.check_availability", {
-      product_id: productId,
-      quantity,
-      location_id: locationId
-    });
+    return safe8(
+      this.client.query("inventory.check_availability", {
+        product_id: productId,
+        quantity,
+        location_id: locationId
+      })
+    );
   }
   async checkVariantAvailability(variantId, quantity, locationId) {
-    return this.client.query("inventory.check_availability", {
-      variant_id: variantId,
-      quantity,
-      location_id: locationId
-    });
+    return safe8(
+      this.client.query("inventory.check_availability", {
+        variant_id: variantId,
+        quantity,
+        location_id: locationId
+      })
+    );
   }
   async checkMultipleAvailability(items, locationId) {
     const results = await Promise.all(
@@ -829,28 +1171,47 @@ var InventoryService = class {
         (item) => item.variant_id ? this.checkVariantAvailability(item.variant_id, item.quantity, locationId) : this.checkProductAvailability(item.product_id, item.quantity, locationId)
       )
     );
-    return results;
+    for (const result of results) {
+      if (!result.ok) return result;
+    }
+    return ok(results.map((r) => r.value));
   }
   // --------------------------------------------------------------------------
   // SUMMARY
   // --------------------------------------------------------------------------
   async getSummary() {
-    return this.client.query("inventory.summary");
+    return safe8(this.client.query("inventory.summary"));
   }
   // --------------------------------------------------------------------------
   // CONVENIENCE METHODS
   // --------------------------------------------------------------------------
   async isInStock(productId, locationId) {
     const result = await this.checkProductAvailability(productId, 1, locationId);
-    return result.is_available;
+    if (!result.ok) return result;
+    return ok(result.value.is_available);
   }
   async getAvailableQuantity(productId, locationId) {
-    const stock = await this.getProductStock(productId, locationId);
-    return stock.available_quantity;
+    const result = await this.getProductStock(productId, locationId);
+    if (!result.ok) return result;
+    return ok(result.value.available_quantity);
   }
 };
 
 // src/scheduling.ts
+function toCimplifyError9(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe9(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError9(error));
+  }
+}
 var SchedulingService = class {
   constructor(client) {
     this.client = client;
@@ -859,86 +1220,113 @@ var SchedulingService = class {
   // SERVICES
   // --------------------------------------------------------------------------
   async getServices() {
-    return this.client.query("scheduling.services");
+    return safe9(this.client.query("scheduling.services"));
   }
   /**
    * Get a specific service by ID
    * Note: Filters from all services client-side (no single-service endpoint)
    */
   async getService(serviceId) {
-    const services = await this.getServices();
-    return services.find((s) => s.id === serviceId) || null;
+    const result = await this.getServices();
+    if (!result.ok) return result;
+    return ok(result.value.find((s) => s.id === serviceId) || null);
   }
   // --------------------------------------------------------------------------
   // AVAILABILITY
   // --------------------------------------------------------------------------
   async getAvailableSlots(input) {
-    return this.client.query(
-      "scheduling.slots",
-      input
+    return safe9(
+      this.client.query(
+        "scheduling.slots",
+        input
+      )
     );
   }
   async checkSlotAvailability(input) {
-    return this.client.query(
-      "scheduling.check_availability",
-      input
+    return safe9(
+      this.client.query(
+        "scheduling.check_availability",
+        input
+      )
     );
   }
   async getServiceAvailability(params) {
-    return this.client.query(
-      "scheduling.availability",
-      params
+    return safe9(
+      this.client.query(
+        "scheduling.availability",
+        params
+      )
     );
   }
   // --------------------------------------------------------------------------
   // BOOKINGS
   // --------------------------------------------------------------------------
   async getBooking(bookingId) {
-    return this.client.query(`scheduling.${bookingId}`);
+    return safe9(this.client.query(`scheduling.${bookingId}`));
   }
   async getCustomerBookings() {
-    return this.client.query("scheduling");
+    return safe9(this.client.query("scheduling"));
   }
   async getUpcomingBookings() {
-    return this.client.query(
-      "scheduling[?(@.status!='completed' && @.status!='cancelled')]#sort(start_time,asc)"
+    return safe9(
+      this.client.query(
+        "scheduling[?(@.status!='completed' && @.status!='cancelled')]#sort(start_time,asc)"
+      )
     );
   }
   async getPastBookings(limit = 10) {
-    return this.client.query(
-      `scheduling[?(@.status=='completed')]#sort(start_time,desc)#limit(${limit})`
+    return safe9(
+      this.client.query(
+        `scheduling[?(@.status=='completed')]#sort(start_time,desc)#limit(${limit})`
+      )
     );
   }
   // --------------------------------------------------------------------------
   // BOOKING MANAGEMENT
   // --------------------------------------------------------------------------
   async cancelBooking(input) {
-    return this.client.call("scheduling.cancel_booking", input);
+    return safe9(this.client.call("scheduling.cancel_booking", input));
   }
   async rescheduleBooking(input) {
-    return this.client.call("scheduling.reschedule_booking", input);
+    return safe9(this.client.call("scheduling.reschedule_booking", input));
   }
   // --------------------------------------------------------------------------
   // CONVENIENCE METHODS
   // --------------------------------------------------------------------------
   async getNextAvailableSlot(serviceId, fromDate) {
     const date = fromDate || (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    const slots = await this.getAvailableSlots({
+    const result = await this.getAvailableSlots({
       service_id: serviceId,
       date
     });
-    return slots.find((slot) => slot.is_available) || null;
+    if (!result.ok) return result;
+    return ok(result.value.find((slot) => slot.is_available) || null);
   }
   async hasAvailabilityOn(serviceId, date) {
-    const slots = await this.getAvailableSlots({
+    const result = await this.getAvailableSlots({
       service_id: serviceId,
       date
     });
-    return slots.some((slot) => slot.is_available);
+    if (!result.ok) return result;
+    return ok(result.value.some((slot) => slot.is_available));
   }
 };
 
 // src/lite.ts
+function toCimplifyError10(error) {
+  if (error instanceof CimplifyError) return error;
+  if (error instanceof Error) {
+    return new CimplifyError("UNKNOWN_ERROR", error.message, false);
+  }
+  return new CimplifyError("UNKNOWN_ERROR", String(error), false);
+}
+async function safe10(promise) {
+  try {
+    return ok(await promise);
+  } catch (error) {
+    return err(toCimplifyError10(error));
+  }
+}
 var LiteService = class {
   constructor(client) {
     this.client = client;
@@ -947,48 +1335,56 @@ var LiteService = class {
   // BOOTSTRAP
   // --------------------------------------------------------------------------
   async getBootstrap() {
-    return this.client.query("lite.bootstrap");
+    return safe10(this.client.query("lite.bootstrap"));
   }
   // --------------------------------------------------------------------------
   // TABLE MANAGEMENT
   // --------------------------------------------------------------------------
   async getTable(tableId) {
-    return this.client.query(`lite.table.${tableId}`);
+    return safe10(this.client.query(`lite.table.${tableId}`));
   }
   async getTableByNumber(tableNumber, locationId) {
-    return this.client.query("lite.table_by_number", {
-      table_number: tableNumber,
-      location_id: locationId
-    });
+    return safe10(
+      this.client.query("lite.table_by_number", {
+        table_number: tableNumber,
+        location_id: locationId
+      })
+    );
   }
   // --------------------------------------------------------------------------
   // KITCHEN ORDERS
   // --------------------------------------------------------------------------
   async sendToKitchen(tableId, items) {
-    return this.client.call("lite.send_to_kitchen", {
-      table_id: tableId,
-      items
-    });
+    return safe10(
+      this.client.call("lite.send_to_kitchen", {
+        table_id: tableId,
+        items
+      })
+    );
   }
   async callWaiter(tableId, reason) {
-    return this.client.call("lite.call_waiter", {
-      table_id: tableId,
-      reason
-    });
+    return safe10(
+      this.client.call("lite.call_waiter", {
+        table_id: tableId,
+        reason
+      })
+    );
   }
   async requestBill(tableId) {
-    return this.client.call("lite.request_bill", {
-      table_id: tableId
-    });
+    return safe10(
+      this.client.call("lite.request_bill", {
+        table_id: tableId
+      })
+    );
   }
   // --------------------------------------------------------------------------
   // MENU (optimized for lite/QR experience)
   // --------------------------------------------------------------------------
   async getMenu() {
-    return this.client.query("lite.menu");
+    return safe10(this.client.query("lite.menu"));
   }
   async getMenuByCategory(categoryId) {
-    return this.client.query(`lite.menu.category.${categoryId}`);
+    return safe10(this.client.query(`lite.menu.category.${categoryId}`));
   }
 };
 
@@ -1818,27 +2214,41 @@ exports.PICKUP_TIME_TYPE = PICKUP_TIME_TYPE;
 exports.QueryBuilder = QueryBuilder;
 exports.SchedulingService = SchedulingService;
 exports.categorizePaymentError = categorizePaymentError;
+exports.combine = combine;
+exports.combineObject = combineObject;
 exports.createCimplifyClient = createCimplifyClient;
 exports.detectMobileMoneyProvider = detectMobileMoneyProvider;
+exports.err = err;
 exports.extractPriceInfo = extractPriceInfo;
+exports.flatMap = flatMap;
 exports.formatMoney = formatMoney;
 exports.formatNumberCompact = formatNumberCompact;
 exports.formatPrice = formatPrice;
 exports.formatPriceAdjustment = formatPriceAdjustment;
 exports.formatPriceCompact = formatPriceCompact;
 exports.formatProductPrice = formatProductPrice;
+exports.fromPromise = fromPromise;
 exports.getBasePrice = getBasePrice;
 exports.getCurrencySymbol = getCurrencySymbol;
 exports.getDiscountPercentage = getDiscountPercentage;
 exports.getDisplayPrice = getDisplayPrice;
 exports.getMarkupPercentage = getMarkupPercentage;
+exports.getOrElse = getOrElse;
 exports.getProductCurrency = getProductCurrency;
 exports.isCimplifyError = isCimplifyError;
+exports.isErr = isErr;
+exports.isOk = isOk;
 exports.isOnSale = isOnSale;
 exports.isRetryableError = isRetryableError;
+exports.mapError = mapError;
+exports.mapResult = mapResult;
 exports.normalizePaymentResponse = normalizePaymentResponse;
 exports.normalizeStatusResponse = normalizeStatusResponse;
+exports.ok = ok;
 exports.parsePrice = parsePrice;
 exports.parsePricePath = parsePricePath;
 exports.parsedPriceToPriceInfo = parsedPriceToPriceInfo;
 exports.query = query;
+exports.toNullable = toNullable;
+exports.tryCatch = tryCatch;
+exports.unwrap = unwrap;