3a-ecommerce-utils 1.0.0 → 1.0.1

package/dist/client.js

@@ -0,0 +1,2338 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client.ts
+var client_exports = {};
+__export(client_exports, {
+  ADD_ADDRESS_MUTATION: () => ADD_ADDRESS_MUTATION,
+  ADMIN_APP_URL: () => ADMIN_APP_URL,
+  API_ENDPOINTS: () => API_ENDPOINTS,
+  AUTH_COOKIE_NAMES: () => AUTH_COOKIE_NAMES,
+  CACHE_CONFIG: () => CACHE_CONFIG,
+  CANCEL_ORDER_MUTATION: () => CANCEL_ORDER_MUTATION,
+  COUPON_CONFIG: () => COUPON_CONFIG,
+  CREATE_CATEGORY_MUTATION: () => CREATE_CATEGORY_MUTATION,
+  CREATE_COUPON_MUTATION: () => CREATE_COUPON_MUTATION,
+  CREATE_ORDER_MUTATION: () => CREATE_ORDER_MUTATION,
+  CREATE_PRODUCT_MUTATION: () => CREATE_PRODUCT_MUTATION,
+  CREATE_REVIEW_MUTATION: () => CREATE_REVIEW_MUTATION,
+  DASHBOARD_STATS_QUERY: () => DASHBOARD_STATS_QUERY,
+  DATABASE_CONFIG: () => DATABASE_CONFIG,
+  DEFAULT_CORS_ORIGINS: () => DEFAULT_CORS_ORIGINS,
+  DELETE_ADDRESS_MUTATION: () => DELETE_ADDRESS_MUTATION,
+  DELETE_CATEGORY_MUTATION: () => DELETE_CATEGORY_MUTATION,
+  DELETE_COUPON_MUTATION: () => DELETE_COUPON_MUTATION,
+  DELETE_PRODUCT_MUTATION: () => DELETE_PRODUCT_MUTATION,
+  DELETE_REVIEW_MUTATION: () => DELETE_REVIEW_MUTATION,
+  DELETE_USER_MUTATION: () => DELETE_USER_MUTATION,
+  ENV_PRESETS: () => ENV_PRESETS,
+  ERROR_MESSAGES: () => ERROR_MESSAGES,
+  FORGOT_PASSWORD_MUTATION: () => FORGOT_PASSWORD_MUTATION,
+  GET_CATEGORIES_QUERY: () => GET_CATEGORIES_QUERY,
+  GET_CATEGORY_QUERY: () => GET_CATEGORY_QUERY,
+  GET_COUPONS_QUERY: () => GET_COUPONS_QUERY,
+  GET_COUPON_QUERY: () => GET_COUPON_QUERY,
+  GET_ME_QUERY: () => GET_ME_QUERY,
+  GET_MY_ADDRESSES_QUERY: () => GET_MY_ADDRESSES_QUERY,
+  GET_ORDERS_BY_CUSTOMER_QUERY: () => GET_ORDERS_BY_CUSTOMER_QUERY,
+  GET_ORDERS_QUERY: () => GET_ORDERS_QUERY,
+  GET_ORDER_QUERY: () => GET_ORDER_QUERY,
+  GET_PRODUCTS_BY_SELLER_QUERY: () => GET_PRODUCTS_BY_SELLER_QUERY,
+  GET_PRODUCTS_QUERY: () => GET_PRODUCTS_QUERY,
+  GET_PRODUCT_QUERY: () => GET_PRODUCT_QUERY,
+  GET_PRODUCT_REVIEWS_QUERY: () => GET_PRODUCT_REVIEWS_QUERY,
+  GET_USERS_QUERY: () => GET_USERS_QUERY,
+  GET_USER_BY_ID_QUERY: () => GET_USER_BY_ID_QUERY,
+  GET_USER_QUERY: () => GET_USER_QUERY,
+  GOOGLE_AUTH_MUTATION: () => GOOGLE_AUTH_MUTATION,
+  HTTP_STATUS: () => HTTP_STATUS,
+  JWT_CONFIG: () => JWT_CONFIG,
+  LOGIN_MUTATION: () => LOGIN_MUTATION,
+  LOGOUT_MUTATION: () => LOGOUT_MUTATION,
+  Logger: () => Logger,
+  MARK_REVIEW_HELPFUL_MUTATION: () => MARK_REVIEW_HELPFUL_MUTATION,
+  ORDER_CONFIG: () => ORDER_CONFIG,
+  PAGINATION: () => PAGINATION,
+  PORT_CONFIG: () => PORT_CONFIG,
+  PRODUCT_CONFIG: () => PRODUCT_CONFIG,
+  REGEX_PATTERNS: () => REGEX_PATTERNS,
+  REGISTER_MUTATION: () => REGISTER_MUTATION,
+  RESET_PASSWORD_MUTATION: () => RESET_PASSWORD_MUTATION,
+  SALES_ANALYTICS_QUERY: () => SALES_ANALYTICS_QUERY,
+  SEARCH_PRODUCTS_QUERY: () => SEARCH_PRODUCTS_QUERY,
+  SELLER_APP_URL: () => SELLER_APP_URL,
+  SEND_VERIFICATION_EMAIL_MUTATION: () => SEND_VERIFICATION_EMAIL_MUTATION,
+  SERVICE_URLS: () => SERVICE_URLS,
+  SET_DEFAULT_ADDRESS_MUTATION: () => SET_DEFAULT_ADDRESS_MUTATION,
+  SHELL_APP_URL: () => SHELL_APP_URL,
+  STOREFRONT_APP_URL: () => STOREFRONT_APP_URL,
+  SUCCESS_MESSAGES: () => SUCCESS_MESSAGES,
+  TIMEOUT_CONFIG: () => TIMEOUT_CONFIG,
+  TOGGLE_COUPON_STATUS_MUTATION: () => TOGGLE_COUPON_STATUS_MUTATION,
+  UPDATE_ADDRESS_MUTATION: () => UPDATE_ADDRESS_MUTATION,
+  UPDATE_CATEGORY_MUTATION: () => UPDATE_CATEGORY_MUTATION,
+  UPDATE_COUPON_MUTATION: () => UPDATE_COUPON_MUTATION,
+  UPDATE_ORDER_STATUS_MUTATION: () => UPDATE_ORDER_STATUS_MUTATION,
+  UPDATE_PAYMENT_STATUS_MUTATION: () => UPDATE_PAYMENT_STATUS_MUTATION,
+  UPDATE_PRODUCT_MUTATION: () => UPDATE_PRODUCT_MUTATION,
+  UPDATE_PROFILE_MUTATION: () => UPDATE_PROFILE_MUTATION,
+  UPDATE_USER_ROLE_MUTATION: () => UPDATE_USER_ROLE_MUTATION,
+  VALIDATE_COUPON_QUERY: () => VALIDATE_COUPON_QUERY,
+  VALIDATE_RESET_TOKEN_QUERY: () => VALIDATE_RESET_TOKEN_QUERY,
+  VERIFY_EMAIL_MUTATION: () => VERIFY_EMAIL_MUTATION,
+  addDays: () => addDays,
+  addHours: () => addHours,
+  areCookiesEnabled: () => areCookiesEnabled,
+  batchValidate: () => batchValidate,
+  calculateDiscount: () => calculateDiscount,
+  calculatePercentage: () => calculatePercentage,
+  calculateTax: () => calculateTax,
+  capitalize: () => capitalize,
+  capitalizeWords: () => capitalizeWords,
+  chunk: () => chunk,
+  clearAuth: () => clearAuth,
+  createApiResponse: () => createApiResponse,
+  debounce: () => debounce,
+  deepMerge: () => deepMerge,
+  delay: () => delay,
+  difference: () => difference,
+  flatten: () => flatten,
+  formatCurrency: () => formatCurrency,
+  formatDate: () => formatDate,
+  formatIndianCompact: () => formatIndianCompact,
+  formatNumber: () => formatNumber,
+  formatPrice: () => formatPrice,
+  formatPriceShort: () => formatPriceShort,
+  generateRandomCode: () => generateRandomCode,
+  getAccessToken: () => getAccessToken,
+  getCookie: () => getCookie,
+  getCurrentUser: () => getCurrentUser,
+  getDaysDifference: () => getDaysDifference,
+  getNestedValue: () => getNestedValue,
+  getRefreshToken: () => getRefreshToken,
+  getStoredAuth: () => getStoredAuth,
+  groupBy: () => groupBy,
+  intersection: () => intersection,
+  isArray: () => isArray,
+  isBoolean: () => isBoolean,
+  isDateInRange: () => isDateInRange,
+  isEmpty: () => isEmpty,
+  isFunction: () => isFunction,
+  isFutureDate: () => isFutureDate,
+  isNull: () => isNull,
+  isNullOrUndefined: () => isNullOrUndefined,
+  isNumber: () => isNumber,
+  isObject: () => isObject,
+  isPastDate: () => isPastDate,
+  isString: () => isString,
+  isTokenExpired: () => isTokenExpired,
+  isUndefined: () => isUndefined,
+  isValidCouponCode: () => isValidCouponCode,
+  isValidEmail: () => isValidEmail,
+  isValidObjectId: () => isValidObjectId,
+  isValidPassword: () => isValidPassword,
+  isValidPhone: () => isValidPhone,
+  isValidPostalCode: () => isValidPostalCode,
+  isValidSku: () => isValidSku,
+  isValidUrl: () => isValidUrl,
+  omit: () => omit,
+  pick: () => pick,
+  removeCookie: () => removeCookie,
+  removeDuplicates: () => removeDuplicates,
+  retry: () => retry,
+  roundDown: () => roundDown,
+  roundUp: () => roundUp,
+  setCookie: () => setCookie,
+  setNestedValue: () => setNestedValue,
+  setupAutoRefresh: () => setupAutoRefresh,
+  slugify: () => slugify,
+  sortBy: () => sortBy,
+  storeAuth: () => storeAuth,
+  throttle: () => throttle,
+  toTitleCase: () => toTitleCase,
+  truncate: () => truncate,
+  tryParse: () => tryParse,
+  unique: () => unique,
+  updateAccessToken: () => updateAccessToken,
+  validateCouponCode: () => validateCouponCode,
+  validateDate: () => validateDate,
+  validateDateRange: () => validateDateRange,
+  validateDiscountPercentage: () => validateDiscountPercentage,
+  validateEmail: () => validateEmail,
+  validateName: () => validateName,
+  validateObjectId: () => validateObjectId,
+  validatePagination: () => validatePagination,
+  validatePassword: () => validatePassword,
+  validatePhone: () => validatePhone,
+  validatePostalCode: () => validatePostalCode,
+  validatePrice: () => validatePrice,
+  validateQuantity: () => validateQuantity,
+  validateRating: () => validateRating,
+  validateSku: () => validateSku,
+  validateUrl: () => validateUrl,
+  validateUserRole: () => validateUserRole,
+  willTokenExpireSoon: () => willTokenExpireSoon,
+  withErrorHandling: () => withErrorHandling
+});
+module.exports = __toCommonJS(client_exports);
+
+// src/constants/index.ts
+var SHELL_APP_URL = "http://localhost:3000";
+var ADMIN_APP_URL = "http://localhost:3001";
+var SELLER_APP_URL = "http://localhost:3002";
+var STOREFRONT_APP_URL = "http://localhost:3003";
+var PORT_CONFIG = {
+  AUTH_SERVICE: 3011,
+  CATEGORY_SERVICE: 3012,
+  COUPON_SERVICE: 3013,
+  PRODUCT_SERVICE: 3014,
+  ORDER_SERVICE: 3015,
+  GRAPHQL_GATEWAY: 4e3,
+  STOREFRONT_APP: 3e3,
+  ADMIN_APP: 3001,
+  SELLER_APP: 3002,
+  SHELL_APP: 3003
+};
+var SERVICE_URLS = {
+  AUTH_SERVICE: `http://localhost:${PORT_CONFIG.AUTH_SERVICE}`,
+  CATEGORY_SERVICE: `http://localhost:${PORT_CONFIG.CATEGORY_SERVICE}`,
+  COUPON_SERVICE: `http://localhost:${PORT_CONFIG.COUPON_SERVICE}`,
+  PRODUCT_SERVICE: `http://localhost:${PORT_CONFIG.PRODUCT_SERVICE}`,
+  ORDER_SERVICE: `http://localhost:${PORT_CONFIG.ORDER_SERVICE}`,
+  GRAPHQL_GATEWAY: `http://localhost:${PORT_CONFIG.GRAPHQL_GATEWAY}/graphql`,
+  AUTH_API: `http://localhost:${PORT_CONFIG.AUTH_SERVICE}/api`,
+  CATEGORY_API: `http://localhost:${PORT_CONFIG.CATEGORY_SERVICE}/api`,
+  COUPON_API: `http://localhost:${PORT_CONFIG.COUPON_SERVICE}/api`,
+  PRODUCT_API: `http://localhost:${PORT_CONFIG.PRODUCT_SERVICE}/api`,
+  ORDER_API: `http://localhost:${PORT_CONFIG.ORDER_SERVICE}/api`
+};
+var DATABASE_CONFIG = {
+  MONGODB_URI: "mongodb+srv://admin:admin@cluster0.wei5wdz.mongodb.net/ecommerce?appName=Cluster0",
+  REDIS_URL: "redis://localhost:6379"
+};
+var DEFAULT_CORS_ORIGINS = [
+  "http://localhost:3000",
+  "http://localhost:3001",
+  "http://localhost:3002",
+  "http://localhost:3003"
+];
+var JWT_CONFIG = {
+  ACCESS_TOKEN_EXPIRY: "1h",
+  REFRESH_TOKEN_EXPIRY: "7d",
+  PASSWORD_MIN_LENGTH: 8,
+  PASSWORD_PATTERN: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/
+};
+var PAGINATION = {
+  DEFAULT_PAGE: 1,
+  DEFAULT_LIMIT: 10,
+  DEFAULT_PAGE_SIZE: 20,
+  MAX_PAGE_SIZE: 100,
+  MIN_PAGE_SIZE: 1,
+  DEFAULT_SORT_BY: "createdAt",
+  DEFAULT_SORT_ORDER: "DESC"
+};
+var PRODUCT_CONFIG = {
+  MIN_PRICE: 0,
+  MAX_PRICE: 999999.99,
+  MIN_STOCK: 0,
+  MAX_RATING: 5,
+  MIN_RATING: 0,
+  DEFAULT_RATING: 0,
+  MAX_IMAGE_SIZE: 5 * 1024 * 1024,
+  // 5MB
+  ALLOWED_IMAGE_TYPES: ["image/jpeg", "image/png", "image/webp"]
+};
+var ORDER_CONFIG = {
+  TAX_RATE: 0.1,
+  // 10% tax
+  SHIPPING_COST_STANDARD: 50,
+  SHIPPING_COST_EXPRESS: 150,
+  SHIPPING_COST_OVERNIGHT: 300,
+  MIN_ORDER_AMOUNT: 0,
+  MAX_ORDER_ITEMS: 1e3
+};
+var COUPON_CONFIG = {
+  CODE_LENGTH: 6,
+  CODE_UPPERCASE: true,
+  MAX_DISCOUNT_PERCENTAGE: 100,
+  MAX_DISCOUNT_FIXED: 999999.99,
+  MIN_PURCHASE_REQUIRED: 0
+};
+var API_ENDPOINTS = {
+  AUTH: {
+    LOGIN: "/api/auth/login",
+    REGISTER: "/api/auth/register",
+    LOGOUT: "/api/auth/logout",
+    PROFILE: "/api/auth/profile",
+    REFRESH: "/api/auth/refresh",
+    VERIFY: "/api/auth/verify"
+  },
+  PRODUCTS: {
+    LIST: "/api/products",
+    CREATE: "/api/products",
+    GET: "/api/products/:id",
+    UPDATE: "/api/products/:id",
+    DELETE: "/api/products/:id",
+    SEARCH: "/api/products/search"
+  },
+  ORDERS: {
+    LIST: "/api/orders",
+    CREATE: "/api/orders",
+    GET: "/api/orders/:id",
+    UPDATE: "/api/orders/:id",
+    CANCEL: "/api/orders/:id/cancel",
+    TRACK: "/api/orders/:id/track"
+  },
+  CATEGORIES: {
+    LIST: "/api/categories",
+    CREATE: "/api/categories",
+    GET: "/api/categories/:id",
+    UPDATE: "/api/categories/:id",
+    DELETE: "/api/categories/:id"
+  },
+  COUPONS: {
+    LIST: "/api/coupons",
+    CREATE: "/api/coupons",
+    GET: "/api/coupons/:id",
+    UPDATE: "/api/coupons/:id",
+    DELETE: "/api/coupons/:id",
+    VALIDATE: "/api/coupons/validate/:code"
+  }
+};
+var HTTP_STATUS = {
+  OK: 200,
+  CREATED: 201,
+  NO_CONTENT: 204,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  CONFLICT: 409,
+  UNPROCESSABLE_ENTITY: 422,
+  INTERNAL_SERVER_ERROR: 500,
+  SERVICE_UNAVAILABLE: 503
+};
+var ERROR_MESSAGES = {
+  // Auth errors
+  UNAUTHORIZED: "Unauthorized access",
+  FORBIDDEN: "Forbidden access",
+  NO_TOKEN: "No token provided. Access denied.",
+  INVALID_TOKEN: "Invalid or expired token",
+  INVALID_CREDENTIALS: "Invalid email or password",
+  USER_EXISTS: "User with this email already exists",
+  USER_NOT_FOUND: "User not found",
+  ACCOUNT_DEACTIVATED: "Account is deactivated. Please contact support.",
+  EMAIL_PASSWORD_MISMATCH: "Email and password does not match.",
+  // General errors
+  NOT_FOUND: "Resource not found",
+  VALIDATION_FAILED: "Validation failed",
+  INTERNAL_ERROR: "Internal server error",
+  SERVICE_UNAVAILABLE: "Service temporarily unavailable",
+  FAILED_TO_FETCH: "Failed to fetch data",
+  // Product errors
+  PRODUCT_NOT_FOUND: "Product not found",
+  INSUFFICIENT_STOCK: "Insufficient stock available",
+  FAILED_TO_GET_PRODUCTS: "Failed to get products",
+  FAILED_TO_CREATE_PRODUCT: "Failed to create product",
+  FAILED_TO_UPDATE_PRODUCT: "Failed to update product",
+  FAILED_TO_DELETE_PRODUCT: "Failed to delete product",
+  // Category errors
+  CATEGORY_NOT_FOUND: "Category not found",
+  FAILED_TO_GET_CATEGORIES: "Failed to get categories",
+  FAILED_TO_CREATE_CATEGORY: "Failed to create category",
+  FAILED_TO_UPDATE_CATEGORY: "Failed to update category",
+  FAILED_TO_DELETE_CATEGORY: "Failed to delete category",
+  // Order errors
+  ORDER_NOT_FOUND: "Order not found",
+  INVALID_ORDER_STATUS: "Invalid order status",
+  FAILED_TO_GET_ORDERS: "Failed to get orders",
+  FAILED_TO_CREATE_ORDER: "Failed to create order",
+  FAILED_TO_UPDATE_ORDER: "Failed to update order",
+  // Coupon errors
+  INVALID_COUPON: "Invalid or expired coupon",
+  COUPON_NOT_FOUND: "Coupon not found",
+  COUPON_EXPIRED: "Coupon has expired",
+  COUPON_LIMIT_REACHED: "Coupon usage limit reached",
+  FAILED_TO_GET_COUPONS: "Failed to get coupons",
+  FAILED_TO_CREATE_COUPON: "Failed to create coupon",
+  FAILED_TO_UPDATE_COUPON: "Failed to update coupon",
+  FAILED_TO_DELETE_COUPON: "Failed to delete coupon",
+  // Review errors
+  REVIEW_NOT_FOUND: "Review not found",
+  DUPLICATE_REVIEW: "You have already reviewed this product",
+  OWN_REVIEW_ONLY: "You can only delete your own reviews",
+  FAILED_TO_GET_REVIEWS: "Failed to get reviews",
+  FAILED_TO_CREATE_REVIEW: "Failed to create review",
+  FAILED_TO_DELETE_REVIEW: "Failed to delete review",
+  // Address errors
+  ADDRESS_NOT_FOUND: "Address not found",
+  FAILED_TO_GET_ADDRESSES: "Failed to get addresses"
+};
+var SUCCESS_MESSAGES = {
+  // General
+  CREATED: "Resource created successfully",
+  UPDATED: "Resource updated successfully",
+  DELETED: "Resource deleted successfully",
+  FETCHED: "Data fetched successfully",
+  // Auth
+  USER_REGISTERED: "User registered successfully",
+  LOGIN_SUCCESS: "Login successful",
+  LOGOUT_SUCCESS: "Logout successful",
+  PROFILE_UPDATED: "Profile updated successfully",
+  PASSWORD_CHANGED: "Password changed successfully",
+  // Product
+  PRODUCT_CREATED: "Product created successfully",
+  PRODUCT_UPDATED: "Product updated successfully",
+  PRODUCT_DELETED: "Product deleted successfully",
+  // Category
+  CATEGORY_CREATED: "Category created successfully",
+  CATEGORY_UPDATED: "Category updated successfully",
+  CATEGORY_DELETED: "Category deleted successfully",
+  // Order
+  ORDER_PLACED: "Order placed successfully",
+  ORDER_UPDATED: "Order updated successfully",
+  ORDER_CANCELLED: "Order cancelled successfully",
+  // Coupon
+  COUPON_CREATED: "Coupon created successfully",
+  COUPON_UPDATED: "Coupon updated successfully",
+  COUPON_DELETED: "Coupon deleted successfully",
+  COUPON_APPLIED: "Coupon applied successfully",
+  // Review
+  REVIEW_SUBMITTED: "Review submitted successfully",
+  REVIEW_DELETED: "Review deleted successfully",
+  // Payment
+  PAYMENT_SUCCESSFUL: "Payment processed successfully"
+};
+var CACHE_CONFIG = {
+  DASHBOARD_STATS_TTL: 3e4,
+  // 30 seconds
+  DASHBOARD_STATS_REFETCH: 6e4,
+  // 1 minute
+  PRODUCTS_TTL: 6e4,
+  // 1 minute
+  CATEGORIES_TTL: 12e4,
+  // 2 minutes
+  USER_PROFILE_TTL: 3e5,
+  // 5 minutes
+  ORDERS_TTL: 3e4
+  // 30 seconds
+};
+var TIMEOUT_CONFIG = {
+  API_REQUEST: 3e4,
+  // 30 seconds
+  DATABASE: 1e4,
+  // 10 seconds
+  GRAPHQL: 15e3
+  // 15 seconds
+};
+var REGEX_PATTERNS = {
+  EMAIL: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+  PHONE: /^[\d\-\s()]{10,}$/,
+  POSTAL_CODE: /^\d{5,6}$/,
+  COUPON_CODE: /^[A-Z0-9]{6,20}$/,
+  PRODUCT_SKU: /^[A-Z0-9\-]{3,20}$/,
+  URL: /^(https?:\/\/)?([\da-z.-]+)\.([a-z.]{2,6})([/\w.-]*)*\/?$/
+};
+var ENV_PRESETS = {
+  DEVELOPMENT: {
+    corsOrigins: DEFAULT_CORS_ORIGINS,
+    logLevel: "debug",
+    apiTimeout: TIMEOUT_CONFIG.API_REQUEST
+  },
+  PRODUCTION: {
+    corsOrigins: ["https://ecommerce.example.com", "https://admin.ecommerce.example.com"],
+    logLevel: "info",
+    apiTimeout: TIMEOUT_CONFIG.API_REQUEST
+  },
+  TESTING: {
+    corsOrigins: ["http://localhost:*"],
+    logLevel: "error",
+    apiTimeout: TIMEOUT_CONFIG.API_REQUEST
+  }
+};
+
+// src/cookies.ts
+var DEFAULT_OPTIONS = {
+  path: "/",
+  secure: process.env.NODE_ENV === "production",
+  sameSite: "Lax"
+};
+var setCookie = (name, value, options = {}) => {
+  if (typeof document === "undefined") return;
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  let cookieString = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+  if (opts.expires) {
+    const date = /* @__PURE__ */ new Date();
+    date.setTime(date.getTime() + opts.expires * 24 * 60 * 60 * 1e3);
+    cookieString += `; expires=${date.toUTCString()}`;
+  }
+  if (opts.path) {
+    cookieString += `; path=${opts.path}`;
+  }
+  if (opts.domain) {
+    cookieString += `; domain=${opts.domain}`;
+  }
+  if (opts.secure) {
+    cookieString += "; secure";
+  }
+  if (opts.sameSite) {
+    cookieString += `; samesite=${opts.sameSite}`;
+  }
+  document.cookie = cookieString;
+};
+var getCookie = (name) => {
+  if (typeof document === "undefined") return null;
+  const nameEQ = `${encodeURIComponent(name)}=`;
+  const cookies = document.cookie.split(";");
+  for (let cookie of cookies) {
+    cookie = cookie.trim();
+    if (cookie.indexOf(nameEQ) === 0) {
+      return decodeURIComponent(cookie.substring(nameEQ.length));
+    }
+  }
+  return null;
+};
+var removeCookie = (name, options = {}) => {
+  if (typeof document === "undefined") return;
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  setCookie(name, "", { ...opts, expires: -1 });
+};
+var areCookiesEnabled = () => {
+  if (typeof document === "undefined") return false;
+  try {
+    document.cookie = "cookietest=1";
+    const result = document.cookie.indexOf("cookietest=") !== -1;
+    document.cookie = "cookietest=1; expires=Thu, 01-Jan-1970 00:00:01 GMT";
+    return result;
+  } catch {
+    return false;
+  }
+};
+var AUTH_COOKIE_NAMES = {
+  ACCESS_TOKEN: "accessToken",
+  REFRESH_TOKEN: "refreshToken",
+  TOKEN_EXPIRY: "tokenExpiry",
+  USER: "user"
+};
+
+// src/auth.ts
+var ACCESS_TOKEN_EXPIRY = 1;
+var REFRESH_TOKEN_EXPIRY = 7;
+var storeAuth = (data) => {
+  setCookie(AUTH_COOKIE_NAMES.USER, JSON.stringify(data.user), {
+    expires: REFRESH_TOKEN_EXPIRY
+  });
+  setCookie(AUTH_COOKIE_NAMES.ACCESS_TOKEN, data.accessToken, {
+    expires: ACCESS_TOKEN_EXPIRY
+  });
+  if (data.refreshToken) {
+    setCookie(AUTH_COOKIE_NAMES.REFRESH_TOKEN, data.refreshToken, {
+      expires: REFRESH_TOKEN_EXPIRY
+    });
+  }
+  const expiresIn = data.expiresIn || 3600;
+  const expiryTime = (/* @__PURE__ */ new Date()).getTime() + expiresIn * 1e3;
+  setCookie(AUTH_COOKIE_NAMES.TOKEN_EXPIRY, expiryTime.toString(), {
+    expires: ACCESS_TOKEN_EXPIRY
+  });
+};
+var getStoredAuth = () => {
+  const userStr = getCookie(AUTH_COOKIE_NAMES.USER);
+  const token = getCookie(AUTH_COOKIE_NAMES.ACCESS_TOKEN);
+  const expiryStr = getCookie(AUTH_COOKIE_NAMES.TOKEN_EXPIRY);
+  if (!userStr || !token) {
+    return null;
+  }
+  try {
+    const user = JSON.parse(userStr);
+    const expiresIn = expiryStr ? parseInt(expiryStr) - (/* @__PURE__ */ new Date()).getTime() : 0;
+    return {
+      user,
+      token,
+      expiresIn: Math.max(0, expiresIn)
+    };
+  } catch {
+    return null;
+  }
+};
+var isTokenExpired = () => {
+  const tokenExpiry = getCookie(AUTH_COOKIE_NAMES.TOKEN_EXPIRY);
+  if (!tokenExpiry) {
+    return true;
+  }
+  const now = (/* @__PURE__ */ new Date()).getTime();
+  return now > parseInt(tokenExpiry);
+};
+var willTokenExpireSoon = () => {
+  const tokenExpiry = getCookie(AUTH_COOKIE_NAMES.TOKEN_EXPIRY);
+  if (!tokenExpiry) {
+    return true;
+  }
+  const now = (/* @__PURE__ */ new Date()).getTime();
+  const expiryTime = parseInt(tokenExpiry);
+  const timeUntilExpiry = expiryTime - now;
+  return timeUntilExpiry < 3e5;
+};
+var clearAuth = () => {
+  removeCookie(AUTH_COOKIE_NAMES.USER);
+  removeCookie(AUTH_COOKIE_NAMES.ACCESS_TOKEN);
+  removeCookie(AUTH_COOKIE_NAMES.REFRESH_TOKEN);
+  removeCookie(AUTH_COOKIE_NAMES.TOKEN_EXPIRY);
+};
+var validateUserRole = (requiredRole) => {
+  const userStr = getCookie(AUTH_COOKIE_NAMES.USER);
+  if (!userStr) {
+    return false;
+  }
+  try {
+    const user = JSON.parse(userStr);
+    return user.role === requiredRole;
+  } catch {
+    return false;
+  }
+};
+var getCurrentUser = () => {
+  const userStr = getCookie(AUTH_COOKIE_NAMES.USER);
+  if (!userStr) {
+    return null;
+  }
+  try {
+    return JSON.parse(userStr);
+  } catch {
+    return null;
+  }
+};
+var getAccessToken = () => {
+  return getCookie(AUTH_COOKIE_NAMES.ACCESS_TOKEN);
+};
+var getRefreshToken = () => {
+  return getCookie(AUTH_COOKIE_NAMES.REFRESH_TOKEN);
+};
+var updateAccessToken = (newToken, expiresIn) => {
+  setCookie(AUTH_COOKIE_NAMES.ACCESS_TOKEN, newToken, {
+    expires: ACCESS_TOKEN_EXPIRY
+  });
+  if (expiresIn) {
+    const expiryTime = (/* @__PURE__ */ new Date()).getTime() + expiresIn * 1e3;
+    setCookie(AUTH_COOKIE_NAMES.TOKEN_EXPIRY, expiryTime.toString(), {
+      expires: ACCESS_TOKEN_EXPIRY
+    });
+  }
+};
+var setupAutoRefresh = (refreshFn) => {
+  const checkAndRefresh = async () => {
+    if (willTokenExpireSoon() && !isTokenExpired()) {
+      try {
+        await refreshFn();
+      } catch (error) {
+        clearAuth();
+        window.location.href = SHELL_APP_URL;
+      }
+    }
+  };
+  const interval = setInterval(checkAndRefresh, 5 * 60 * 1e3);
+  return () => clearInterval(interval);
+};
+
+// src/helpers.ts
+var capitalize = (str) => {
+  if (!str) return "";
+  return str.charAt(0).toUpperCase() + str.slice(1);
+};
+var capitalizeWords = (str) => {
+  if (!str) return "";
+  return str.split(" ").map((word) => capitalize(word)).join(" ");
+};
+var toTitleCase = (str) => {
+  if (!str) return "";
+  return str.replace(/\w\S*/g, (txt) => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase());
+};
+var slugify = (str) => {
+  if (!str) return "";
+  return str.toLowerCase().trim().replace(/\s+/g, "-").replace(/[^\w-]/g, "");
+};
+var generateRandomCode = (length = 6) => {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return result;
+};
+var truncate = (str, length, suffix = "...") => {
+  if (!str || str.length <= length) return str;
+  return str.substring(0, length) + suffix;
+};
+var formatCurrency = (amount, currency = "USD") => {
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency
+  }).format(amount);
+};
+var formatNumber = (num, decimals = 2) => {
+  return parseFloat(num.toFixed(decimals));
+};
+var roundUp = (num, decimals = 2) => {
+  const factor = Math.pow(10, decimals);
+  return Math.ceil(num * factor) / factor;
+};
+var roundDown = (num, decimals = 2) => {
+  const factor = Math.pow(10, decimals);
+  return Math.floor(num * factor) / factor;
+};
+var calculatePercentage = (value, percentage) => {
+  return formatNumber(value * percentage / 100);
+};
+var calculateDiscount = (price, discountPercent) => {
+  return formatNumber(price - price * discountPercent / 100);
+};
+var calculateTax = (amount, taxRate) => {
+  return formatNumber(amount * taxRate);
+};
+var chunk = (arr, size) => {
+  const chunks = [];
+  for (let i = 0; i < arr.length; i += size) {
+    chunks.push(arr.slice(i, i + size));
+  }
+  return chunks;
+};
+var unique = (arr) => {
+  return Array.from(new Set(arr));
+};
+var removeDuplicates = (arr, key) => {
+  const seen = /* @__PURE__ */ new Set();
+  return arr.filter((item) => {
+    const value = item[key];
+    if (seen.has(value)) return false;
+    seen.add(value);
+    return true;
+  });
+};
+var groupBy = (arr, key) => {
+  return arr.reduce((result, item) => {
+    const groupKey = String(item[key]);
+    if (!result[groupKey]) {
+      result[groupKey] = [];
+    }
+    result[groupKey].push(item);
+    return result;
+  }, {});
+};
+var sortBy = (arr, key, order = "ASC") => {
+  const sorted = [...arr].sort((a, b) => {
+    const aVal = a[key];
+    const bVal = b[key];
+    if (aVal < bVal) return order === "ASC" ? -1 : 1;
+    if (aVal > bVal) return order === "ASC" ? 1 : -1;
+    return 0;
+  });
+  return sorted;
+};
+var flatten = (arr) => {
+  return arr.reduce((flat, item) => flat.concat(item), []);
+};
+var difference = (arr1, arr2) => {
+  return arr1.filter((item) => !arr2.includes(item));
+};
+var intersection = (arr1, arr2) => {
+  return arr1.filter((item) => arr2.includes(item));
+};
+var omit = (obj, keys) => {
+  const result = { ...obj };
+  keys.forEach((key) => delete result[key]);
+  return result;
+};
+var pick = (obj, keys) => {
+  const result = {};
+  keys.forEach((key) => {
+    if (key in obj) {
+      result[key] = obj[key];
+    }
+  });
+  return result;
+};
+var deepMerge = (target, source) => {
+  const result = { ...target };
+  for (const key in source) {
+    if (source.hasOwnProperty(key)) {
+      if (typeof source[key] === "object" && source[key] !== null && !Array.isArray(source[key])) {
+        result[key] = deepMerge(
+          target[key] || {},
+          source[key]
+        );
+      } else {
+        result[key] = source[key];
+      }
+    }
+  }
+  return result;
+};
+var isEmpty = (obj) => {
+  return Object.keys(obj).length === 0;
+};
+var getNestedValue = (obj, path) => {
+  const keys = path.split(".");
+  let result = obj;
+  for (const key of keys) {
+    if (result && typeof result === "object" && key in result) {
+      result = result[key];
+    } else {
+      return void 0;
+    }
+  }
+  return result;
+};
+var setNestedValue = (obj, path, value) => {
+  const keys = path.split(".");
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (!(key in current) || typeof current[key] !== "object") {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[keys[keys.length - 1]] = value;
+};
+var formatDate = (date, format = "MM/DD/YYYY") => {
+  const dateObj = new Date(date);
+  const year = dateObj.getFullYear();
+  const month = String(dateObj.getMonth() + 1).padStart(2, "0");
+  const day = String(dateObj.getDate()).padStart(2, "0");
+  const hours = String(dateObj.getHours()).padStart(2, "0");
+  const minutes = String(dateObj.getMinutes()).padStart(2, "0");
+  const seconds = String(dateObj.getSeconds()).padStart(2, "0");
+  return format.replace("YYYY", String(year)).replace("MM", month).replace("DD", day).replace("HH", hours).replace("mm", minutes).replace("ss", seconds);
+};
+var addDays = (date, days) => {
+  const result = new Date(date);
+  result.setDate(result.getDate() + days);
+  return result;
+};
+var addHours = (date, hours) => {
+  const result = new Date(date);
+  result.setHours(result.getHours() + hours);
+  return result;
+};
+var getDaysDifference = (date1, date2) => {
+  const diffTime = Math.abs(date2.getTime() - date1.getTime());
+  return Math.ceil(diffTime / (1e3 * 60 * 60 * 24));
+};
+var isDateInRange = (date, startDate, endDate) => {
+  return date >= startDate && date <= endDate;
+};
+var isFutureDate = (date) => {
+  return date > /* @__PURE__ */ new Date();
+};
+var isPastDate = (date) => {
+  return date < /* @__PURE__ */ new Date();
+};
+var delay = (ms) => {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+};
+var debounce = (fn, wait) => {
+  let timeoutId;
+  return (...args) => {
+    clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => fn(...args), wait);
+  };
+};
+var throttle = (fn, limit) => {
+  let inThrottle;
+  return (...args) => {
+    if (!inThrottle) {
+      fn(...args);
+      inThrottle = true;
+      setTimeout(() => inThrottle = false, limit);
+    }
+  };
+};
+var tryParse = (json, fallback) => {
+  try {
+    return JSON.parse(json);
+  } catch {
+    return fallback;
+  }
+};
+var withErrorHandling = async (fn) => {
+  try {
+    const data = await fn();
+    return { success: true, data };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return { success: false, error: message };
+  }
+};
+var createApiResponse = (success, data, message, statusCode = 200) => {
+  return {
+    success,
+    statusCode,
+    message: message || (success ? "Success" : "Error"),
+    data: data || (success ? {} : null)
+  };
+};
+var retry = async (fn, maxAttempts = 3, delayMs = 1e3) => {
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (attempt === maxAttempts) throw error;
+      await delay(delayMs * attempt);
+    }
+  }
+  throw new Error("Retry failed");
+};
+var isString = (val) => typeof val === "string";
+var isNumber = (val) => typeof val === "number";
+var isBoolean = (val) => typeof val === "boolean";
+var isArray = (val) => Array.isArray(val);
+var isObject = (val) => typeof val === "object" && val !== null && !Array.isArray(val);
+var isFunction = (val) => typeof val === "function";
+var isNull = (val) => val === null;
+var isUndefined = (val) => val === void 0;
+var isNullOrUndefined = (val) => val === null || val === void 0;
+var formatIndianCompact = (num = 0) => {
+  if (num >= 1e7) {
+    return (num / 1e7).toFixed(2).replace(/\.00$/, "") + "Cr";
+  }
+  if (num >= 1e5) {
+    return (num / 1e5).toFixed(2).replace(/\.00$/, "") + "L";
+  }
+  return "\u20B9" + num?.toLocaleString("en-IN", {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2
+  });
+};
+function formatPrice(price) {
+  return `\u20B9${price?.toFixed(2)}`;
+}
+function formatPriceShort(price) {
+  if (price >= 1e5) {
+    return `\u20B9${(price / 1e5).toFixed(1)}L`;
+  } else if (price >= 1e3) {
+    return `\u20B9${(price / 1e3).toFixed(1)}K`;
+  }
+  return `\u20B9${price.toFixed(0)}`;
+}
+
+// src/validation/client.ts
+var isValidEmail = (email) => {
+  return REGEX_PATTERNS.EMAIL.test(email);
+};
+var validateEmail = (email) => {
+  if (!email || email.trim() === "") {
+    return { valid: false, error: "Email is required" };
+  }
+  if (!isValidEmail(email)) {
+    return { valid: false, error: "Invalid email format" };
+  }
+  if (email.length > 255) {
+    return { valid: false, error: "Email is too long" };
+  }
+  return { valid: true };
+};
+var isValidPassword = (password) => {
+  return JWT_CONFIG.PASSWORD_PATTERN.test(password);
+};
+var validatePassword = (password) => {
+  if (!password) {
+    return { valid: false, error: "Password is required" };
+  }
+  if (password.length < JWT_CONFIG.PASSWORD_MIN_LENGTH) {
+    return {
+      valid: false,
+      error: `Password must be at least ${JWT_CONFIG.PASSWORD_MIN_LENGTH} characters`
+    };
+  }
+  if (!isValidPassword(password)) {
+    return {
+      valid: false,
+      error: "Password must contain uppercase, lowercase, number, and special character (@$!%*?&)"
+    };
+  }
+  return { valid: true };
+};
+var validateName = (name) => {
+  if (!name || name.trim() === "") {
+    return { valid: false, error: "Name is required" };
+  }
+  if (name.length < 2) {
+    return { valid: false, error: "Name must be at least 2 characters" };
+  }
+  if (name.length > 100) {
+    return { valid: false, error: "Name is too long" };
+  }
+  if (!/^[a-zA-Z\s'-]+$/.test(name)) {
+    return {
+      valid: false,
+      error: "Name can only contain letters, spaces, hyphens, and apostrophes"
+    };
+  }
+  return { valid: true };
+};
+var isValidPhone = (phone) => {
+  return REGEX_PATTERNS.PHONE.test(phone);
+};
+var validatePhone = (phone) => {
+  if (!phone) {
+    return { valid: false, error: "Phone number is required" };
+  }
+  if (!isValidPhone(phone)) {
+    return { valid: false, error: "Invalid phone number format" };
+  }
+  return { valid: true };
+};
+var isValidPostalCode = (postalCode) => {
+  return REGEX_PATTERNS.POSTAL_CODE.test(postalCode);
+};
+var validatePostalCode = (postalCode) => {
+  if (!postalCode) {
+    return { valid: false, error: "Postal code is required" };
+  }
+  if (!isValidPostalCode(postalCode)) {
+    return { valid: false, error: "Invalid postal code format" };
+  }
+  return { valid: true };
+};
+var isValidCouponCode = (code) => {
+  return REGEX_PATTERNS.COUPON_CODE.test(code);
+};
+var validateCouponCode = (code) => {
+  if (!code) {
+    return { valid: false, error: "Coupon code is required" };
+  }
+  if (!isValidCouponCode(code)) {
+    return { valid: false, error: "Invalid coupon code format (6-20 alphanumeric characters)" };
+  }
+  return { valid: true };
+};
+var validatePrice = (price) => {
+  const numPrice = parseFloat(price);
+  if (isNaN(numPrice)) {
+    return { valid: false, error: "Price must be a valid number" };
+  }
+  if (numPrice < 0) {
+    return { valid: false, error: "Price cannot be negative" };
+  }
+  if (numPrice > 999999.99) {
+    return { valid: false, error: "Price exceeds maximum allowed value" };
+  }
+  return { valid: true };
+};
+var validateQuantity = (qty) => {
+  const numQty = parseInt(qty, 10);
+  if (isNaN(numQty)) {
+    return { valid: false, error: "Quantity must be a valid number" };
+  }
+  if (numQty < 0) {
+    return { valid: false, error: "Quantity cannot be negative" };
+  }
+  if (!Number.isInteger(numQty)) {
+    return { valid: false, error: "Quantity must be a whole number" };
+  }
+  return { valid: true };
+};
+var validateRating = (rating) => {
+  const numRating = parseFloat(rating);
+  if (isNaN(numRating)) {
+    return { valid: false, error: "Rating must be a valid number" };
+  }
+  if (numRating < 0 || numRating > 5) {
+    return { valid: false, error: "Rating must be between 0 and 5" };
+  }
+  return { valid: true };
+};
+var validateDiscountPercentage = (discount) => {
+  const numDiscount = parseFloat(discount);
+  if (isNaN(numDiscount)) {
+    return { valid: false, error: "Discount must be a valid number" };
+  }
+  if (numDiscount < 0 || numDiscount > 100) {
+    return { valid: false, error: "Discount percentage must be between 0 and 100" };
+  }
+  return { valid: true };
+};
+var validatePagination = (page, limit) => {
+  const numPage = parseInt(page, 10) || 1;
+  const numLimit = parseInt(limit, 10) || 10;
+  if (numPage < 1) {
+    return { valid: false, error: "Page must be greater than 0" };
+  }
+  if (numLimit < 1) {
+    return { valid: false, error: "Limit must be greater than 0" };
+  }
+  if (numLimit > 100) {
+    return { valid: false, error: "Limit cannot exceed 100" };
+  }
+  return { valid: true, page: numPage, limit: numLimit };
+};
+var isValidObjectId = (id) => {
+  return /^[0-9a-fA-F]{24}$/.test(id);
+};
+var validateObjectId = (id, fieldName = "ID") => {
+  if (!id) {
+    return { valid: false, error: `${fieldName} is required` };
+  }
+  if (!isValidObjectId(id)) {
+    return { valid: false, error: `Invalid ${fieldName} format` };
+  }
+  return { valid: true };
+};
+var isValidUrl = (url) => {
+  return REGEX_PATTERNS.URL.test(url);
+};
+var validateUrl = (url) => {
+  if (!url) {
+    return { valid: false, error: "URL is required" };
+  }
+  if (!isValidUrl(url)) {
+    return { valid: false, error: "Invalid URL format" };
+  }
+  return { valid: true };
+};
+var isValidSku = (sku) => {
+  return REGEX_PATTERNS.PRODUCT_SKU.test(sku);
+};
+var validateSku = (sku) => {
+  if (!sku) {
+    return { valid: false, error: "SKU is required" };
+  }
+  if (!isValidSku(sku)) {
+    return {
+      valid: false,
+      error: "Invalid SKU format (3-20 alphanumeric characters with hyphens)"
+    };
+  }
+  return { valid: true };
+};
+var validateDate = (date) => {
+  const dateObj = new Date(date);
+  if (isNaN(dateObj.getTime())) {
+    return { valid: false, error: "Invalid date format" };
+  }
+  return { valid: true };
+};
+var validateDateRange = (startDate, endDate) => {
+  const start = new Date(startDate);
+  const end = new Date(endDate);
+  if (isNaN(start.getTime())) {
+    return { valid: false, error: "Invalid start date" };
+  }
+  if (isNaN(end.getTime())) {
+    return { valid: false, error: "Invalid end date" };
+  }
+  if (start > end) {
+    return { valid: false, error: "Start date must be before end date" };
+  }
+  return { valid: true };
+};
+var batchValidate = (validations) => {
+  const errors = [];
+  for (const validation of validations) {
+    if (!validation.valid && validation.error) {
+      errors.push(validation.error);
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+};
+
+// src/api/logger.client.ts
+var import_a_ecommerce_types = require("3a-ecommerce-types");
+var Logger = class {
+  static configure(options) {
+    if (options.maxLogs !== void 0) this.maxLogs = options.maxLogs;
+    if (options.enableConsole !== void 0) this.enableConsole = options.enableConsole;
+  }
+  static addLog(entry) {
+    this.logs.push(entry);
+    if (this.logs.length > this.maxLogs) this.logs.shift();
+  }
+  static format(entry) {
+    return `[${entry.timestamp}] [${entry.level}]${entry.context ? ` [${entry.context}]` : ""}: ${entry.message}`;
+  }
+  static debug(message, data, context) {
+    this.log(import_a_ecommerce_types.LogLevel.DEBUG, message, data, context);
+  }
+  static info(message, data, context) {
+    this.log(import_a_ecommerce_types.LogLevel.INFO, message, data, context);
+  }
+  static warn(message, data, context) {
+    this.log(import_a_ecommerce_types.LogLevel.WARN, message, data, context);
+  }
+  static error(message, error, context) {
+    this.log(import_a_ecommerce_types.LogLevel.ERROR, message, error, context);
+  }
+  static log(level, message, data, context) {
+    const entry = {
+      level,
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      data,
+      context
+    };
+    this.addLog(entry);
+    if (!this.enableConsole) return;
+    const formatted = this.format(entry);
+    switch (level) {
+      case import_a_ecommerce_types.LogLevel.ERROR:
+        console.error(formatted, data ?? "");
+        break;
+      case import_a_ecommerce_types.LogLevel.WARN:
+        console.warn(formatted, data ?? "");
+        break;
+      case import_a_ecommerce_types.LogLevel.INFO:
+        console.info(formatted, data ?? "");
+        break;
+      default:
+        console.debug(formatted, data ?? "");
+    }
+  }
+  static getLogs(level) {
+    return level ? this.logs.filter((l) => l.level === level) : [...this.logs];
+  }
+  static clearLogs() {
+    this.logs = [];
+  }
+};
+Logger.logs = [];
+Logger.maxLogs = 1e3;
+Logger.enableConsole = true;
+
+// src/api/user.queries.ts
+var GET_USERS_QUERY = `
+  query GetUsers($page: Int, $limit: Int, $search: String, $role: String) {
+    users(page: $page, limit: $limit, search: $search, role: $role) {
+      users {
+        id
+        name
+        email
+        role
+        isActive
+        emailVerified
+        createdAt
+        lastLogin
+      }
+      pagination {
+        page
+        limit
+        total
+        pages
+        sellerCount
+        adminCount
+        customerCount
+      }
+    }
+  }
+`;
+var GET_USER_QUERY = `
+  query GetUser($id: ID!) {
+    user(id: $id) {
+      id
+      name
+      email
+      role
+      isActive
+      emailVerified
+      createdAt
+      lastLogin
+    }
+  }
+`;
+var GET_USER_BY_ID_QUERY = `
+  query GetUserById($id: ID!) {
+    getUserById(id: $id) {
+      user {
+        id
+        name
+        email
+        role
+        isActive
+        emailVerified
+        createdAt
+        lastLogin
+      }
+      accessToken
+      refreshToken
+      tokenExpiry
+    }
+  }
+`;
+var GET_ME_QUERY = `
+  query GetMe {
+    me {
+      id
+      name
+      email
+      role
+      isActive
+      emailVerified
+      createdAt
+      lastLogin
+    }
+  }
+`;
+var LOGIN_MUTATION = `
+  mutation Login($input: LoginInput!) {
+    login(input: $input) {
+      user {
+        id
+        name
+        email
+        role
+        isActive
+        emailVerified
+        createdAt
+      }
+      accessToken
+      refreshToken
+    }
+  }
+`;
+var REGISTER_MUTATION = `
+  mutation Register($input: RegisterInput!) {
+    register(input: $input) {
+      user {
+        id
+        name
+        email
+        role
+        isActive
+        emailVerified
+        createdAt
+      }
+      accessToken
+      refreshToken
+    }
+  }
+`;
+var GOOGLE_AUTH_MUTATION = `
+  mutation GoogleAuth($input: GoogleAuthInput!) {
+    googleAuth(input: $input) {
+      user {
+        id
+        name
+        email
+        role
+        isActive
+        emailVerified
+        createdAt
+        profilePicture
+      }
+      accessToken
+      refreshToken
+    }
+  }
+`;
+var LOGOUT_MUTATION = `
+  mutation Logout {
+    logout
+  }
+`;
+var UPDATE_USER_ROLE_MUTATION = `
+  mutation UpdateUserRole($id: ID!, $role: String!) {
+    updateUserRole(id: $id, role: $role) {
+      id
+      name
+      email
+      role
+      isActive
+      emailVerified
+      createdAt
+      lastLogin
+    }
+  }
+`;
+var DELETE_USER_MUTATION = `
+  mutation DeleteUser($id: ID!) {
+    deleteUser(id: $id)
+  }
+`;
+var SEND_VERIFICATION_EMAIL_MUTATION = `
+  mutation SendVerificationEmail($source: String) {
+    sendVerificationEmail(source: $source) {
+      success
+      message
+    }
+  }
+`;
+var VERIFY_EMAIL_MUTATION = `
+  mutation VerifyEmail {
+    verifyEmail {
+      success
+      message
+      user {
+        id
+        name
+        email
+        role
+        isActive
+        emailVerified
+        createdAt
+      }
+    }
+  }
+`;
+var FORGOT_PASSWORD_MUTATION = `
+  mutation ForgotPassword($email: String!, $role: String!) {
+    forgotPassword(email: $email, role: $role) {
+      success
+      message
+      resetToken
+      resetUrl
+    }
+  }
+`;
+var RESET_PASSWORD_MUTATION = `
+  mutation ResetPassword($token: String!, $password: String!, $confirmPassword: String!) {
+    resetPassword(token: $token, password: $password, confirmPassword: $confirmPassword) {
+      success
+      message
+    }
+  }
+`;
+var VALIDATE_RESET_TOKEN_QUERY = `
+  query ValidateResetToken($token: String!) {
+    validateResetToken(token: $token) {
+      success
+      message
+      email
+    }
+  }
+`;
+var UPDATE_PROFILE_MUTATION = `
+  mutation UpdateProfile($input: UpdateProfileInput!) {
+    updateProfile(input: $input) {
+      success
+      message
+      user {
+        id
+        name
+        email
+        role
+        isActive
+        emailVerified
+        createdAt
+      }
+    }
+  }
+`;
+
+// src/api/product.queries.ts
+var GET_PRODUCTS_QUERY = `
+  query GetProducts($page: Int, $limit: Int, $search: String, $category: String, $minPrice: Float, $maxPrice: Float, $sortBy: String, $sortOrder: String, $featured: Boolean, $includeInactive: Boolean) {
+    products(page: $page, limit: $limit, search: $search, category: $category, minPrice: $minPrice, maxPrice: $maxPrice, sortBy: $sortBy, sortOrder: $sortOrder, featured: $featured, includeInactive: $includeInactive) {
+      products {
+        id
+        name
+        description
+        price
+        stock
+        category
+        sellerId
+        isActive
+        imageUrl
+        tags
+        rating
+        reviewCount
+        createdAt
+        updatedAt
+      }
+      pagination {
+        page
+        limit
+        total
+        pages
+      }
+    }
+  }
+`;
+var GET_PRODUCT_QUERY = `
+  query GetProduct($id: ID!) {
+    product(id: $id) {
+      id
+      name
+      description
+      price
+      stock
+      category
+      sellerId
+      seller {
+        id
+        name
+        email
+      }
+      isActive
+      imageUrl
+      tags
+      rating
+      reviewCount
+      createdAt
+      updatedAt
+    }
+  }
+`;
+var GET_PRODUCTS_BY_SELLER_QUERY = `
+  query GetProductsBySeller($sellerId: String!) {
+    productsBySeller(sellerId: $sellerId) {
+      id
+      name
+      description
+      price
+      stock
+      category
+      sellerId
+      isActive
+      imageUrl
+      tags
+      rating
+      reviewCount
+      createdAt
+      updatedAt
+    }
+  }
+`;
+var CREATE_PRODUCT_MUTATION = `
+  mutation CreateProduct($input: CreateProductInput!) {
+    createProduct(input: $input) {
+      id
+      name
+      description
+      price
+      stock
+      category
+      sellerId
+      isActive
+      imageUrl
+      tags
+      rating
+      reviewCount
+      createdAt
+      updatedAt
+    }
+  }
+`;
+var UPDATE_PRODUCT_MUTATION = `
+  mutation UpdateProduct($id: ID!, $input: UpdateProductInput!) {
+    updateProduct(id: $id, input: $input) {
+      id
+      name
+      description
+      price
+      stock
+      category
+      sellerId
+      isActive
+      imageUrl
+      tags
+      rating
+      reviewCount
+      createdAt
+      updatedAt
+    }
+  }
+`;
+var DELETE_PRODUCT_MUTATION = `
+  mutation DeleteProduct($id: ID!) {
+    deleteProduct(id: $id)
+  }
+`;
+var SEARCH_PRODUCTS_QUERY = `
+  query SearchProducts($search: String!, $limit: Int) {
+    searchProducts(search: $search, limit: $limit) {
+      id
+      name
+      description
+      price
+      stock
+      category
+      sellerId
+      isActive
+      imageUrl
+      tags
+      rating
+      reviewCount
+      createdAt
+      updatedAt
+    }
+  }
+`;
+
+// src/api/order.queries.ts
+var GET_ORDERS_QUERY = `
+  query GetOrders($page: Int, $limit: Int, $customerId: String) {
+    orders(page: $page, limit: $limit, customerId: $customerId) {
+      orders {
+        id
+        orderNumber
+        customerId
+        customerEmail
+        items {
+          productId
+          productName
+          quantity
+          price
+          subtotal
+        }
+        subtotal
+        tax
+        shipping
+        discount
+        total
+        orderStatus
+        paymentStatus
+        paymentMethod
+        shippingAddress {
+          street
+          city
+          state
+          zip
+          country
+        }
+        notes
+        createdAt
+        updatedAt
+      }
+      pagination {
+        page
+        limit
+        total
+        pages
+      }
+    }
+  }
+`;
+var GET_ORDER_QUERY = `
+  query GetOrder($id: ID!) {
+    order(id: $id) {
+      id
+      orderNumber
+      customerId
+      customerEmail
+      items {
+        productId
+        productName
+        quantity
+        price
+        subtotal
+      }
+      subtotal
+      tax
+      shipping
+      total
+      orderStatus
+      paymentStatus
+      paymentMethod
+      shippingAddress {
+        street
+        city
+        state
+        zip
+        country
+      }
+      notes
+      createdAt
+      updatedAt
+    }
+  }
+`;
+var GET_ORDERS_BY_CUSTOMER_QUERY = `
+  query GetOrdersByCustomer($customerId: String!) {
+    ordersByCustomer(customerId: $customerId) {
+      id
+      orderNumber
+      customerId
+      customerEmail
+      items {
+        productId
+        productName
+        quantity
+        price
+        subtotal
+      }
+      subtotal
+      tax
+      shipping
+      total
+      orderStatus
+      paymentStatus
+      paymentMethod
+      shippingAddress {
+        street
+        city
+        state
+        zip
+        country
+      }
+      notes
+      createdAt
+      updatedAt
+    }
+  }
+`;
+var CREATE_ORDER_MUTATION = `
+  mutation CreateOrder($input: CreateOrderInput!) {
+    createOrder(input: $input) {
+      order {
+        id
+        orderNumber
+        customerId
+        customerEmail
+        sellerId
+        items {
+          productId
+          productName
+          quantity
+          price
+          sellerId
+          subtotal
+        }
+        subtotal
+        tax
+        shipping
+        discount
+        couponCode
+        total
+        orderStatus
+        paymentStatus
+        paymentMethod
+        shippingAddress {
+          street
+          city
+          state
+          zip
+          country
+        }
+        notes
+        createdAt
+        updatedAt
+      }
+      orders {
+        id
+        orderNumber
+        customerId
+        customerEmail
+        sellerId
+        items {
+          productId
+          productName
+          quantity
+          price
+          sellerId
+          subtotal
+        }
+        subtotal
+        tax
+        shipping
+        discount
+        total
+        orderStatus
+        paymentStatus
+        createdAt
+      }
+      orderCount
+    }
+  }
+`;
+var UPDATE_ORDER_STATUS_MUTATION = `
+  mutation UpdateOrderStatus($id: ID!, $status: OrderStatus!) {
+    updateOrderStatus(id: $id, status: $status) {
+      id
+      orderNumber
+      orderStatus
+      updatedAt
+    }
+  }
+`;
+var UPDATE_PAYMENT_STATUS_MUTATION = `
+  mutation UpdatePaymentStatus($id: ID!, $status: PaymentStatus!) {
+    updatePaymentStatus(id: $id, status: $status) {
+      id
+      orderNumber
+      paymentStatus
+      updatedAt
+    }
+  }
+`;
+var CANCEL_ORDER_MUTATION = `
+  mutation CancelOrder($id: ID!) {
+    cancelOrder(id: $id) {
+      id
+      orderNumber
+      orderStatus
+      updatedAt
+    }
+  }
+`;
+
+// src/api/coupon.queries.ts
+var GET_COUPONS_QUERY = `
+  query GetCoupons($page: Int, $limit: Int, $isActive: Boolean, $search: String) {
+    coupons(page: $page, limit: $limit, isActive: $isActive, search: $search) {
+      coupons {
+        id
+        code
+        description
+        discountType
+        discount
+        minPurchase
+        maxDiscount
+        validFrom
+        validTo
+        usageLimit
+        usageCount
+        isActive
+        createdAt
+        updatedAt
+      }
+      pagination {
+        page
+        limit
+        total
+        pages
+      }
+    }
+  }
+`;
+var GET_COUPON_QUERY = `
+  query GetCoupon($id: ID!) {
+    coupon(id: $id) {
+      id
+      code
+      description
+      discountType
+      discount
+      minPurchase
+      maxDiscount
+      validFrom
+      validTo
+      usageLimit
+      usageCount
+      isActive
+      createdAt
+      updatedAt
+    }
+  }
+`;
+var VALIDATE_COUPON_QUERY = `
+  query ValidateCoupon($code: String!, $orderTotal: Float!) {
+    validateCoupon(code: $code, orderTotal: $orderTotal) {
+      valid
+      discount
+      discountValue
+      finalTotal
+      discountType
+      message
+      code
+    }
+  }
+`;
+var CREATE_COUPON_MUTATION = `
+  mutation CreateCoupon($input: CreateCouponInput!) {
+    createCoupon(input: $input) {
+      id
+      code
+      description
+      discountType
+      discount
+      minPurchase
+      maxDiscount
+      validFrom
+      validTo
+      usageLimit
+      usageCount
+      isActive
+      createdAt
+      updatedAt
+    }
+  }
+`;
+var UPDATE_COUPON_MUTATION = `
+  mutation UpdateCoupon($id: ID!, $input: UpdateCouponInput!) {
+    updateCoupon(id: $id, input: $input) {
+      id
+      code
+      description
+      discountType
+      discount
+      minPurchase
+      maxDiscount
+      validFrom
+      validTo
+      usageLimit
+      usageCount
+      isActive
+      createdAt
+      updatedAt
+    }
+  }
+`;
+var DELETE_COUPON_MUTATION = `
+  mutation DeleteCoupon($id: ID!) {
+    deleteCoupon(id: $id)
+  }
+`;
+var TOGGLE_COUPON_STATUS_MUTATION = `
+  mutation ToggleCouponStatus($id: ID!) {
+    toggleCouponStatus(id: $id) {
+      id
+      isActive
+    }
+  }
+`;
+
+// src/api/category.queries.ts
+var GET_CATEGORIES_QUERY = `
+  query GetCategories($filter: CategoryFilterInput) {
+    categories(filter: $filter) {
+      success
+      message
+      data {
+        id
+        name
+        description
+        icon
+        slug
+        isActive
+        productCount
+        createdAt
+        updatedAt
+      }
+      count
+    }
+  }
+`;
+var GET_CATEGORY_QUERY = `
+  query GetCategory($id: String!) {
+    category(id: $id) {
+      id
+      name
+      description
+      icon
+      slug
+      isActive
+      productCount
+      createdAt
+      updatedAt
+    }
+  }
+`;
+var CREATE_CATEGORY_MUTATION = `
+  mutation CreateCategory($input: CategoryInput!) {
+    createCategory(input: $input) {
+      success
+      message
+      data {
+        id
+        name
+        description
+        icon
+        slug
+        isActive
+        productCount
+        createdAt
+        updatedAt
+      }
+    }
+  }
+`;
+var UPDATE_CATEGORY_MUTATION = `
+  mutation UpdateCategory($id: ID!, $input: CategoryInput!) {
+    updateCategory(id: $id, input: $input) {
+      success
+      message
+      data {
+        id
+        name
+        description
+        icon
+        slug
+        isActive
+        productCount
+        createdAt
+        updatedAt
+      }
+    }
+  }
+`;
+var DELETE_CATEGORY_MUTATION = `
+  mutation DeleteCategory($id: ID!) {
+    deleteCategory(id: $id) {
+      success
+      message
+    }
+  }
+`;
+
+// src/api/dashboard.queries.ts
+var DASHBOARD_STATS_QUERY = `
+  query GetDashboardStats {
+    dashboardStats {
+      totalUsers
+      totalOrders
+      totalRevenue
+      pendingOrders
+    }
+  }
+`;
+var SALES_ANALYTICS_QUERY = `
+  query GetSalesAnalytics($period: String!) {
+    salesAnalytics(period: $period) {
+      daily {
+        date
+        sales
+        orders
+        revenue
+      }
+      weekly {
+        date
+        sales
+        orders
+        revenue
+      }
+      monthly {
+        date
+        sales
+        orders
+        revenue
+      }
+    }
+  }
+`;
+
+// src/api/review.queries.ts
+var GET_PRODUCT_REVIEWS_QUERY = `
+  query GetProductReviews($productId: ID!, $page: Int, $limit: Int) {
+    productReviews(productId: $productId, page: $page, limit: $limit) {
+      reviews {
+        id
+        productId
+        userId
+        userName
+        rating
+        comment
+        helpful
+        createdAt
+      }
+      pagination {
+        page
+        limit
+        total
+        pages
+      }
+    }
+  }
+`;
+var CREATE_REVIEW_MUTATION = `
+  mutation CreateReview($productId: ID!, $input: CreateReviewInput!) {
+    createReview(productId: $productId, input: $input) {
+      success
+      message
+      review {
+        id
+        productId
+        userId
+        userName
+        rating
+        comment
+        helpful
+        createdAt
+      }
+    }
+  }
+`;
+var MARK_REVIEW_HELPFUL_MUTATION = `
+  mutation MarkReviewHelpful($reviewId: ID!) {
+    markReviewHelpful(reviewId: $reviewId) {
+      id
+      helpful
+    }
+  }
+`;
+var DELETE_REVIEW_MUTATION = `
+  mutation DeleteReview($reviewId: ID!) {
+    deleteReview(reviewId: $reviewId)
+  }
+`;
+
+// src/api/address.queries.ts
+var GET_MY_ADDRESSES_QUERY = `
+  query GetMyAddresses {
+    myAddresses {
+      addresses {
+        id
+        userId
+        street
+        city
+        state
+        zip
+        country
+        isDefault
+        label
+        createdAt
+        updatedAt
+      }
+    }
+  }
+`;
+var ADD_ADDRESS_MUTATION = `
+  mutation AddAddress($input: AddAddressInput!) {
+    addAddress(input: $input) {
+      success
+      message
+      address {
+        id
+        userId
+        street
+        city
+        state
+        zip
+        country
+        isDefault
+        label
+        createdAt
+        updatedAt
+      }
+    }
+  }
+`;
+var UPDATE_ADDRESS_MUTATION = `
+  mutation UpdateAddress($id: ID!, $input: UpdateAddressInput!) {
+    updateAddress(id: $id, input: $input) {
+      success
+      message
+      address {
+        id
+        userId
+        street
+        city
+        state
+        zip
+        country
+        isDefault
+        label
+        createdAt
+        updatedAt
+      }
+    }
+  }
+`;
+var DELETE_ADDRESS_MUTATION = `
+  mutation DeleteAddress($id: ID!) {
+    deleteAddress(id: $id) {
+      success
+      message
+    }
+  }
+`;
+var SET_DEFAULT_ADDRESS_MUTATION = `
+  mutation SetDefaultAddress($id: ID!) {
+    setDefaultAddress(id: $id) {
+      success
+      message
+      address {
+        id
+        userId
+        street
+        city
+        state
+        zip
+        country
+        isDefault
+        label
+        createdAt
+        updatedAt
+      }
+    }
+  }
+`;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ADD_ADDRESS_MUTATION,
+  ADMIN_APP_URL,
+  API_ENDPOINTS,
+  AUTH_COOKIE_NAMES,
+  CACHE_CONFIG,
+  CANCEL_ORDER_MUTATION,
+  COUPON_CONFIG,
+  CREATE_CATEGORY_MUTATION,
+  CREATE_COUPON_MUTATION,
+  CREATE_ORDER_MUTATION,
+  CREATE_PRODUCT_MUTATION,
+  CREATE_REVIEW_MUTATION,
+  DASHBOARD_STATS_QUERY,
+  DATABASE_CONFIG,
+  DEFAULT_CORS_ORIGINS,
+  DELETE_ADDRESS_MUTATION,
+  DELETE_CATEGORY_MUTATION,
+  DELETE_COUPON_MUTATION,
+  DELETE_PRODUCT_MUTATION,
+  DELETE_REVIEW_MUTATION,
+  DELETE_USER_MUTATION,
+  ENV_PRESETS,
+  ERROR_MESSAGES,
+  FORGOT_PASSWORD_MUTATION,
+  GET_CATEGORIES_QUERY,
+  GET_CATEGORY_QUERY,
+  GET_COUPONS_QUERY,
+  GET_COUPON_QUERY,
+  GET_ME_QUERY,
+  GET_MY_ADDRESSES_QUERY,
+  GET_ORDERS_BY_CUSTOMER_QUERY,
+  GET_ORDERS_QUERY,
+  GET_ORDER_QUERY,
+  GET_PRODUCTS_BY_SELLER_QUERY,
+  GET_PRODUCTS_QUERY,
+  GET_PRODUCT_QUERY,
+  GET_PRODUCT_REVIEWS_QUERY,
+  GET_USERS_QUERY,
+  GET_USER_BY_ID_QUERY,
+  GET_USER_QUERY,
+  GOOGLE_AUTH_MUTATION,
+  HTTP_STATUS,
+  JWT_CONFIG,
+  LOGIN_MUTATION,
+  LOGOUT_MUTATION,
+  Logger,
+  MARK_REVIEW_HELPFUL_MUTATION,
+  ORDER_CONFIG,
+  PAGINATION,
+  PORT_CONFIG,
+  PRODUCT_CONFIG,
+  REGEX_PATTERNS,
+  REGISTER_MUTATION,
+  RESET_PASSWORD_MUTATION,
+  SALES_ANALYTICS_QUERY,
+  SEARCH_PRODUCTS_QUERY,
+  SELLER_APP_URL,
+  SEND_VERIFICATION_EMAIL_MUTATION,
+  SERVICE_URLS,
+  SET_DEFAULT_ADDRESS_MUTATION,
+  SHELL_APP_URL,
+  STOREFRONT_APP_URL,
+  SUCCESS_MESSAGES,
+  TIMEOUT_CONFIG,
+  TOGGLE_COUPON_STATUS_MUTATION,
+  UPDATE_ADDRESS_MUTATION,
+  UPDATE_CATEGORY_MUTATION,
+  UPDATE_COUPON_MUTATION,
+  UPDATE_ORDER_STATUS_MUTATION,
+  UPDATE_PAYMENT_STATUS_MUTATION,
+  UPDATE_PRODUCT_MUTATION,
+  UPDATE_PROFILE_MUTATION,
+  UPDATE_USER_ROLE_MUTATION,
+  VALIDATE_COUPON_QUERY,
+  VALIDATE_RESET_TOKEN_QUERY,
+  VERIFY_EMAIL_MUTATION,
+  addDays,
+  addHours,
+  areCookiesEnabled,
+  batchValidate,
+  calculateDiscount,
+  calculatePercentage,
+  calculateTax,
+  capitalize,
+  capitalizeWords,
+  chunk,
+  clearAuth,
+  createApiResponse,
+  debounce,
+  deepMerge,
+  delay,
+  difference,
+  flatten,
+  formatCurrency,
+  formatDate,
+  formatIndianCompact,
+  formatNumber,
+  formatPrice,
+  formatPriceShort,
+  generateRandomCode,
+  getAccessToken,
+  getCookie,
+  getCurrentUser,
+  getDaysDifference,
+  getNestedValue,
+  getRefreshToken,
+  getStoredAuth,
+  groupBy,
+  intersection,
+  isArray,
+  isBoolean,
+  isDateInRange,
+  isEmpty,
+  isFunction,
+  isFutureDate,
+  isNull,
+  isNullOrUndefined,
+  isNumber,
+  isObject,
+  isPastDate,
+  isString,
+  isTokenExpired,
+  isUndefined,
+  isValidCouponCode,
+  isValidEmail,
+  isValidObjectId,
+  isValidPassword,
+  isValidPhone,
+  isValidPostalCode,
+  isValidSku,
+  isValidUrl,
+  omit,
+  pick,
+  removeCookie,
+  removeDuplicates,
+  retry,
+  roundDown,
+  roundUp,
+  setCookie,
+  setNestedValue,
+  setupAutoRefresh,
+  slugify,
+  sortBy,
+  storeAuth,
+  throttle,
+  toTitleCase,
+  truncate,
+  tryParse,
+  unique,
+  updateAccessToken,
+  validateCouponCode,
+  validateDate,
+  validateDateRange,
+  validateDiscountPercentage,
+  validateEmail,
+  validateName,
+  validateObjectId,
+  validatePagination,
+  validatePassword,
+  validatePhone,
+  validatePostalCode,
+  validatePrice,
+  validateQuantity,
+  validateRating,
+  validateSku,
+  validateUrl,
+  validateUserRole,
+  willTokenExpireSoon,
+  withErrorHandling
+});