@cimplify/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1500 @@
+'use strict';
+
+// src/types/common.ts
+var CimplifyError = class extends Error {
+  constructor(code, message, retryable = false) {
+    super(message);
+    this.code = code;
+    this.retryable = retryable;
+    this.name = "CimplifyError";
+  }
+};
+
+// src/catalogue.ts
+var CatalogueQueries = class {
+  constructor(client) {
+    this.client = client;
+  }
+  // --------------------------------------------------------------------------
+  // PRODUCTS
+  // --------------------------------------------------------------------------
+  async getProducts(options) {
+    let query2 = "products";
+    const filters = [];
+    if (options?.category) {
+      filters.push(`@.category_id=='${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 '${options.search}'`);
+    }
+    if (options?.min_price !== void 0) {
+      filters.push(`@.price>=${options.min_price}`);
+    }
+    if (options?.max_price !== void 0) {
+      filters.push(`@.price<=${options.max_price}`);
+    }
+    if (filters.length > 0) {
+      query2 += `[?(${filters.join(" && ")})]`;
+    }
+    if (options?.sort_by) {
+      query2 += `#sort(${options.sort_by},${options.sort_order || "asc"})`;
+    }
+    if (options?.limit) {
+      query2 += `#limit(${options.limit})`;
+    }
+    if (options?.offset) {
+      query2 += `#offset(${options.offset})`;
+    }
+    return this.client.query(query2);
+  }
+  async getProduct(id) {
+    return this.client.query(`products.${id}`);
+  }
+  async getProductBySlug(slug) {
+    const products = await this.client.query(
+      `products[?(@.slug=='${slug}')]`
+    );
+    if (!products.length) {
+      throw new Error(`Product not found: ${slug}`);
+    }
+    return products[0];
+  }
+  // --------------------------------------------------------------------------
+  // VARIANTS
+  // --------------------------------------------------------------------------
+  async getVariants(productId) {
+    return this.client.query(`products.${productId}.variants`);
+  }
+  async getVariantAxes(productId) {
+    return 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 }
+    );
+  }
+  /**
+   * Get a specific variant by its ID
+   */
+  async getVariantById(productId, variantId) {
+    return this.client.query(
+      `products.${productId}.variant.${variantId}`
+    );
+  }
+  // --------------------------------------------------------------------------
+  // ADD-ONS
+  // --------------------------------------------------------------------------
+  async getAddOns(productId) {
+    return this.client.query(`products.${productId}.add_ons`);
+  }
+  // --------------------------------------------------------------------------
+  // CATEGORIES
+  // --------------------------------------------------------------------------
+  async getCategories() {
+    return this.client.query("categories");
+  }
+  async getCategory(id) {
+    return 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}`);
+    }
+    return categories[0];
+  }
+  async getCategoryProducts(categoryId) {
+    return this.client.query(
+      `products[?(@.category_id=='${categoryId}')]`
+    );
+  }
+  // --------------------------------------------------------------------------
+  // COLLECTIONS
+  // --------------------------------------------------------------------------
+  async getCollections() {
+    return this.client.query("collections");
+  }
+  async getCollection(id) {
+    return 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}`);
+    }
+    return collections[0];
+  }
+  async getCollectionProducts(collectionId) {
+    return this.client.query(`collections.${collectionId}.products`);
+  }
+  async searchCollections(query2, limit = 20) {
+    return this.client.query(
+      `collections[?(@.name contains '${query2}')]#limit(${limit})`
+    );
+  }
+  // --------------------------------------------------------------------------
+  // BUNDLES
+  // --------------------------------------------------------------------------
+  async getBundles() {
+    return this.client.query("bundles");
+  }
+  async getBundle(id) {
+    return 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}`);
+    }
+    return bundles[0];
+  }
+  async searchBundles(query2, limit = 20) {
+    return this.client.query(
+      `bundles[?(@.name contains '${query2}')]#limit(${limit})`
+    );
+  }
+  // --------------------------------------------------------------------------
+  // COMPOSITES (Build-Your-Own)
+  // --------------------------------------------------------------------------
+  async getComposites(options) {
+    let query2 = "composites";
+    if (options?.limit) {
+      query2 += `#limit(${options.limit})`;
+    }
+    return this.client.query(query2);
+  }
+  async getComposite(id) {
+    return this.client.query(`composites.${id}`);
+  }
+  async getCompositeByProductId(productId) {
+    return 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
+      }
+    );
+  }
+  // --------------------------------------------------------------------------
+  // SEARCH
+  // --------------------------------------------------------------------------
+  async search(query2, options) {
+    const limit = options?.limit ?? 20;
+    let searchQuery = `products[?(@.name contains '${query2}')]`;
+    if (options?.category) {
+      searchQuery = `products[?(@.name contains '${query2}' && @.category_id=='${options.category}')]`;
+    }
+    searchQuery += `#limit(${limit})`;
+    return this.client.query(searchQuery);
+  }
+  async searchProducts(query2, options) {
+    return this.client.call("catalogue.search", {
+      query: query2,
+      limit: options?.limit ?? 20,
+      category: options?.category
+    });
+  }
+  // --------------------------------------------------------------------------
+  // MENU (Restaurant-specific)
+  // --------------------------------------------------------------------------
+  async getMenu(options) {
+    let query2 = "menu";
+    if (options?.category) {
+      query2 = `menu[?(@.category=='${options.category}')]`;
+    }
+    if (options?.limit) {
+      query2 += `#limit(${options.limit})`;
+    }
+    return this.client.query(query2);
+  }
+  async getMenuCategory(categoryId) {
+    return this.client.query(`menu.category.${categoryId}`);
+  }
+  async getMenuItem(itemId) {
+    return this.client.query(`menu.${itemId}`);
+  }
+};
+
+// src/cart.ts
+var CartOperations = class {
+  constructor(client) {
+    this.client = client;
+  }
+  // --------------------------------------------------------------------------
+  // CART QUERIES
+  // --------------------------------------------------------------------------
+  /**
+   * Get the enriched cart with product names, images, and details.
+   * This is the main method for storefront display.
+   */
+  async get() {
+    return this.client.query("cart#enriched");
+  }
+  async getRaw() {
+    return this.client.query("cart");
+  }
+  async getItems() {
+    return this.client.query("cart_items");
+  }
+  async getCount() {
+    return this.client.query("cart#count");
+  }
+  async getTotal() {
+    return this.client.query("cart#total");
+  }
+  async getSummary() {
+    const cart = await this.get();
+    return {
+      item_count: cart.items.length,
+      total_items: cart.items.reduce((sum, item) => sum + item.quantity, 0),
+      subtotal: cart.pricing.subtotal,
+      discount_amount: cart.pricing.total_discounts,
+      tax_amount: cart.pricing.tax_amount,
+      total: cart.pricing.total_price,
+      currency: cart.pricing.currency
+    };
+  }
+  // --------------------------------------------------------------------------
+  // CART MUTATIONS
+  // --------------------------------------------------------------------------
+  async addItem(input) {
+    return this.client.call("cart.addItem", input);
+  }
+  async updateItem(cartItemId, updates) {
+    return 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
+    });
+  }
+  async removeItem(cartItemId) {
+    return this.client.call("cart.removeItem", {
+      cart_item_id: cartItemId
+    });
+  }
+  async clear() {
+    return this.client.call("cart.clearCart");
+  }
+  // --------------------------------------------------------------------------
+  // COUPONS & DISCOUNTS
+  // --------------------------------------------------------------------------
+  async applyCoupon(code) {
+    return this.client.call("cart.applyCoupon", {
+      coupon_code: code
+    });
+  }
+  async removeCoupon() {
+    return this.client.call("cart.removeCoupon");
+  }
+  // --------------------------------------------------------------------------
+  // CONVENIENCE METHODS
+  // --------------------------------------------------------------------------
+  async isEmpty() {
+    const count = await this.getCount();
+    return count === 0;
+  }
+  async hasItem(productId, variantId) {
+    const items = await this.getItems();
+    return items.some((item) => {
+      const matchesProduct = item.item_id === productId;
+      if (!variantId) return matchesProduct;
+      const config = item.configuration;
+      if ("variant" in config && config.variant) {
+        return matchesProduct && config.variant.variant_id === variantId;
+      }
+      return matchesProduct;
+    });
+  }
+  async findItem(productId, variantId) {
+    const items = await this.getItems();
+    return items.find((item) => {
+      const matchesProduct = item.item_id === productId;
+      if (!variantId) return matchesProduct;
+      const config = item.configuration;
+      if ("variant" in config && config.variant) {
+        return matchesProduct && config.variant.variant_id === variantId;
+      }
+      return matchesProduct;
+    });
+  }
+};
+
+// src/constants.ts
+var CHECKOUT_MODE = {
+  LINK: "link",
+  GUEST: "guest"
+};
+var ORDER_TYPE = {
+  DELIVERY: "delivery",
+  PICKUP: "pickup",
+  DINE_IN: "dine-in",
+  WALK_IN: "walk-in"
+};
+var PAYMENT_METHOD = {
+  MOBILE_MONEY: "mobile_money",
+  CARD: "card"
+};
+var CHECKOUT_STEP = {
+  AUTHENTICATION: "authentication",
+  ORDER_DETAILS: "order_details",
+  PAYMENT_METHOD: "payment_method",
+  PAYMENT: "payment",
+  CONFIRMATION: "confirmation"
+};
+var PAYMENT_STATE = {
+  INITIAL: "initial",
+  PREPARING: "preparing",
+  PROCESSING: "processing",
+  VERIFYING: "verifying",
+  AWAITING_AUTHORIZATION: "awaiting_authorization",
+  SUCCESS: "success",
+  ERROR: "error",
+  TIMEOUT: "timeout"
+};
+var PICKUP_TIME_TYPE = {
+  ASAP: "asap",
+  SCHEDULED: "scheduled"
+};
+var MOBILE_MONEY_PROVIDER = {
+  MTN: "mtn",
+  VODAFONE: "vodafone",
+  AIRTEL: "airtel"
+};
+var AUTHORIZATION_TYPE = {
+  OTP: "otp",
+  PIN: "pin",
+  PHONE: "phone",
+  BIRTHDAY: "birthday",
+  ADDRESS: "address"
+};
+var LINK_QUERY = {
+  DATA: "link.data",
+  ADDRESSES: "link.addresses",
+  MOBILE_MONEY: "link.mobile_money",
+  PREFERENCES: "link.preferences",
+  SESSIONS: "link.sessions"
+};
+var LINK_MUTATION = {
+  CHECK_STATUS: "link.check_status",
+  ENROLL: "link.enroll",
+  ENROLL_AND_LINK_ORDER: "link.enroll_and_link_order",
+  UPDATE_PREFERENCES: "link.update_preferences",
+  CREATE_ADDRESS: "link.create_address",
+  UPDATE_ADDRESS: "link.update_address",
+  DELETE_ADDRESS: "link.delete_address",
+  SET_DEFAULT_ADDRESS: "link.set_default_address",
+  TRACK_ADDRESS_USAGE: "link.track_address_usage",
+  CREATE_MOBILE_MONEY: "link.create_mobile_money",
+  DELETE_MOBILE_MONEY: "link.delete_mobile_money",
+  SET_DEFAULT_MOBILE_MONEY: "link.set_default_mobile_money",
+  TRACK_MOBILE_MONEY_USAGE: "link.track_mobile_money_usage",
+  VERIFY_MOBILE_MONEY: "link.verify_mobile_money",
+  REVOKE_SESSION: "link.revoke_session",
+  REVOKE_ALL_SESSIONS: "link.revoke_all_sessions"
+};
+var AUTH_MUTATION = {
+  REQUEST_OTP: "auth.request_otp",
+  VERIFY_OTP: "auth.verify_otp"
+};
+var CHECKOUT_MUTATION = {
+  PROCESS: "checkout.process"
+};
+var PAYMENT_MUTATION = {
+  SUBMIT_AUTHORIZATION: "payment.submit_authorization",
+  CHECK_STATUS: "order.poll_payment_status"
+};
+var ORDER_MUTATION = {
+  UPDATE_CUSTOMER: "order.update_order_customer"
+};
+var DEFAULT_CURRENCY = "GHS";
+var DEFAULT_COUNTRY = "GHA";
+
+// src/checkout.ts
+var CheckoutService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async process(data) {
+    return 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
+    });
+  }
+  async submitAuthorization(input) {
+    return this.client.call(
+      PAYMENT_MUTATION.SUBMIT_AUTHORIZATION,
+      input
+    );
+  }
+  async pollPaymentStatus(orderId) {
+    return this.client.call(
+      PAYMENT_MUTATION.CHECK_STATUS,
+      orderId
+    );
+  }
+  async updateOrderCustomer(orderId, customer) {
+    return this.client.call(ORDER_MUTATION.UPDATE_CUSTOMER, {
+      order_id: orderId,
+      ...customer
+    });
+  }
+  async verifyPayment(orderId) {
+    return this.client.call("order.verifyPayment", {
+      order_id: orderId
+    });
+  }
+};
+
+// src/orders.ts
+var OrderQueries = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(options) {
+    let query2 = "orders";
+    if (options?.status) {
+      query2 += `[?(@.status=='${options.status}')]`;
+    }
+    query2 += "#sort(created_at,desc)";
+    if (options?.limit) {
+      query2 += `#limit(${options.limit})`;
+    }
+    if (options?.offset) {
+      query2 += `#offset(${options.offset})`;
+    }
+    return this.client.query(query2);
+  }
+  async get(orderId) {
+    return this.client.query(`orders.${orderId}`);
+  }
+  async getRecent(limit = 5) {
+    return this.client.query(
+      `orders#sort(created_at,desc)#limit(${limit})`
+    );
+  }
+  async getByStatus(status) {
+    return this.client.query(`orders[?(@.status=='${status}')]`);
+  }
+  async cancel(orderId, reason) {
+    return this.client.call("order.cancelOrder", {
+      order_id: orderId,
+      reason
+    });
+  }
+};
+
+// src/link.ts
+var LinkService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async requestOtp(input) {
+    return 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);
+    }
+    return response;
+  }
+  async logout() {
+    const result = await this.client.linkPost("/v1/link/auth/logout");
+    this.client.clearSession();
+    return result;
+  }
+  async checkStatus(contact) {
+    return this.client.call(LINK_MUTATION.CHECK_STATUS, {
+      contact
+    });
+  }
+  async getLinkData() {
+    return this.client.query(LINK_QUERY.DATA);
+  }
+  async getAddresses() {
+    return this.client.query(LINK_QUERY.ADDRESSES);
+  }
+  async getMobileMoney() {
+    return this.client.query(LINK_QUERY.MOBILE_MONEY);
+  }
+  async getPreferences() {
+    return this.client.query(LINK_QUERY.PREFERENCES);
+  }
+  async enroll(data) {
+    return this.client.call(LINK_MUTATION.ENROLL, data);
+  }
+  async enrollAndLinkOrder(data) {
+    return this.client.call(
+      LINK_MUTATION.ENROLL_AND_LINK_ORDER,
+      data
+    );
+  }
+  async updatePreferences(preferences) {
+    return this.client.call(
+      LINK_MUTATION.UPDATE_PREFERENCES,
+      preferences
+    );
+  }
+  async createAddress(input) {
+    return this.client.call(
+      LINK_MUTATION.CREATE_ADDRESS,
+      input
+    );
+  }
+  async updateAddress(input) {
+    return this.client.call(LINK_MUTATION.UPDATE_ADDRESS, input);
+  }
+  async deleteAddress(addressId) {
+    return this.client.call(
+      LINK_MUTATION.DELETE_ADDRESS,
+      addressId
+    );
+  }
+  async setDefaultAddress(addressId) {
+    return this.client.call(
+      LINK_MUTATION.SET_DEFAULT_ADDRESS,
+      addressId
+    );
+  }
+  async trackAddressUsage(addressId) {
+    return this.client.call(LINK_MUTATION.TRACK_ADDRESS_USAGE, {
+      address_id: addressId
+    });
+  }
+  async createMobileMoney(input) {
+    return this.client.call(
+      LINK_MUTATION.CREATE_MOBILE_MONEY,
+      input
+    );
+  }
+  async deleteMobileMoney(mobileMoneyId) {
+    return this.client.call(
+      LINK_MUTATION.DELETE_MOBILE_MONEY,
+      mobileMoneyId
+    );
+  }
+  async setDefaultMobileMoney(mobileMoneyId) {
+    return 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
+    });
+  }
+  async verifyMobileMoney(mobileMoneyId) {
+    return this.client.call(
+      LINK_MUTATION.VERIFY_MOBILE_MONEY,
+      mobileMoneyId
+    );
+  }
+  async getSessions() {
+    return this.client.linkGet("/v1/link/sessions");
+  }
+  async revokeSession(sessionId) {
+    return this.client.linkDelete(
+      `/v1/link/sessions/${sessionId}`
+    );
+  }
+  async revokeAllSessions() {
+    return this.client.linkDelete("/v1/link/sessions");
+  }
+  async getAddressesRest() {
+    return this.client.linkGet("/v1/link/addresses");
+  }
+  async createAddressRest(input) {
+    return this.client.linkPost("/v1/link/addresses", input);
+  }
+  async deleteAddressRest(addressId) {
+    return this.client.linkDelete(`/v1/link/addresses/${addressId}`);
+  }
+  async setDefaultAddressRest(addressId) {
+    return this.client.linkPost(
+      `/v1/link/addresses/${addressId}/default`
+    );
+  }
+  async getMobileMoneyRest() {
+    return this.client.linkGet("/v1/link/mobile-money");
+  }
+  async createMobileMoneyRest(input) {
+    return this.client.linkPost("/v1/link/mobile-money", input);
+  }
+  async deleteMobileMoneyRest(mobileMoneyId) {
+    return this.client.linkDelete(
+      `/v1/link/mobile-money/${mobileMoneyId}`
+    );
+  }
+  async setDefaultMobileMoneyRest(mobileMoneyId) {
+    return this.client.linkPost(
+      `/v1/link/mobile-money/${mobileMoneyId}/default`
+    );
+  }
+};
+
+// src/auth.ts
+var AuthService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  // --------------------------------------------------------------------------
+  // STATUS & USER
+  // --------------------------------------------------------------------------
+  async getStatus() {
+    return this.client.query("auth");
+  }
+  async getCurrentUser() {
+    const status = await this.getStatus();
+    return status.customer || null;
+  }
+  async isAuthenticated() {
+    const status = await this.getStatus();
+    return status.is_authenticated;
+  }
+  // --------------------------------------------------------------------------
+  // OTP AUTHENTICATION
+  // --------------------------------------------------------------------------
+  async requestOtp(contact, contactType) {
+    await 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
+    });
+  }
+  // --------------------------------------------------------------------------
+  // SESSION MANAGEMENT
+  // --------------------------------------------------------------------------
+  async logout() {
+    return this.client.call("auth.logout");
+  }
+  // --------------------------------------------------------------------------
+  // PROFILE MANAGEMENT
+  // --------------------------------------------------------------------------
+  async updateProfile(input) {
+    return this.client.call("auth.update_profile", input);
+  }
+  async changePassword(input) {
+    return this.client.call("auth.change_password", input);
+  }
+  async resetPassword(email) {
+    return this.client.call("auth.reset_password", { email });
+  }
+};
+
+// src/business.ts
+var BusinessService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  // --------------------------------------------------------------------------
+  // BUSINESS INFO
+  // --------------------------------------------------------------------------
+  async getInfo() {
+    return this.client.query("business.info");
+  }
+  async getByHandle(handle) {
+    return this.client.query(`business.handle.${handle}`);
+  }
+  async getByDomain(domain) {
+    return this.client.query("business.domain", { domain });
+  }
+  async getSettings() {
+    return this.client.query("business.settings");
+  }
+  async getTheme() {
+    return this.client.query("business.theme");
+  }
+  // --------------------------------------------------------------------------
+  // LOCATIONS
+  // --------------------------------------------------------------------------
+  async getLocations() {
+    return this.client.query("business.locations");
+  }
+  async getLocation(locationId) {
+    return this.client.query(`business.locations.${locationId}`);
+  }
+  // --------------------------------------------------------------------------
+  // HOURS
+  // --------------------------------------------------------------------------
+  async getHours() {
+    return this.client.query("business.hours");
+  }
+  async getLocationHours(locationId) {
+    return this.client.query(
+      `business.locations.${locationId}.hours`
+    );
+  }
+  // --------------------------------------------------------------------------
+  // BOOTSTRAP (for storefront initialization)
+  // --------------------------------------------------------------------------
+  async getBootstrap() {
+    const [business, locations, categories] = await Promise.all([
+      this.getInfo(),
+      this.getLocations(),
+      this.client.query("categories#select(id,name,slug)")
+    ]);
+    const defaultLocation = locations[0];
+    return {
+      business,
+      location: defaultLocation,
+      locations,
+      categories,
+      currency: business.default_currency,
+      is_open: defaultLocation?.accepts_online_orders ?? false,
+      accepts_orders: defaultLocation?.accepts_online_orders ?? false
+    };
+  }
+};
+
+// src/inventory.ts
+var InventoryService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  // --------------------------------------------------------------------------
+  // STOCK QUERIES
+  // --------------------------------------------------------------------------
+  async getStockLevels() {
+    return 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 this.client.query("inventory.product", {
+      product_id: productId
+    });
+  }
+  async getVariantStock(variantId, locationId) {
+    return 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
+    });
+  }
+  async checkVariantAvailability(variantId, quantity, locationId) {
+    return this.client.query("inventory.check_availability", {
+      variant_id: variantId,
+      quantity,
+      location_id: locationId
+    });
+  }
+  async checkMultipleAvailability(items, locationId) {
+    const results = await Promise.all(
+      items.map(
+        (item) => item.variant_id ? this.checkVariantAvailability(item.variant_id, item.quantity, locationId) : this.checkProductAvailability(item.product_id, item.quantity, locationId)
+      )
+    );
+    return results;
+  }
+  // --------------------------------------------------------------------------
+  // SUMMARY
+  // --------------------------------------------------------------------------
+  async getSummary() {
+    return this.client.query("inventory.summary");
+  }
+  // --------------------------------------------------------------------------
+  // CONVENIENCE METHODS
+  // --------------------------------------------------------------------------
+  async isInStock(productId, locationId) {
+    const result = await this.checkProductAvailability(productId, 1, locationId);
+    return result.is_available;
+  }
+  async getAvailableQuantity(productId, locationId) {
+    const stock = await this.getProductStock(productId, locationId);
+    return stock.available_quantity;
+  }
+};
+
+// src/scheduling.ts
+var SchedulingService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  // --------------------------------------------------------------------------
+  // SERVICES
+  // --------------------------------------------------------------------------
+  async getServices() {
+    return this.client.query("scheduling.services");
+  }
+  async getService(serviceId) {
+    return this.client.query(`scheduling.services.${serviceId}`);
+  }
+  // --------------------------------------------------------------------------
+  // AVAILABILITY
+  // --------------------------------------------------------------------------
+  async getAvailableSlots(input) {
+    return this.client.query(
+      "scheduling.available_slots",
+      input
+    );
+  }
+  async checkSlotAvailability(input) {
+    return this.client.query(
+      "scheduling.check_slot",
+      input
+    );
+  }
+  async getServiceAvailability(params) {
+    return this.client.query(
+      "scheduling.service_availability",
+      params
+    );
+  }
+  // --------------------------------------------------------------------------
+  // BOOKINGS
+  // --------------------------------------------------------------------------
+  async getBooking(bookingId) {
+    return this.client.query(`scheduling.bookings.${bookingId}`);
+  }
+  async getCustomerBookings() {
+    return this.client.query("scheduling.customer_bookings");
+  }
+  async getUpcomingBookings() {
+    return this.client.query(
+      "scheduling.customer_bookings[?(@.status!='completed' && @.status!='cancelled')]#sort(start_time,asc)"
+    );
+  }
+  async getPastBookings(limit = 10) {
+    return this.client.query(
+      `scheduling.customer_bookings[?(@.status=='completed')]#sort(start_time,desc)#limit(${limit})`
+    );
+  }
+  // --------------------------------------------------------------------------
+  // BOOKING MANAGEMENT
+  // --------------------------------------------------------------------------
+  async cancelBooking(input) {
+    return this.client.call("scheduling.cancel_booking", input);
+  }
+  async rescheduleBooking(input) {
+    return 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({
+      service_id: serviceId,
+      date
+    });
+    return slots.find((slot) => slot.is_available) || null;
+  }
+  async hasAvailabilityOn(serviceId, date) {
+    const slots = await this.getAvailableSlots({
+      service_id: serviceId,
+      date
+    });
+    return slots.some((slot) => slot.is_available);
+  }
+};
+
+// src/lite.ts
+var LiteService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  // --------------------------------------------------------------------------
+  // BOOTSTRAP
+  // --------------------------------------------------------------------------
+  async getBootstrap() {
+    return this.client.query("lite.bootstrap");
+  }
+  // --------------------------------------------------------------------------
+  // TABLE MANAGEMENT
+  // --------------------------------------------------------------------------
+  async getTable(tableId) {
+    return this.client.query(`lite.table.${tableId}`);
+  }
+  async getTableByNumber(tableNumber, locationId) {
+    return 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
+    });
+  }
+  async callWaiter(tableId, reason) {
+    return this.client.call("lite.call_waiter", {
+      table_id: tableId,
+      reason
+    });
+  }
+  async requestBill(tableId) {
+    return this.client.call(
+      "lite.request_bill",
+      { table_id: tableId }
+    );
+  }
+  // --------------------------------------------------------------------------
+  // MENU (optimized for lite/QR experience)
+  // --------------------------------------------------------------------------
+  async getMenu() {
+    return this.client.query("lite.menu");
+  }
+  async getMenuByCategory(categoryId) {
+    return this.client.query(`lite.menu.category.${categoryId}`);
+  }
+};
+
+// src/client.ts
+var SESSION_TOKEN_HEADER = "x-session-token";
+var SESSION_STORAGE_KEY = "cimplify_session_token";
+function deriveUrls() {
+  const hostname = typeof window !== "undefined" ? window.location.hostname : "";
+  if (hostname === "localhost" || hostname === "127.0.0.1") {
+    const protocol = window.location.protocol;
+    return {
+      baseUrl: `${protocol}//${hostname}:8082`,
+      linkApiUrl: `${protocol}//${hostname}:8080`
+    };
+  }
+  return {
+    baseUrl: "https://storefronts.cimplify.io",
+    linkApiUrl: "https://api.cimplify.io"
+  };
+}
+var CimplifyClient = class {
+  constructor(config = {}) {
+    this.sessionToken = null;
+    this.publicKey = config.publicKey || "";
+    const urls = deriveUrls();
+    this.baseUrl = urls.baseUrl;
+    this.linkApiUrl = urls.linkApiUrl;
+    this.credentials = config.credentials || "include";
+    this.sessionToken = this.loadSessionToken();
+  }
+  getSessionToken() {
+    return this.sessionToken;
+  }
+  setSessionToken(token) {
+    this.sessionToken = token;
+    this.saveSessionToken(token);
+  }
+  clearSession() {
+    this.sessionToken = null;
+    this.saveSessionToken(null);
+  }
+  loadSessionToken() {
+    if (typeof window !== "undefined" && window.localStorage) {
+      return localStorage.getItem(SESSION_STORAGE_KEY);
+    }
+    return null;
+  }
+  saveSessionToken(token) {
+    if (typeof window !== "undefined" && window.localStorage) {
+      if (token) {
+        localStorage.setItem(SESSION_STORAGE_KEY, token);
+      } else {
+        localStorage.removeItem(SESSION_STORAGE_KEY);
+      }
+    }
+  }
+  getHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      "X-API-Key": this.publicKey
+    };
+    if (this.sessionToken) {
+      headers[SESSION_TOKEN_HEADER] = this.sessionToken;
+    }
+    return headers;
+  }
+  updateSessionFromResponse(response) {
+    const newToken = response.headers.get(SESSION_TOKEN_HEADER);
+    if (newToken && newToken !== this.sessionToken) {
+      this.sessionToken = newToken;
+      this.saveSessionToken(newToken);
+    }
+  }
+  async query(query2, variables) {
+    const body = { query: query2 };
+    if (variables) {
+      body.variables = variables;
+    }
+    const response = await fetch(`${this.baseUrl}/api/q`, {
+      method: "POST",
+      credentials: this.credentials,
+      headers: this.getHeaders(),
+      body: JSON.stringify(body)
+    });
+    this.updateSessionFromResponse(response);
+    return this.handleResponse(response);
+  }
+  async call(method, args) {
+    const body = {
+      method,
+      args: args !== void 0 ? [args] : []
+    };
+    const response = await fetch(`${this.baseUrl}/api/m`, {
+      method: "POST",
+      credentials: this.credentials,
+      headers: this.getHeaders(),
+      body: JSON.stringify(body)
+    });
+    this.updateSessionFromResponse(response);
+    return this.handleResponse(response);
+  }
+  async get(path) {
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      method: "GET",
+      credentials: this.credentials,
+      headers: this.getHeaders()
+    });
+    this.updateSessionFromResponse(response);
+    return this.handleRestResponse(response);
+  }
+  async post(path, body) {
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      credentials: this.credentials,
+      headers: this.getHeaders(),
+      body: body ? JSON.stringify(body) : void 0
+    });
+    this.updateSessionFromResponse(response);
+    return this.handleRestResponse(response);
+  }
+  async delete(path) {
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      method: "DELETE",
+      credentials: this.credentials,
+      headers: this.getHeaders()
+    });
+    this.updateSessionFromResponse(response);
+    return this.handleRestResponse(response);
+  }
+  async linkGet(path) {
+    const response = await fetch(`${this.linkApiUrl}${path}`, {
+      method: "GET",
+      credentials: this.credentials,
+      headers: this.getHeaders()
+    });
+    this.updateSessionFromResponse(response);
+    return this.handleRestResponse(response);
+  }
+  async linkPost(path, body) {
+    const response = await fetch(`${this.linkApiUrl}${path}`, {
+      method: "POST",
+      credentials: this.credentials,
+      headers: this.getHeaders(),
+      body: body ? JSON.stringify(body) : void 0
+    });
+    this.updateSessionFromResponse(response);
+    return this.handleRestResponse(response);
+  }
+  async linkDelete(path) {
+    const response = await fetch(`${this.linkApiUrl}${path}`, {
+      method: "DELETE",
+      credentials: this.credentials,
+      headers: this.getHeaders()
+    });
+    this.updateSessionFromResponse(response);
+    return this.handleRestResponse(response);
+  }
+  async handleRestResponse(response) {
+    const json = await response.json();
+    if (!response.ok) {
+      throw new CimplifyError(
+        json.error?.error_code || "API_ERROR",
+        json.error?.error_message || "An error occurred",
+        false
+      );
+    }
+    return json.data;
+  }
+  async handleResponse(response) {
+    const json = await response.json();
+    if (!json.success || json.error) {
+      throw new CimplifyError(
+        json.error?.code || "UNKNOWN_ERROR",
+        json.error?.message || "An unknown error occurred",
+        json.error?.retryable || false
+      );
+    }
+    return json.data;
+  }
+  get catalogue() {
+    if (!this._catalogue) {
+      this._catalogue = new CatalogueQueries(this);
+    }
+    return this._catalogue;
+  }
+  get cart() {
+    if (!this._cart) {
+      this._cart = new CartOperations(this);
+    }
+    return this._cart;
+  }
+  get checkout() {
+    if (!this._checkout) {
+      this._checkout = new CheckoutService(this);
+    }
+    return this._checkout;
+  }
+  get orders() {
+    if (!this._orders) {
+      this._orders = new OrderQueries(this);
+    }
+    return this._orders;
+  }
+  get link() {
+    if (!this._link) {
+      this._link = new LinkService(this);
+    }
+    return this._link;
+  }
+  get auth() {
+    if (!this._auth) {
+      this._auth = new AuthService(this);
+    }
+    return this._auth;
+  }
+  get business() {
+    if (!this._business) {
+      this._business = new BusinessService(this);
+    }
+    return this._business;
+  }
+  get inventory() {
+    if (!this._inventory) {
+      this._inventory = new InventoryService(this);
+    }
+    return this._inventory;
+  }
+  get scheduling() {
+    if (!this._scheduling) {
+      this._scheduling = new SchedulingService(this);
+    }
+    return this._scheduling;
+  }
+  get lite() {
+    if (!this._lite) {
+      this._lite = new LiteService(this);
+    }
+    return this._lite;
+  }
+};
+function createCimplifyClient(config) {
+  return new CimplifyClient(config);
+}
+
+// src/query/builder.ts
+var QueryBuilder = class {
+  constructor(entity) {
+    this.filters = [];
+    this.modifiers = [];
+    this.pathSegments = [];
+    this.entity = entity;
+  }
+  path(segment) {
+    this.pathSegments.push(segment);
+    return this;
+  }
+  where(field, op, value) {
+    const v = typeof value === "string" ? `'${value}'` : value;
+    if (op === "contains" || op === "startsWith") {
+      this.filters.push(`@.${field} ${op} ${v}`);
+    } else {
+      this.filters.push(`@.${field}${op}${v}`);
+    }
+    return this;
+  }
+  and(field, op, value) {
+    return this.where(field, op, value);
+  }
+  sort(field, order = "asc") {
+    this.modifiers.push(`sort(${field},${order})`);
+    return this;
+  }
+  limit(n) {
+    this.modifiers.push(`limit(${n})`);
+    return this;
+  }
+  offset(n) {
+    this.modifiers.push(`offset(${n})`);
+    return this;
+  }
+  count() {
+    this.modifiers.push("count");
+    return this;
+  }
+  enriched() {
+    this.modifiers.push("enriched");
+    return this;
+  }
+  build() {
+    let query2 = this.entity;
+    if (this.pathSegments.length > 0) {
+      query2 += "." + this.pathSegments.join(".");
+    }
+    if (this.filters.length > 0) {
+      query2 += `[?(${this.filters.join(" && ")})]`;
+    }
+    for (const mod of this.modifiers) {
+      query2 += `#${mod}`;
+    }
+    return query2;
+  }
+  toString() {
+    return this.build();
+  }
+};
+function query(entity) {
+  return new QueryBuilder(entity);
+}
+
+// src/utils/payment.ts
+var CURRENCY_SYMBOLS = {
+  GHS: "GH\u20B5",
+  USD: "$",
+  EUR: "\u20AC",
+  GBP: "\xA3",
+  NGN: "\u20A6",
+  KES: "KSh",
+  ZAR: "R",
+  XOF: "CFA",
+  XAF: "FCFA"
+};
+function formatMoney(amount, currency = "GHS") {
+  const symbol = CURRENCY_SYMBOLS[currency.toUpperCase()] || currency;
+  const numAmount = typeof amount === "string" ? parseFloat(amount) : amount;
+  return `${symbol}${numAmount.toFixed(2)}`;
+}
+function categorizePaymentError(error, errorCode) {
+  let message = "An unexpected error occurred during payment processing. Please try again or contact support.";
+  let recoverable = true;
+  let code = errorCode || "PAYMENT_ERROR";
+  const technical = error.stack;
+  const errorMessage = error.message?.toLowerCase() || "";
+  if (errorCode === "INSUFFICIENT_FUNDS" || errorMessage.includes("insufficient") || errorMessage.includes("funds")) {
+    code = "INSUFFICIENT_FUNDS";
+    message = "Your payment method has insufficient funds. Please try another payment method.";
+  } else if (errorCode === "CARD_DECLINED" || errorMessage.includes("declined")) {
+    code = "CARD_DECLINED";
+    message = "Your card was declined. Please try another card or payment method.";
+  } else if (errorMessage.includes("cancelled") || errorMessage.includes("canceled") || errorCode === "PAYMENT_CANCELLED") {
+    code = "PAYMENT_CANCELLED";
+    message = "Payment was cancelled. You can try again when ready.";
+  } else if (errorMessage.includes("network") || errorMessage.includes("connection") || errorCode === "NETWORK_ERROR") {
+    code = "NETWORK_ERROR";
+    message = "Network connection issue. Please check your internet connection and try again.";
+  } else if (errorMessage.includes("timeout") || errorCode === "TIMEOUT") {
+    code = "TIMEOUT";
+    message = "Payment processing timed out. Please try again.";
+  } else if (errorCode === "PAYMENT_ACTION_NOT_COMPLETED") {
+    code = "PAYMENT_ACTION_NOT_COMPLETED";
+    message = "Payment action was not completed. Please try again.";
+  } else if (errorCode === "AUTHORIZATION_FAILED") {
+    code = "AUTHORIZATION_FAILED";
+    message = "Authorization failed. Please check your code and try again.";
+  } else if (errorCode === "INVALID_OTP") {
+    code = "INVALID_OTP";
+    message = "Invalid verification code. Please check and try again.";
+  }
+  return { code, message, recoverable, technical };
+}
+function isQuickPaymentResponse(response) {
+  return response !== null && typeof response === "object" && "payment" in response && typeof response.payment === "object";
+}
+function isWebPaymentResponse(response) {
+  return response !== null && typeof response === "object" && "transaction" in response && typeof response.transaction === "object";
+}
+function normalizePaymentResponse(response) {
+  if (!response) {
+    return {
+      method: "unknown",
+      provider: "unknown",
+      requires_action: false,
+      metadata: {}
+    };
+  }
+  if (isQuickPaymentResponse(response)) {
+    return {
+      method: response.payment.type?.toLowerCase() || "unknown",
+      provider: response.payment.provider?.toLowerCase() || "unknown",
+      requires_action: !!response.payment.redirect_url || !!response.payment.access_code,
+      public_key: response.payment.public_key,
+      client_secret: response.payment.access_code,
+      access_code: response.payment.access_code,
+      redirect_url: response.payment.redirect_url,
+      transaction_id: response.payment.reference,
+      order_id: response.order_id,
+      reference: response.payment.reference,
+      instructions: response.payment.instructions,
+      metadata: response.payment.metadata
+    };
+  }
+  if (isWebPaymentResponse(response)) {
+    const authType = response.authorization_type?.toLowerCase();
+    const validAuthTypes = ["otp", "pin", "phone", "birthday", "address"];
+    const safeAuthType = authType && validAuthTypes.includes(authType) ? authType : void 0;
+    return {
+      provider: response.transaction.provider_type?.toLowerCase() || "unknown",
+      requires_action: response.requires_action || false,
+      public_key: response.public_key,
+      client_secret: response.client_secret,
+      redirect_url: response.authorization_url,
+      transaction_id: response.transaction.id,
+      order_id: response.transaction.order_id,
+      reference: response.transaction.provider_reference,
+      metadata: response.transaction.metadata,
+      method: response.transaction.payment_method?.toLowerCase() || "unknown",
+      instructions: response.display_text,
+      display_text: response.display_text,
+      requires_authorization: response.requires_authorization,
+      authorization_type: safeAuthType,
+      provider_payment_id: response.provider_payment_id || response.transaction.provider_reference
+    };
+  }
+  return {
+    method: "unknown",
+    provider: "unknown",
+    requires_action: false,
+    metadata: {}
+  };
+}
+function normalizeStatusResponse(response) {
+  if (!response || typeof response !== "object") {
+    return {
+      status: "pending",
+      paid: false,
+      message: "No status available"
+    };
+  }
+  const res = response;
+  const status = res.status?.toLowerCase() || "";
+  let standardStatus;
+  if (status === "success" || status === "completed" || res.paid === true) {
+    standardStatus = "success";
+  } else if (status === "failed" || status === "declined" || status === "cancelled") {
+    standardStatus = "failed";
+  } else if (status === "processing" || status === "pending_confirmation") {
+    standardStatus = "processing";
+  } else {
+    standardStatus = "pending";
+  }
+  return {
+    status: standardStatus,
+    paid: res.paid || standardStatus === "success",
+    amount: res.amount,
+    currency: res.currency,
+    reference: res.reference,
+    message: res.message || ""
+  };
+}
+var MOBILE_MONEY_PROVIDERS = {
+  mtn: { name: "MTN Mobile Money", prefix: ["024", "054", "055", "059"] },
+  vodafone: { name: "Vodafone Cash", prefix: ["020", "050"] },
+  airtel: { name: "AirtelTigo Money", prefix: ["027", "057", "026", "056"] }
+};
+function detectMobileMoneyProvider(phoneNumber) {
+  const cleaned = phoneNumber.replace(/\D/g, "");
+  const prefix = cleaned.slice(-9, -6);
+  for (const [provider, info] of Object.entries(MOBILE_MONEY_PROVIDERS)) {
+    if (info.prefix.some((p) => prefix.startsWith(p.slice(1)))) {
+      return provider;
+    }
+  }
+  return null;
+}
+
+exports.AUTHORIZATION_TYPE = AUTHORIZATION_TYPE;
+exports.AUTH_MUTATION = AUTH_MUTATION;
+exports.AuthService = AuthService;
+exports.BusinessService = BusinessService;
+exports.CHECKOUT_MODE = CHECKOUT_MODE;
+exports.CHECKOUT_MUTATION = CHECKOUT_MUTATION;
+exports.CHECKOUT_STEP = CHECKOUT_STEP;
+exports.CURRENCY_SYMBOLS = CURRENCY_SYMBOLS;
+exports.CartOperations = CartOperations;
+exports.CatalogueQueries = CatalogueQueries;
+exports.CheckoutOperations = CheckoutService;
+exports.CheckoutService = CheckoutService;
+exports.CimplifyClient = CimplifyClient;
+exports.CimplifyError = CimplifyError;
+exports.DEFAULT_COUNTRY = DEFAULT_COUNTRY;
+exports.DEFAULT_CURRENCY = DEFAULT_CURRENCY;
+exports.InventoryService = InventoryService;
+exports.LINK_MUTATION = LINK_MUTATION;
+exports.LINK_QUERY = LINK_QUERY;
+exports.LinkService = LinkService;
+exports.LiteService = LiteService;
+exports.MOBILE_MONEY_PROVIDER = MOBILE_MONEY_PROVIDER;
+exports.MOBILE_MONEY_PROVIDERS = MOBILE_MONEY_PROVIDERS;
+exports.ORDER_MUTATION = ORDER_MUTATION;
+exports.ORDER_TYPE = ORDER_TYPE;
+exports.OrderQueries = OrderQueries;
+exports.PAYMENT_METHOD = PAYMENT_METHOD;
+exports.PAYMENT_MUTATION = PAYMENT_MUTATION;
+exports.PAYMENT_STATE = PAYMENT_STATE;
+exports.PICKUP_TIME_TYPE = PICKUP_TIME_TYPE;
+exports.QueryBuilder = QueryBuilder;
+exports.SchedulingService = SchedulingService;
+exports.categorizePaymentError = categorizePaymentError;
+exports.createCimplifyClient = createCimplifyClient;
+exports.detectMobileMoneyProvider = detectMobileMoneyProvider;
+exports.formatMoney = formatMoney;
+exports.normalizePaymentResponse = normalizePaymentResponse;
+exports.normalizeStatusResponse = normalizeStatusResponse;
+exports.query = query;