@atomic-solutions/woocommerce-api-client 0.2.0 → 0.3.1

package/dist/testing/index.js

@@ -0,0 +1,2103 @@
+'use strict';
+
+var axios = require('axios');
+var zod = require('zod');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+
+// src/client/createClient.ts
+
+// src/errors/classes/BaseError.ts
+var BaseError = class extends Error {
+  constructor(options) {
+    super(options.message);
+    this.options = options;
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.name = this.constructor.name;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    if (this.options.cause instanceof Error && this.options.cause.stack) {
+      this.stack = `${this.stack}
+Caused by: ${this.options.cause.stack}`;
+    }
+  }
+  /**
+   * Get reportable data for error tracking/logging
+   * Subclasses should override this to add their own reportable fields
+   */
+  getReportableData() {
+    const { code, operation, userMessage, retryable } = this.options;
+    return {
+      code,
+      operation,
+      userMessage,
+      retryable
+    };
+  }
+  /**
+   * Custom JSON serialization
+   * Makes the error properly serializable for logging/reporting
+   */
+  toJSON() {
+    return {
+      ...this.getReportableData(),
+      name: this.name,
+      message: this.message,
+      stack: this.stack
+    };
+  }
+};
+
+// src/errors/mapping/mapWooCommerceCode.ts
+var mapWooCommerceCode = (apiCode) => {
+  const directMatches = {
+    woocommerce_rest_cart_empty: "cart_empty",
+    woocommerce_rest_cart_coupon_error: "invalid_coupon",
+    woocommerce_rest_missing_nonce: "missing_nonce",
+    woocommerce_rest_invalid_nonce: "invalid_nonce",
+    rest_invalid_param: "invalid_params",
+    woocommerce_rest_product_invalid_id: "product_not_found",
+    woocommerce_rest_product_out_of_stock: "out_of_stock",
+    woocommerce_rest_product_not_enough_stock: "insufficient_stock",
+    woocommerce_rest_checkout_invalid_payment_method: "invalid_payment_method"
+  };
+  if (directMatches[apiCode]) {
+    return directMatches[apiCode];
+  }
+  if (apiCode.includes("nonce")) return "invalid_nonce";
+  if (apiCode.includes("coupon")) return "invalid_coupon";
+  if (apiCode.includes("stock")) return "insufficient_stock";
+  if (apiCode.includes("checkout")) return "checkout_error";
+  if (apiCode.includes("payment")) return "invalid_payment_method";
+  return "unknown_error";
+};
+
+// src/errors/mapping/constants.ts
+var WOOCOMMERCE_ERROR_METADATA = {
+  cart_empty: {
+    operation: "get_cart",
+    retryable: false,
+    userMessage: "Your cart is empty"
+  },
+  invalid_coupon: {
+    operation: "apply_coupon",
+    retryable: false,
+    userMessage: "Invalid coupon code"
+  },
+  missing_nonce: {
+    operation: "cart_request",
+    retryable: true
+    // Auto-retry with new nonce
+  },
+  invalid_nonce: {
+    operation: "cart_request",
+    retryable: true
+    // Auto-retry with new nonce
+  },
+  invalid_params: {
+    operation: "api_request",
+    retryable: false,
+    userMessage: "Invalid request parameters"
+  },
+  product_not_found: {
+    operation: "get_product",
+    retryable: false,
+    userMessage: "Product not found"
+  },
+  out_of_stock: {
+    operation: "add_to_cart",
+    retryable: false,
+    userMessage: "This product is out of stock"
+  },
+  insufficient_stock: {
+    operation: "add_to_cart",
+    retryable: false,
+    userMessage: "Not enough stock available"
+  },
+  invalid_payment_method: {
+    operation: "process_checkout",
+    retryable: false,
+    userMessage: "Invalid payment method"
+  },
+  checkout_error: {
+    operation: "process_checkout",
+    retryable: false
+  },
+  network_error: {
+    operation: "network_request",
+    retryable: true
+  },
+  unknown_error: {
+    operation: "unknown",
+    retryable: false
+  }
+};
+
+// src/errors/classes/WooCommerceApiError.ts
+var WooCommerceApiError = class extends BaseError {
+  constructor(options) {
+    const metadata = WOOCOMMERCE_ERROR_METADATA[options.code] ?? {
+      operation: "woocommerce_api_request",
+      retryable: false
+    };
+    const enrichedOptions = {
+      ...options,
+      operation: options.operation || metadata.operation,
+      userMessage: options.userMessage || metadata.userMessage,
+      retryable: options.retryable ?? metadata.retryable
+    };
+    super(enrichedOptions);
+  }
+  // Convenient getters for frequently accessed fields (no duplication)
+  get wooCode() {
+    return this.options.code;
+  }
+  get originalCode() {
+    return this.options.originalCode;
+  }
+  get statusCode() {
+    return this.options.statusCode;
+  }
+  get url() {
+    return this.options.url;
+  }
+  get method() {
+    return this.options.method;
+  }
+  get requestBody() {
+    return this.options.requestBody;
+  }
+  get responseBody() {
+    return this.options.responseBody;
+  }
+  get data() {
+    return this.options.data;
+  }
+  /**
+   * Get reportable data for error tracking/logging
+   * Includes HTTP context and WooCommerce-specific fields
+   */
+  getReportableData() {
+    return {
+      code: this.options.code,
+      operation: this.options.operation,
+      userMessage: this.options.userMessage,
+      retryable: this.options.retryable,
+      statusCode: this.options.statusCode,
+      url: this.options.url,
+      method: this.options.method,
+      wooCode: this.options.code,
+      originalCode: this.options.originalCode
+    };
+  }
+};
+
+// src/errors/classes/WooCommerceDataValidationError.ts
+var WooCommerceDataValidationError = class _WooCommerceDataValidationError extends BaseError {
+  constructor(options) {
+    const fieldErrors = options.zodError ? _WooCommerceDataValidationError.extractFieldErrorsFromZod(options.zodError) : void 0;
+    super({
+      code: "validation_error",
+      message: options.message,
+      operation: options.operation,
+      userMessage: options.userMessage || "Received unexpected data from WooCommerce",
+      retryable: false,
+      cause: options.cause,
+      url: options.url,
+      zodError: options.zodError,
+      value: options.value,
+      fieldErrors
+    });
+  }
+  // Convenient getters for validation-specific fields (no duplication)
+  get url() {
+    return this.options.url;
+  }
+  get zodError() {
+    return this.options.zodError;
+  }
+  get invalidValue() {
+    return this.options.value;
+  }
+  get fieldErrors() {
+    return this.options.fieldErrors;
+  }
+  /**
+   * Get reportable data for error tracking/logging
+   * Includes validation-specific fields
+   */
+  getReportableData() {
+    return {
+      code: this.options.code,
+      operation: this.options.operation,
+      userMessage: this.options.userMessage,
+      retryable: false,
+      fieldErrors: this.options.fieldErrors,
+      url: this.options.url
+    };
+  }
+  /**
+   * Extract field errors from Zod error
+   */
+  static extractFieldErrorsFromZod(zodError) {
+    if (!zodError?.errors) {
+      return void 0;
+    }
+    const fieldErrors = {};
+    for (const issue of zodError.errors) {
+      const path = issue.path.join(".");
+      if (!fieldErrors[path]) {
+        fieldErrors[path] = [];
+      }
+      fieldErrors[path].push(issue.message);
+    }
+    return fieldErrors;
+  }
+  /**
+   * Get all error messages as a flat array
+   */
+  getMessages() {
+    if (!this.fieldErrors) {
+      return [this.message];
+    }
+    const messages = [];
+    for (const fieldMessages of Object.values(this.fieldErrors)) {
+      messages.push(...fieldMessages);
+    }
+    return messages;
+  }
+  /**
+   * Check if a specific field has errors
+   */
+  hasFieldError(field) {
+    return this.fieldErrors ? field in this.fieldErrors : false;
+  }
+  /**
+   * Get error messages for a specific field
+   */
+  getFieldError(field) {
+    return this.fieldErrors?.[field];
+  }
+};
+
+// src/http/handleApiResponse.ts
+var handleApiResponse = (response, schema, options) => {
+  const validationMode = options?.validationMode ?? "strict";
+  if (validationMode === "warn") {
+    const result = schema.safeParse(response.data);
+    if (!result.success) {
+      const validationError = new WooCommerceDataValidationError({
+        message: `WooCommerce API response validation failed for ${response.config.url || "unknown endpoint"}`,
+        url: response.config.url,
+        zodError: result.error,
+        value: response.data,
+        userMessage: "Received unexpected data from WooCommerce"
+      });
+      options?.onValidationError?.(validationError);
+      options?.errorReporter?.(validationError);
+      console.warn("[woocommerce-utils] Validation warning:", validationError.message);
+      return response.data;
+    }
+    return result.data;
+  }
+  try {
+    return schema.parse(response.data);
+  } catch (error2) {
+    if (error2 && typeof error2 === "object" && "issues" in error2) {
+      const validationError = new WooCommerceDataValidationError({
+        message: `WooCommerce API response validation failed for ${response.config.url || "unknown endpoint"}`,
+        url: response.config.url,
+        zodError: error2,
+        value: response.data,
+        userMessage: "Received unexpected data from WooCommerce"
+      });
+      options?.onValidationError?.(validationError);
+      options?.errorReporter?.(validationError);
+      throw validationError;
+    }
+    throw error2;
+  }
+};
+
+// src/utils/calculatePagination.ts
+var calculatePagination = (input) => {
+  const { page, perPage, total, totalPages } = input;
+  const hasNextPage = page < totalPages;
+  const hasPrevPage = page > 1;
+  return {
+    page,
+    perPage,
+    total,
+    totalPages,
+    hasNextPage,
+    hasPrevPage,
+    nextPage: hasNextPage ? page + 1 : null,
+    prevPage: hasPrevPage ? page - 1 : null
+  };
+};
+
+// src/utils/getPaginationMeta.ts
+var getPaginationMeta = (headers) => {
+  if (!headers) {
+    return {
+      total: 0,
+      totalPages: 0
+    };
+  }
+  const wpTotal = headers["x-wp-total"];
+  const wpTotalPages = headers["x-wp-totalpages"];
+  if (!wpTotal || !wpTotalPages) {
+    return {
+      total: 0,
+      totalPages: 0
+    };
+  }
+  const total = parseInt(wpTotal, 10);
+  const totalPages = parseInt(wpTotalPages, 10);
+  return {
+    total,
+    totalPages
+  };
+};
+
+// src/http/handlePaginatedApiResponse.ts
+var handlePaginatedApiResponse = (response, schema, params = {}, options) => {
+  const validationMode = options?.validationMode ?? "strict";
+  let data;
+  if (validationMode === "warn") {
+    const result = schema.safeParse(response.data);
+    if (!result.success) {
+      const validationError = new WooCommerceDataValidationError({
+        message: `WooCommerce API response validation failed for ${response.config.url || "unknown endpoint"}`,
+        url: response.config.url,
+        zodError: result.error,
+        value: response.data,
+        userMessage: "Received unexpected data from WooCommerce"
+      });
+      options?.onValidationError?.(validationError);
+      options?.errorReporter?.(validationError);
+      console.warn("[woocommerce-utils] Validation warning:", validationError.message);
+      data = Array.isArray(response.data) ? response.data : [];
+    } else {
+      data = result.data;
+    }
+  } else {
+    try {
+      data = schema.parse(response.data);
+    } catch (error2) {
+      if (error2 && typeof error2 === "object" && "issues" in error2) {
+        const validationError = new WooCommerceDataValidationError({
+          message: `WooCommerce API response validation failed for ${response.config.url || "unknown endpoint"}`,
+          url: response.config.url,
+          zodError: error2,
+          value: response.data,
+          userMessage: "Received unexpected data from WooCommerce"
+        });
+        options?.onValidationError?.(validationError);
+        options?.errorReporter?.(validationError);
+        throw validationError;
+      }
+      throw error2;
+    }
+  }
+  const { total, totalPages } = getPaginationMeta(response.headers);
+  const page = params.page || 1;
+  const perPage = params.per_page || 10;
+  const pagination = calculatePagination({
+    page,
+    perPage,
+    total,
+    totalPages
+  });
+  return {
+    data,
+    pagination
+  };
+};
+
+// src/logging/logger.ts
+var DEBUG_PREFIX = "[woocommerce-utils]";
+var isDebugEnabled = () => {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env.DEBUG === "true" || process.env.DEBUG === "1";
+  }
+  return false;
+};
+var debug = (...args) => {
+  if (isDebugEnabled()) {
+    console.log(DEBUG_PREFIX, ...args);
+  }
+};
+var error = (...args) => {
+  console.error(DEBUG_PREFIX, ...args);
+};
+
+// src/http/interceptors/request.ts
+var requiresAuth = (url) => {
+  if (!url) return false;
+  const authEndpoints = [
+    "/jwt-auth/",
+    "/customers/me",
+    "/wp/v2/users/me",
+    // Store API non-cart endpoints: inject JWT when available so authenticated
+    // users can access their own resources (e.g. orders, personalised product data)
+    "/wc/store/v1/order"
+  ];
+  return authEndpoints.some((endpoint) => url.includes(endpoint));
+};
+var requiresCartAuth = (url) => {
+  if (!url) return false;
+  return /\/wc\/store\/(v\d+\/)?cart/.test(url) || /\/wc\/store\/(v\d+\/)?checkout/.test(url);
+};
+var setupRequestInterceptor = (axiosInstance, config, client) => {
+  axiosInstance.interceptors.request.use(
+    async (requestConfig) => {
+      const url = requestConfig.url;
+      if (config.jwtToken) {
+        const token = await config.jwtToken.get();
+        if (token && (requiresAuth(url) || requiresCartAuth(url))) {
+          requestConfig.headers.Authorization = `Bearer ${token}`;
+          if (config.debug) {
+            debug("Injected JWT token for", url);
+          }
+        }
+      }
+      if (requiresCartAuth(url)) {
+        const headers = await config.cartHeaders.get();
+        const isAuthenticated = !!await config.jwtToken?.get();
+        if (headers.nonce) {
+          requestConfig.headers.Nonce = headers.nonce;
+        }
+        if (headers.cartToken && !isAuthenticated) {
+          requestConfig.headers["Cart-Token"] = headers.cartToken;
+        }
+        requestConfig.headers["Cache-Control"] = "no-cache, no-store, must-revalidate";
+        requestConfig.headers.Pragma = "no-cache";
+        requestConfig.headers.Expires = "0";
+        if (config.debug) {
+          debug("Injected cart headers for", url, {
+            hasNonce: !!headers.nonce,
+            hasCartToken: !!headers.cartToken
+          });
+        }
+      }
+      if (config.debug) {
+        debug(
+          `${requestConfig.method?.toUpperCase()} ${requestConfig.url}`,
+          requestConfig.params || requestConfig.data
+        );
+      }
+      if (config.onRequest) {
+        return config.onRequest(requestConfig, client);
+      }
+      return requestConfig;
+    },
+    (error2) => {
+      return Promise.reject(error2);
+    }
+  );
+};
+
+// src/http/interceptors/response.ts
+var isCartResponse = (url) => {
+  if (!url) return false;
+  return /\/wc\/store\/(v\d+\/)?cart/.test(url) || /\/wc\/store\/(v\d+\/)?checkout/.test(url);
+};
+var setupResponseInterceptor = (axiosInstance, config, client) => {
+  axiosInstance.interceptors.response.use(
+    async (response) => {
+      if (isCartResponse(response.config.url)) {
+        const nonce = response.headers["nonce"] || response.headers["Nonce"];
+        const cartToken = response.headers["cart-token"] || response.headers["Cart-Token"];
+        if (nonce || cartToken) {
+          await config.cartHeaders.save({
+            nonce: nonce || void 0,
+            cartToken: cartToken || void 0
+          });
+          if (config.debug) {
+            debug(
+              "Saved updated cart headers:",
+              response.config.url,
+              "nonce:",
+              !!nonce,
+              "cartToken:",
+              !!cartToken
+            );
+          }
+        }
+      }
+      if (config.debug) {
+        debug("Response:", response.config.url, response.status);
+      }
+      if (config.onResponse) {
+        return config.onResponse(response, client);
+      }
+      return response;
+    },
+    (error2) => {
+      return Promise.reject(error2);
+    }
+  );
+};
+
+// src/utils/initializeCartSession.ts
+var initializeCartSession = async (client, cartHeaders) => {
+  try {
+    debug("session", "Initializing cart session");
+    const response = await client.get("/wc/store/v1/cart");
+    const nonce = response.headers["nonce"] || response.headers["Nonce"];
+    const cartToken = response.headers["cart-token"] || response.headers["Cart-Token"];
+    if (nonce || cartToken) {
+      await cartHeaders.save({
+        nonce: nonce || void 0,
+        cartToken: cartToken || void 0
+      });
+      debug("session", "Cart session initialized", {
+        hasNonce: !!nonce,
+        hasCartToken: !!cartToken
+      });
+    }
+  } catch (error2) {
+    debug("session", "Failed to initialize cart session", error2);
+    throw error2;
+  }
+};
+
+// src/http/interceptors/error.ts
+var setupErrorInterceptor = (axiosInstance, config, client) => {
+  axiosInstance.interceptors.response.use(
+    (response) => response,
+    async (axiosError) => {
+      const status = axiosError.response?.status || 500;
+      const errorData = axiosError.response?.data;
+      const apiCode = errorData?.code || "unknown_error";
+      const wpMessage = errorData?.message || axiosError.message || "Unknown error";
+      const errorCode = mapWooCommerceCode(apiCode);
+      const errorMetadata = WOOCOMMERCE_ERROR_METADATA[errorCode];
+      const wcError = new WooCommerceApiError({
+        message: wpMessage,
+        statusCode: status,
+        code: errorCode,
+        // Transformed app-level code
+        originalCode: apiCode,
+        // Original WooCommerce API code
+        retryable: errorMetadata.retryable,
+        userMessage: errorMetadata.userMessage,
+        operation: errorMetadata.operation,
+        url: axiosError.config?.url || "",
+        method: axiosError.config?.method?.toUpperCase() || "GET",
+        requestBody: axiosError.config?.data,
+        responseBody: errorData,
+        data: errorData?.data,
+        cause: axiosError
+      });
+      if (config.debug) {
+        debug("WooCommerce error:", apiCode, status, wpMessage);
+        error(wcError);
+      }
+      if ((status === 401 || status === 403) && config.onAuthError && axios.isAxiosError(axiosError) && !axiosError.config?._retry) {
+        if (config.debug) {
+          debug("Auth error detected, calling onAuthError handler");
+        }
+        try {
+          const shouldRetry = await config.onAuthError(wcError, client);
+          if (shouldRetry) {
+            if (config.debug) {
+              debug("Retrying request after auth error");
+            }
+            axiosError.config._retry = true;
+            return axiosInstance.request(axiosError.config);
+          }
+        } catch (authErrorHandlerError) {
+          if (config.debug) {
+            debug("onAuthError handler threw error", authErrorHandlerError);
+          }
+        }
+      }
+      if (config.onError) {
+        config.onError(wcError, client);
+      }
+      const isNonceError = errorCode === "missing_nonce" || errorCode === "invalid_nonce";
+      if (isNonceError && axios.isAxiosError(axiosError) && !axiosError.config?._retry) {
+        if (config.debug) {
+          debug("Nonce error detected, retrying with new session");
+        }
+        try {
+          await initializeCartSession(axiosInstance, config.cartHeaders);
+          axiosError.config._retry = true;
+          return axiosInstance.request(axiosError.config);
+        } catch (_retryError) {
+          config.errorReporter?.report(wcError);
+          return Promise.reject(wcError);
+        }
+      }
+      config.errorReporter?.report(wcError);
+      return Promise.reject(wcError);
+    }
+  );
+};
+var addressSchema = zod.z.object({
+  /** First name */
+  first_name: zod.z.string().min(1, "First name is required"),
+  /** Last name */
+  last_name: zod.z.string().min(1, "Last name is required"),
+  /** Company name (optional) */
+  company: zod.z.string(),
+  /** Address line 1 */
+  address_1: zod.z.string().min(1, "Address is required"),
+  /** Address line 2 (optional) */
+  address_2: zod.z.string(),
+  /** City */
+  city: zod.z.string().min(1, "City is required"),
+  /** State/Province/Region */
+  state: zod.z.string(),
+  /** Postal code */
+  postcode: zod.z.string().min(1, "Postal code is required"),
+  /** Country code (ISO 3166-1 alpha-2) */
+  country: zod.z.string(),
+  /** Phone number */
+  phone: zod.z.string().min(1, "Phone number is required")
+});
+var addressSchemaNonMandatory = zod.z.object({
+  /** First name */
+  first_name: zod.z.string(),
+  /** Last name */
+  last_name: zod.z.string(),
+  /** Company name (optional) */
+  company: zod.z.string(),
+  /** Address line 1 */
+  address_1: zod.z.string(),
+  /** Address line 2 (optional) */
+  address_2: zod.z.string(),
+  /** City */
+  city: zod.z.string(),
+  /** State/Province/Region */
+  state: zod.z.string(),
+  /** Postal code */
+  postcode: zod.z.string(),
+  /** Country code (ISO 3166-1 alpha-2) */
+  country: zod.z.string(),
+  /** Phone number */
+  phone: zod.z.string()
+});
+var billingAddressSchemaMandatory = addressSchema.extend({
+  /** Email address (required for billing) */
+  email: zod.z.string().email("Valid email is required")
+});
+var billingAddressSchemaNonMandatory = addressSchemaNonMandatory.extend({
+  /** Email address (can be null for guest carts) */
+  email: zod.z.string().nullable()
+});
+var moneySchema = zod.z.object({
+  /** Currency code (e.g., 'USD', 'EUR', 'BAM') */
+  currency_code: zod.z.string(),
+  /** Currency symbol (e.g., '$', '€', 'KM') */
+  currency_symbol: zod.z.string(),
+  /** Number of decimal places (e.g., 2 for dollars/euros) */
+  currency_minor_unit: zod.z.number(),
+  /** Decimal separator character (e.g., '.', ',') */
+  currency_decimal_separator: zod.z.string(),
+  /** Thousands separator character (e.g., ',', '.') */
+  currency_thousand_separator: zod.z.string(),
+  /** Currency symbol prefix (empty if symbol is suffix) */
+  currency_prefix: zod.z.string(),
+  /** Currency symbol suffix (empty if symbol is prefix) */
+  currency_suffix: zod.z.string()
+});
+var productImageSchema = zod.z.object({
+  /** Alternative text for the image */
+  alt: zod.z.string(),
+  /** Image unique identifier */
+  id: zod.z.number(),
+  /** Image filename */
+  name: zod.z.string(),
+  /** Available image sizes in JSON format */
+  sizes: zod.z.string(),
+  /** Full-size image URL */
+  src: zod.z.string().url(),
+  /** Srcset attribute for responsive images */
+  srcset: zod.z.string(),
+  /** Thumbnail image URL */
+  thumbnail: zod.z.string().url()
+});
+var cartItemImageSchema = zod.z.object({
+  /** Image ID */
+  id: zod.z.number(),
+  /** Full image URL */
+  src: zod.z.string(),
+  /** Thumbnail URL */
+  thumbnail: zod.z.string(),
+  /** Responsive image srcset */
+  srcset: zod.z.string(),
+  /** Responsive image sizes */
+  sizes: zod.z.string(),
+  /** Image name */
+  name: zod.z.string(),
+  /** Image alt text */
+  alt: zod.z.string()
+});
+var pricesSchema = zod.z.object({
+  /** Current active price (sale price if on sale, otherwise regular) */
+  price: zod.z.string(),
+  /** Regular price (before any discounts) */
+  regular_price: zod.z.string(),
+  /** Sale price (empty string if not on sale) */
+  sale_price: zod.z.string(),
+  /** Price range for variable products (null for simple products) */
+  price_range: zod.z.object({
+    min_amount: zod.z.string(),
+    max_amount: zod.z.string()
+  }).nullable(),
+  /** Raw price data without formatting */
+  raw_prices: zod.z.object({
+    /** Decimal precision */
+    precision: zod.z.number(),
+    /** Raw price value */
+    price: zod.z.string(),
+    /** Raw regular price value */
+    regular_price: zod.z.string(),
+    /** Raw sale price value */
+    sale_price: zod.z.string()
+  }).optional()
+}).merge(moneySchema);
+
+// ../schemas/src/woocommerce/store-api/cart-item.schema.ts
+var itemTotalsSchema = zod.z.object({
+  /** Subtotal before taxes */
+  line_subtotal: zod.z.string(),
+  /** Tax amount on subtotal */
+  line_subtotal_tax: zod.z.string(),
+  /** Total after discounts, before taxes */
+  line_total: zod.z.string(),
+  /** Tax amount on total */
+  line_total_tax: zod.z.string()
+}).merge(moneySchema);
+var cartItemSchema = zod.z.object({
+  /** Unique cart item key (use this for update/remove operations) */
+  key: zod.z.string(),
+  /** Product ID */
+  id: zod.z.number(),
+  /** Quantity of this item in cart */
+  quantity: zod.z.number(),
+  /** Quantity limits for this product */
+  quantity_limits: zod.z.object({
+    /** Minimum quantity allowed */
+    minimum: zod.z.number(),
+    /** Maximum quantity allowed */
+    maximum: zod.z.number(),
+    /** Quantity must be multiple of this value */
+    multiple_of: zod.z.number(),
+    /** Whether quantity can be changed */
+    editable: zod.z.boolean()
+  }),
+  /** Product name */
+  name: zod.z.string(),
+  /** Short product description */
+  short_description: zod.z.string(),
+  /** Full product description */
+  description: zod.z.string(),
+  /** Product SKU */
+  sku: zod.z.string(),
+  /** Remaining stock count if low (null if not low or unlimited) */
+  low_stock_remaining: zod.z.number().nullable(),
+  /** Whether backorders are allowed */
+  backorders_allowed: zod.z.boolean(),
+  /** Whether to show backorder badge */
+  show_backorder_badge: zod.z.boolean(),
+  /** Whether product can only be purchased individually */
+  sold_individually: zod.z.boolean(),
+  /** Product permalink URL */
+  permalink: zod.z.string(),
+  /** Product images */
+  images: zod.z.array(cartItemImageSchema),
+  /** Variation attributes (for variable products) */
+  variation: zod.z.array(
+    zod.z.object({
+      /** Attribute name (e.g., 'Color', 'Size') */
+      attribute: zod.z.string(),
+      /** Selected value (e.g., 'Red', 'Large') */
+      value: zod.z.string()
+    })
+  ),
+  /** Additional item data/metadata */
+  item_data: zod.z.array(
+    zod.z.object({
+      key: zod.z.string(),
+      value: zod.z.string()
+    })
+  ),
+  /** Product pricing information */
+  prices: pricesSchema,
+  /** Line item totals */
+  totals: itemTotalsSchema,
+  /** Catalog visibility setting */
+  catalog_visibility: zod.z.string(),
+  /** Product type */
+  type: zod.z.enum(["simple", "variable", "grouped", "external"]),
+  /** Extension data from plugins */
+  extensions: zod.z.record(zod.z.string(), zod.z.unknown())
+});
+var cartTotalsSchema = zod.z.object({
+  /** Total of all cart items (before discounts and taxes) */
+  total_items: zod.z.string(),
+  /** Tax on cart items */
+  total_items_tax: zod.z.string(),
+  /** Total fees */
+  total_fees: zod.z.string(),
+  /** Tax on fees */
+  total_fees_tax: zod.z.string(),
+  /** Total discount amount from coupons */
+  total_discount: zod.z.string(),
+  /** Tax on discounts */
+  total_discount_tax: zod.z.string(),
+  /** Shipping cost (null if not calculated yet) */
+  total_shipping: zod.z.string().nullable(),
+  /** Shipping tax (null if not calculated yet) */
+  total_shipping_tax: zod.z.string().nullable(),
+  /** Final total price (includes all taxes and fees) */
+  total_price: zod.z.string(),
+  /** Total tax amount */
+  total_tax: zod.z.string(),
+  /** Tax breakdown by rate */
+  tax_lines: zod.z.array(
+    zod.z.object({
+      /** Tax rate name */
+      name: zod.z.string(),
+      /** Tax amount */
+      price: zod.z.string(),
+      /** Tax rate percentage */
+      rate: zod.z.string()
+    })
+  )
+}).merge(moneySchema);
+var cartCouponSchema = zod.z.object({
+  /** Coupon code */
+  code: zod.z.string(),
+  /** Discount totals for this coupon */
+  totals: zod.z.object({
+    /** Total discount amount (before tax) */
+    total_discount: zod.z.string(),
+    /** Tax amount on discount */
+    total_discount_tax: zod.z.string()
+  }).merge(moneySchema)
+});
+var shippingRateSchema = zod.z.object({
+  /** Unique rate identifier (format: instance_id:method_id) */
+  rate_id: zod.z.string(),
+  /** Shipping method name */
+  name: zod.z.string(),
+  /** Shipping method description */
+  description: zod.z.string(),
+  /** Estimated delivery time */
+  delivery_time: zod.z.string(),
+  /** Shipping cost */
+  price: zod.z.string(),
+  /** Shipping instance ID */
+  instance_id: zod.z.number(),
+  /** Shipping method ID */
+  method_id: zod.z.string(),
+  /** Additional metadata for this shipping method */
+  meta_data: zod.z.array(
+    zod.z.object({
+      key: zod.z.string(),
+      value: zod.z.string()
+    })
+  ),
+  /** Whether this rate is currently selected */
+  selected: zod.z.boolean(),
+  /** Currency code for the price */
+  currency_code: zod.z.string(),
+  /** Currency symbol for the price */
+  currency_symbol: zod.z.string()
+});
+var shippingPackageSchema = zod.z.object({
+  /** Package identifier (0-indexed) */
+  package_id: zod.z.number(),
+  /** Package name/label */
+  name: zod.z.string(),
+  /** Shipping destination address */
+  destination: zod.z.object({
+    address_1: zod.z.string(),
+    address_2: zod.z.string().optional(),
+    city: zod.z.string(),
+    state: zod.z.string(),
+    postcode: zod.z.string(),
+    country: zod.z.string()
+  }),
+  /** Items included in this package */
+  items: zod.z.array(
+    zod.z.object({
+      /** Cart item key */
+      key: zod.z.string(),
+      /** Product name */
+      name: zod.z.string(),
+      /** Quantity in package */
+      quantity: zod.z.number()
+    })
+  ),
+  /** Available shipping rates for this package */
+  shipping_rates: zod.z.array(shippingRateSchema)
+});
+
+// ../schemas/src/woocommerce/store-api/cart.ts
+var cartSchema = zod.z.object({
+  items: zod.z.array(cartItemSchema),
+  items_count: zod.z.number(),
+  items_weight: zod.z.number(),
+  needs_payment: zod.z.boolean(),
+  needs_shipping: zod.z.boolean(),
+  payment_methods: zod.z.array(zod.z.enum(["cod", "monri"])),
+  payment_requirements: zod.z.array(zod.z.string()),
+  has_calculated_shipping: zod.z.boolean(),
+  shipping_address: addressSchemaNonMandatory,
+  billing_address: billingAddressSchemaNonMandatory,
+  shipping_rates: zod.z.array(shippingPackageSchema),
+  coupons: zod.z.array(cartCouponSchema),
+  totals: cartTotalsSchema,
+  errors: zod.z.array(
+    zod.z.object({
+      code: zod.z.string(),
+      message: zod.z.string()
+    })
+  ),
+  extensions: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+  cross_sells: zod.z.array(zod.z.unknown()),
+  fees: zod.z.array(zod.z.unknown())
+});
+zod.z.object({
+  id: zod.z.number(),
+  quantity: zod.z.number().int().positive(),
+  variation: zod.z.array(
+    zod.z.object({
+      attribute: zod.z.string(),
+      value: zod.z.string()
+    })
+  ).optional()
+});
+zod.z.object({
+  key: zod.z.string(),
+  quantity: zod.z.number().int().positive()
+});
+zod.z.object({
+  key: zod.z.string()
+});
+zod.z.object({
+  code: zod.z.string().min(1)
+});
+zod.z.object({
+  billing_address: billingAddressSchemaMandatory.partial(),
+  shipping_address: addressSchema.partial()
+}).partial();
+zod.z.object({
+  package_id: zod.z.union([zod.z.number(), zod.z.string()]).default(0),
+  rate_id: zod.z.string()
+});
+var orderItemImageSchema = zod.z.object({
+  /** Image ID */
+  id: zod.z.number(),
+  /** Full image URL */
+  src: zod.z.string().url(),
+  /** Thumbnail URL */
+  thumbnail: zod.z.string().url(),
+  /** Responsive image srcset */
+  srcset: zod.z.string(),
+  /** Responsive image sizes attribute */
+  sizes: zod.z.string(),
+  /** Image name */
+  name: zod.z.string(),
+  /** Image alt text */
+  alt: zod.z.string()
+});
+var orderItemPricesSchema = zod.z.object({
+  /** Formatted price (current price) */
+  price: zod.z.string(),
+  /** Formatted regular price */
+  regular_price: zod.z.string(),
+  /** Formatted sale price */
+  sale_price: zod.z.string(),
+  /** Price range (null for simple products) */
+  price_range: zod.z.null(),
+  /** Currency code (e.g., 'USD', 'EUR') */
+  currency_code: zod.z.string(),
+  /** Currency symbol (e.g., '$', '€') */
+  currency_symbol: zod.z.string(),
+  /** Number of decimal places for currency */
+  currency_minor_unit: zod.z.number(),
+  /** Decimal separator (e.g., '.', ',') */
+  currency_decimal_separator: zod.z.string(),
+  /** Thousand separator (e.g., ',', '.') */
+  currency_thousand_separator: zod.z.string(),
+  /** Currency prefix (e.g., '$') */
+  currency_prefix: zod.z.string(),
+  /** Currency suffix (e.g., 'USD') */
+  currency_suffix: zod.z.string(),
+  /** Raw price values for calculations */
+  raw_prices: zod.z.object({
+    /** Precision for price calculations */
+    precision: zod.z.number(),
+    /** Raw price (in minor units) */
+    price: zod.z.string(),
+    /** Raw regular price (in minor units) */
+    regular_price: zod.z.string(),
+    /** Raw sale price (in minor units) */
+    sale_price: zod.z.string()
+  })
+});
+var orderItemTotalsSchema = zod.z.object({
+  /** Line subtotal (before discounts) */
+  line_subtotal: zod.z.string(),
+  /** Line subtotal tax */
+  line_subtotal_tax: zod.z.string(),
+  /** Line total (after discounts) */
+  line_total: zod.z.string(),
+  /** Line total tax */
+  line_total_tax: zod.z.string(),
+  /** Currency code */
+  currency_code: zod.z.string(),
+  /** Currency symbol */
+  currency_symbol: zod.z.string(),
+  /** Currency minor unit */
+  currency_minor_unit: zod.z.number(),
+  /** Decimal separator */
+  currency_decimal_separator: zod.z.string(),
+  /** Thousand separator */
+  currency_thousand_separator: zod.z.string(),
+  /** Currency prefix */
+  currency_prefix: zod.z.string(),
+  /** Currency suffix */
+  currency_suffix: zod.z.string()
+});
+var quantityLimitsSchema = zod.z.object({
+  /** Minimum quantity allowed */
+  minimum: zod.z.number(),
+  /** Maximum quantity allowed */
+  maximum: zod.z.number(),
+  /** Quantity must be multiple of this value */
+  multiple_of: zod.z.number(),
+  /** Whether quantity is editable */
+  editable: zod.z.boolean()
+});
+var orderItemSchema = zod.z.object({
+  /** Unique cart/order item key */
+  key: zod.z.string(),
+  /** Product ID */
+  id: zod.z.number(),
+  /** Quantity ordered */
+  quantity: zod.z.number(),
+  /** Quantity limits for this product */
+  quantity_limits: quantityLimitsSchema,
+  /** Product name */
+  name: zod.z.string(),
+  /** Short description */
+  short_description: zod.z.string(),
+  /** Full description */
+  description: zod.z.string(),
+  /** Product SKU */
+  sku: zod.z.string(),
+  /** Low stock warning (null if not low) */
+  low_stock_remaining: zod.z.null(),
+  /** Whether backorders are allowed */
+  backorders_allowed: zod.z.boolean(),
+  /** Whether to show backorder badge */
+  show_backorder_badge: zod.z.boolean(),
+  /** Whether product can only be purchased individually */
+  sold_individually: zod.z.boolean(),
+  /** Product permalink URL */
+  permalink: zod.z.string().url(),
+  /** Product images */
+  images: zod.z.array(orderItemImageSchema),
+  /** Variation attributes (empty for simple products) */
+  variation: zod.z.array(zod.z.unknown()),
+  /** Custom item data/metadata */
+  item_data: zod.z.array(zod.z.unknown()),
+  /** Price information */
+  prices: orderItemPricesSchema,
+  /** Totals for this line item */
+  totals: orderItemTotalsSchema,
+  /** Catalog visibility setting */
+  catalog_visibility: zod.z.string()
+});
+var orderTotalsSchema = zod.z.object({
+  /** Subtotal (before discounts and fees) */
+  subtotal: zod.z.string(),
+  /** Total discount amount */
+  total_discount: zod.z.string(),
+  /** Total shipping cost */
+  total_shipping: zod.z.string(),
+  /** Total fees */
+  total_fees: zod.z.string(),
+  /** Total tax */
+  total_tax: zod.z.string(),
+  /** Total refund amount */
+  total_refund: zod.z.string(),
+  /** Final total price */
+  total_price: zod.z.string(),
+  /** Total items cost (subtotal after item-level discounts) */
+  total_items: zod.z.string(),
+  /** Tax on items */
+  total_items_tax: zod.z.string(),
+  /** Tax on fees */
+  total_fees_tax: zod.z.string(),
+  /** Tax on discounts */
+  total_discount_tax: zod.z.string(),
+  /** Tax on shipping */
+  total_shipping_tax: zod.z.string(),
+  /** Tax line items breakdown */
+  tax_lines: zod.z.array(zod.z.unknown()),
+  /** Currency code (e.g., 'USD', 'EUR', 'BAM') */
+  currency_code: zod.z.string(),
+  /** Currency symbol (e.g., '$', '€', 'KM') */
+  currency_symbol: zod.z.string(),
+  /** Number of decimal places for currency */
+  currency_minor_unit: zod.z.number(),
+  /** Decimal separator (e.g., '.', ',') */
+  currency_decimal_separator: zod.z.string(),
+  /** Thousand separator (e.g., ',', '.') */
+  currency_thousand_separator: zod.z.string(),
+  /** Currency prefix (e.g., '$') */
+  currency_prefix: zod.z.string(),
+  /** Currency suffix (e.g., 'USD') */
+  currency_suffix: zod.z.string()
+});
+
+// ../schemas/src/woocommerce/store-api/order.schema.ts
+var orderStatusEnum = zod.z.enum([
+  "pending",
+  // Order received, awaiting payment
+  "processing",
+  // Payment received, order is being processed
+  "on-hold",
+  // Order on hold, awaiting confirmation
+  "completed",
+  // Order fulfilled and complete
+  "cancelled",
+  // Order cancelled by customer or admin
+  "refunded",
+  // Order refunded
+  "failed"
+  // Payment failed or order declined
+]);
+var storeApiOrderSchema = zod.z.object({
+  /** Order ID */
+  id: zod.z.number(),
+  /** Order status */
+  status: orderStatusEnum,
+  /** Order line items (products purchased) */
+  items: zod.z.array(orderItemSchema),
+  /** Applied coupons */
+  coupons: zod.z.array(zod.z.unknown()),
+  /** Order fees */
+  fees: zod.z.array(zod.z.unknown()),
+  /** Order totals breakdown */
+  totals: orderTotalsSchema,
+  /** Shipping address */
+  shipping_address: addressSchema,
+  /** Billing address (includes email) */
+  billing_address: billingAddressSchemaMandatory,
+  /** Whether order still needs payment */
+  needs_payment: zod.z.boolean(),
+  /** Whether order needs shipping */
+  needs_shipping: zod.z.boolean(),
+  /** Payment method requirements */
+  payment_requirements: zod.z.array(zod.z.string()),
+  /** Order errors (if any) */
+  errors: zod.z.array(zod.z.unknown()),
+  /** Payment method (optional - returned from checkout) */
+  payment_method: zod.z.string().optional(),
+  /** Payment method title (optional - returned from checkout) */
+  payment_method_title: zod.z.string().optional()
+});
+var checkoutSchema = zod.z.object({
+  order_id: zod.z.number(),
+  status: zod.z.string(),
+  order_key: zod.z.string(),
+  customer_note: zod.z.string(),
+  customer_id: zod.z.number(),
+  billing_address: billingAddressSchemaNonMandatory,
+  shipping_address: addressSchemaNonMandatory,
+  payment_method: zod.z.string(),
+  payment_result: zod.z.object({
+    payment_status: zod.z.string(),
+    payment_details: zod.z.array(zod.z.unknown()),
+    redirect_url: zod.z.string()
+  })
+});
+zod.z.object({
+  payment_method: zod.z.string(),
+  payment_data: zod.z.array(
+    zod.z.object({
+      key: zod.z.string(),
+      value: zod.z.union([zod.z.string(), zod.z.boolean()])
+    })
+  ).optional(),
+  billing_address: billingAddressSchemaMandatory.optional(),
+  shipping_address: addressSchema.optional(),
+  customer_note: zod.z.string().optional(),
+  create_account: zod.z.boolean().optional(),
+  extensions: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+});
+var addToCartSchema = zod.z.object({
+  /** Description for add to cart action */
+  description: zod.z.string(),
+  /** Maximum quantity that can be added */
+  maximum: zod.z.number(),
+  /** Minimum quantity that can be added */
+  minimum: zod.z.number(),
+  /** Quantity must be a multiple of this number */
+  multiple_of: zod.z.number(),
+  /** Text for add to cart button */
+  text: zod.z.string(),
+  /** URL for add to cart action */
+  url: zod.z.string()
+});
+var embeddedCategorySchema = zod.z.object({
+  /** Category unique identifier */
+  id: zod.z.number(),
+  /** Category display name */
+  name: zod.z.string(),
+  /** URL-friendly category identifier */
+  slug: zod.z.string(),
+  /** Link to category page */
+  link: zod.z.string(),
+  /** Parent category ID (0 for root categories) - optional in embedded */
+  parent: zod.z.number().optional(),
+  /** Category description - optional in embedded */
+  description: zod.z.string().optional(),
+  /** Display type - optional in embedded */
+  display: zod.z.string().optional(),
+  /** Category image - optional in embedded */
+  image: productImageSchema.nullable().optional(),
+  /** Menu order for sorting - optional in embedded */
+  menu_order: zod.z.number().optional(),
+  /** Number of products in this category - optional in embedded */
+  count: zod.z.number().optional()
+});
+var productCategorySchema = zod.z.object({
+  /** Category unique identifier */
+  id: zod.z.number(),
+  /** Category display name */
+  name: zod.z.string(),
+  /** URL-friendly category identifier */
+  slug: zod.z.string(),
+  /** Parent category ID (0 for root categories) */
+  parent: zod.z.number(),
+  /** Category description */
+  description: zod.z.string(),
+  /** Category image */
+  image: productImageSchema.nullable(),
+  /** Menu order for sorting */
+  menu_order: zod.z.number().optional(),
+  /** Number of products in this category */
+  count: zod.z.number()
+});
+
+// ../schemas/src/woocommerce/store-api/products.ts
+var productSchema = zod.z.object({
+  id: zod.z.number(),
+  name: zod.z.string(),
+  slug: zod.z.string(),
+  type: zod.z.string(),
+  variation: zod.z.string(),
+  permalink: zod.z.string().url(),
+  sku: zod.z.string(),
+  short_description: zod.z.string(),
+  description: zod.z.string(),
+  is_purchasable: zod.z.boolean(),
+  is_in_stock: zod.z.boolean(),
+  is_on_backorder: zod.z.boolean(),
+  low_stock_remaining: zod.z.number().nullable(),
+  sold_individually: zod.z.boolean(),
+  add_to_cart: addToCartSchema,
+  has_options: zod.z.boolean(),
+  on_sale: zod.z.boolean(),
+  parent: zod.z.number(),
+  attributes: zod.z.array(zod.z.unknown()),
+  categories: zod.z.array(embeddedCategorySchema),
+  tags: zod.z.array(zod.z.unknown()),
+  images: zod.z.array(productImageSchema),
+  variations: zod.z.array(zod.z.unknown()),
+  price_html: zod.z.string(),
+  prices: pricesSchema,
+  average_rating: zod.z.string(),
+  review_count: zod.z.number(),
+  extensions: zod.z.record(zod.z.string(), zod.z.unknown())
+});
+zod.z.object({
+  /** Attribution source type (e.g., 'mobile_app', 'organic', 'referral') */
+  source_type: zod.z.string(),
+  /** UTM source identifier (e.g., 'moja-apoteka-app', 'google') */
+  utm_source: zod.z.string(),
+  /** Device type (e.g., 'mobile', 'desktop', 'tablet') */
+  device_type: zod.z.string()
+});
+var ORDER_ATTRIBUTION_NAMESPACE = "woocommerce/order-attribution";
+
+// src/api/cart.ts
+var createCartAPI = (client, endpoints, options) => ({
+  get: async () => {
+    const response = await client.get(endpoints.cart);
+    return handleApiResponse(response, cartSchema, options);
+  },
+  addItem: async (input) => {
+    const response = await client.post(endpoints.addItem, input);
+    return handleApiResponse(response, cartSchema, options);
+  },
+  updateItem: async (input) => {
+    const response = await client.post(endpoints.updateItem, input);
+    return handleApiResponse(response, cartSchema, options);
+  },
+  removeItem: async (input) => {
+    const response = await client.post(endpoints.removeItem, input);
+    return handleApiResponse(response, cartSchema, options);
+  },
+  applyCoupon: async (input) => {
+    const response = await client.post(endpoints.applyCoupon, input);
+    return handleApiResponse(response, cartSchema, options);
+  },
+  removeCoupon: async (input) => {
+    const response = await client.post(endpoints.removeCoupon, input);
+    return handleApiResponse(response, cartSchema, options);
+  },
+  updateCustomer: async (input) => {
+    const response = await client.post(endpoints.updateCustomer, input);
+    return handleApiResponse(response, cartSchema, options);
+  },
+  selectShippingRate: async (input) => {
+    const response = await client.post(endpoints.selectShippingRate, input);
+    return handleApiResponse(response, cartSchema, options);
+  }
+});
+
+// src/api/checkout.ts
+var createCheckoutAPI = (client, endpoints, options, orderAttribution) => ({
+  get: async () => {
+    const response = await client.get(endpoints.checkout);
+    return handleApiResponse(response, checkoutSchema, options);
+  },
+  process: async (input) => {
+    const body = orderAttribution ? {
+      ...input,
+      extensions: {
+        [ORDER_ATTRIBUTION_NAMESPACE]: orderAttribution,
+        ...input.extensions
+      }
+    } : input;
+    const response = await client.post(endpoints.checkout, body);
+    return handleApiResponse(response, checkoutSchema, options);
+  }
+});
+
+// src/api/orders.ts
+var createOrdersAPI = (client, endpoints, options) => ({
+  /**
+   * Get a single order by ID
+   * Uses Store API - supports guest lookup with billing_email + key
+   */
+  get: async (input) => {
+    const { id, billing_email, key } = input;
+    const params = billing_email && key ? { billing_email, key } : void 0;
+    const response = await client.get(`${endpoints.order}/${id}`, { params });
+    return handleApiResponse(response, storeApiOrderSchema, options);
+  }
+});
+var createProductsAPI = (client, endpoints, options) => ({
+  list: async (params) => {
+    const response = await client.get(endpoints.products, { params });
+    return handlePaginatedApiResponse(response, zod.z.array(productSchema), params, options);
+  },
+  get: async (id) => {
+    const response = await client.get(`${endpoints.products}/${id}`);
+    return handleApiResponse(response, productSchema, options);
+  },
+  categories: async () => {
+    const response = await client.get(endpoints.categories);
+    return handleApiResponse(response, zod.z.array(productCategorySchema), options);
+  }
+});
+
+// src/constants/endpoints.ts
+var createEndpoints = (version = "legacy") => {
+  const prefix = version === "v1" ? "/wc/store/v1" : "/wc/store";
+  return {
+    // Products
+    products: `${prefix}/products`,
+    categories: `${prefix}/products/categories`,
+    // Cart
+    cart: `${prefix}/cart`,
+    addItem: `${prefix}/cart/add-item`,
+    updateItem: `${prefix}/cart/update-item`,
+    removeItem: `${prefix}/cart/remove-item`,
+    applyCoupon: `${prefix}/cart/apply-coupon`,
+    removeCoupon: `${prefix}/cart/remove-coupon`,
+    updateCustomer: `${prefix}/cart/update-customer`,
+    selectShippingRate: `${prefix}/cart/select-shipping-rate`,
+    // Checkout
+    checkout: `${prefix}/checkout`,
+    // Orders
+    order: `${prefix}/order`
+  };
+};
+
+// src/client/createClient.ts
+var DEFAULT_ERROR_REPORTER = {
+  report: (error2) => {
+    console.error("[woocommerce-utils]", error2);
+  }
+};
+var createClient = (config) => {
+  const fullConfig = {
+    ...config,
+    errorReporter: config.errorReporter ?? DEFAULT_ERROR_REPORTER
+  };
+  const axiosInstance = axios__default.default.create({
+    baseURL: fullConfig.baseURL,
+    timeout: fullConfig.timeout || 3e4,
+    headers: {
+      "Content-Type": "application/json",
+      ...fullConfig.headers
+    }
+  });
+  const endpoints = createEndpoints(fullConfig.storeApiVersion ?? "legacy");
+  const responseOptions = {
+    validationMode: fullConfig.validationMode,
+    errorReporter: fullConfig.errorReporter?.report,
+    onValidationError: fullConfig.onValidationError
+  };
+  const client = {
+    config: fullConfig,
+    axios: axiosInstance,
+    products: createProductsAPI(axiosInstance, endpoints, responseOptions),
+    cart: createCartAPI(axiosInstance, endpoints, responseOptions),
+    checkout: createCheckoutAPI(
+      axiosInstance,
+      endpoints,
+      responseOptions,
+      fullConfig.orderAttribution
+    ),
+    orders: createOrdersAPI(axiosInstance, endpoints, responseOptions)
+  };
+  setupRequestInterceptor(axiosInstance, fullConfig, client);
+  setupResponseInterceptor(axiosInstance, fullConfig, client);
+  setupErrorInterceptor(axiosInstance, fullConfig, client);
+  return client;
+};
+function createAdminClient(options) {
+  const client = axios__default.default.create({
+    baseURL: options.baseURL,
+    auth: {
+      username: options.consumerKey,
+      password: options.consumerSecret
+    },
+    timeout: 15e3
+  });
+  return {
+    deleteOrder: async (id, force = true) => {
+      await client.delete(`/wc/v3/orders/${id}`, {
+        params: { force }
+      });
+    }
+  };
+}
+var TEST_BILLING_ADDRESS = {
+  first_name: "E2E",
+  last_name: "Test",
+  company: "",
+  address_1: "Ferhadija 10",
+  address_2: "",
+  city: "Sarajevo",
+  state: "",
+  postcode: "71000",
+  country: "BA",
+  phone: "+38761000000",
+  email: "e2e-test@atomic.ba"
+};
+var TEST_SHIPPING_ADDRESS = {
+  first_name: "E2E",
+  last_name: "Test",
+  company: "",
+  address_1: "Ferhadija 10",
+  address_2: "",
+  city: "Sarajevo",
+  state: "",
+  postcode: "71000",
+  country: "BA",
+  phone: "+38761000000"
+};
+function createInMemoryCartAdapter() {
+  let stored = {};
+  return {
+    get: async () => stored,
+    save: async (headers) => {
+      stored = { ...stored, ...headers };
+    },
+    clear: async () => {
+      stored = {};
+    }
+  };
+}
+function createStaticJwtAdapter(token) {
+  return {
+    get: async () => token
+  };
+}
+async function loginForJwt(baseURL, username, password) {
+  const response = await axios__default.default.post(`${baseURL}/jwt-auth/v1/token`, {
+    username,
+    password
+  });
+  return response.data.token;
+}
+function assertAddressMatch(actual, expected, expectFn) {
+  const fields = ["first_name", "last_name", "address_1", "city", "postcode", "country", "phone"];
+  for (const field of fields) {
+    expectFn(actual[field]).toBe(expected[field]);
+  }
+}
+
+// src/testing/suites/authenticated-checkout.suite.ts
+function authenticatedCheckoutSuite(options) {
+  const { timeout = 3e4 } = options;
+  const g = globalThis;
+  const describeFn = options.describe || g.describe;
+  const itFn = options.it || g.it;
+  const expectFn = options.expect || g.expect;
+  const beforeAllFn = options.beforeAll || g.beforeAll;
+  const afterAllFn = options.afterAll || g.afterAll;
+  if (!options.wpUsername || !options.wpPassword) {
+    describeFn("Authenticated Checkout E2E", () => {
+      itFn("skipped \u2014 no WP credentials provided", () => {
+        console.warn("Authenticated checkout E2E skipped. Set wpUsername and wpPassword to run.");
+      });
+    });
+    return;
+  }
+  describeFn("Authenticated Checkout E2E", () => {
+    let client;
+    let adminClient;
+    let createdOrderId = null;
+    beforeAllFn(async () => {
+      const token = await loginForJwt(options.baseURL, options.wpUsername, options.wpPassword);
+      client = createClient({
+        baseURL: options.baseURL,
+        storeApiVersion: options.storeApiVersion ?? "v1",
+        cartHeaders: createInMemoryCartAdapter(),
+        jwtToken: createStaticJwtAdapter(token),
+        validationMode: "strict"
+      });
+      adminClient = createAdminClient({
+        baseURL: options.baseURL,
+        consumerKey: options.consumerKey,
+        consumerSecret: options.consumerSecret
+      });
+    }, timeout);
+    afterAllFn(async () => {
+      if (createdOrderId) {
+        try {
+          await adminClient.deleteOrder(createdOrderId);
+        } catch {
+          console.warn(`[e2e cleanup] Failed to delete order ${createdOrderId}`);
+        }
+      }
+    }, timeout);
+    itFn(
+      "should clear any existing cart items",
+      async () => {
+        const cart = await client.cart.get();
+        for (const item of cart.items) {
+          await client.cart.removeItem({ key: item.key });
+        }
+        const cleared = await client.cart.get();
+        expectFn(cleared.items_count).toBe(0);
+      },
+      timeout
+    );
+    let productId;
+    itFn(
+      "should fetch products",
+      async () => {
+        const result = await client.products.list({ page: 1, per_page: 5 });
+        expectFn(result.data.length).toBeGreaterThan(0);
+        productId = result.data[0].id;
+      },
+      timeout
+    );
+    let cartItemKey;
+    itFn(
+      "should add item to cart with JWT auth",
+      async () => {
+        const cart = await client.cart.addItem({ id: productId, quantity: 1 });
+        expectFn(cart.items_count).toBe(1);
+        expectFn(cart.items[0].id).toBe(productId);
+        cartItemKey = cart.items[0].key;
+      },
+      timeout
+    );
+    itFn(
+      "should fetch cart",
+      async () => {
+        const cart = await client.cart.get();
+        expectFn(cart.items_count).toBe(1);
+        expectFn(cart.needs_payment).toBe(true);
+      },
+      timeout
+    );
+    itFn(
+      "should update customer addresses",
+      async () => {
+        const cart = await client.cart.updateCustomer({
+          billing_address: TEST_BILLING_ADDRESS,
+          shipping_address: TEST_SHIPPING_ADDRESS
+        });
+        assertAddressMatch(cart.billing_address, TEST_BILLING_ADDRESS, expectFn);
+        assertAddressMatch(cart.shipping_address, TEST_SHIPPING_ADDRESS, expectFn);
+        expectFn(cart.billing_address.email).toBe(TEST_BILLING_ADDRESS.email);
+      },
+      timeout
+    );
+    itFn(
+      "should return persisted addresses on cart fetch",
+      async () => {
+        const cart = await client.cart.get();
+        expectFn(cart.billing_address.email).toBe(TEST_BILLING_ADDRESS.email);
+        assertAddressMatch(cart.shipping_address, TEST_SHIPPING_ADDRESS, expectFn);
+      },
+      timeout
+    );
+    itFn(
+      "should remove item from cart",
+      async () => {
+        const cart = await client.cart.removeItem({ key: cartItemKey });
+        expectFn(cart.items_count).toBe(0);
+        expectFn(cart.items.length).toBe(0);
+      },
+      timeout
+    );
+    itFn(
+      "should re-add item to cart for checkout",
+      async () => {
+        const cart = await client.cart.addItem({ id: productId, quantity: 1 });
+        expectFn(cart.items_count).toBe(1);
+      },
+      timeout
+    );
+    itFn(
+      "should fetch checkout state",
+      async () => {
+        const checkout = await client.checkout.get();
+        expectFn(checkout).toHaveProperty("order_id");
+        expectFn(checkout).toHaveProperty("billing_address");
+        expectFn(checkout).toHaveProperty("shipping_address");
+        expectFn(checkout).toHaveProperty("payment_method");
+      },
+      timeout
+    );
+    itFn(
+      "should process checkout with COD payment",
+      async () => {
+        const checkout = await client.checkout.process({
+          payment_method: "cod",
+          billing_address: TEST_BILLING_ADDRESS,
+          shipping_address: TEST_SHIPPING_ADDRESS
+        });
+        expectFn(checkout.order_id).toBeGreaterThan(0);
+        expectFn(checkout.order_key).toMatch(/^wc_order_/);
+        expectFn(checkout.status).toBeTruthy();
+        createdOrderId = checkout.order_id;
+      },
+      timeout
+    );
+    itFn(
+      "should retrieve order using JWT authentication",
+      async () => {
+        const order = await client.orders.get({
+          id: createdOrderId
+        });
+        expectFn(order.id).toBe(createdOrderId);
+        assertAddressMatch(order.billing_address, TEST_BILLING_ADDRESS, expectFn);
+        assertAddressMatch(order.shipping_address, TEST_SHIPPING_ADDRESS, expectFn);
+        expectFn(order.billing_address.email).toBe(TEST_BILLING_ADDRESS.email);
+        expectFn(order.items.length).toBeGreaterThan(0);
+      },
+      timeout
+    );
+  });
+}
+
+// src/testing/suites/checkout-validation.suite.ts
+function checkoutValidationSuite(options) {
+  const { timeout = 3e4 } = options;
+  const g = globalThis;
+  const describeFn = options.describe || g.describe;
+  const itFn = options.it || g.it;
+  const expectFn = options.expect || g.expect;
+  const afterAllFn = options.afterAll || g.afterAll;
+  describeFn("Checkout Validation E2E", () => {
+    const leakedOrderIds = [];
+    const adminClient = createAdminClient({
+      baseURL: options.baseURL,
+      consumerKey: options.consumerKey,
+      consumerSecret: options.consumerSecret
+    });
+    afterAllFn(async () => {
+      for (const id of leakedOrderIds) {
+        try {
+          await adminClient.deleteOrder(id);
+        } catch {
+          console.warn(`[e2e cleanup] Failed to delete leaked order ${id}`);
+        }
+      }
+    }, timeout);
+    async function createReadyClient() {
+      const client = createClient({
+        baseURL: options.baseURL,
+        storeApiVersion: options.storeApiVersion ?? "v1",
+        cartHeaders: createInMemoryCartAdapter(),
+        validationMode: "strict"
+      });
+      const products = await client.products.list({ page: 1, per_page: 1 });
+      if (products.data.length === 0) {
+        throw new Error("No products available for checkout validation tests");
+      }
+      await client.cart.addItem({ id: products.data[0].id, quantity: 1 });
+      return client;
+    }
+    async function expectRejection(label, checkoutCall) {
+      let thrown = null;
+      let result = null;
+      try {
+        result = await checkoutCall();
+      } catch (error2) {
+        thrown = error2;
+      }
+      if (result) {
+        if (result.order_id > 0) leakedOrderIds.push(result.order_id);
+        throw new Error(
+          `${label}: expected server rejection but checkout succeeded (order_id=${result.order_id})`
+        );
+      }
+      expectFn(thrown).toBeInstanceOf(WooCommerceApiError);
+      const wcError = thrown;
+      expectFn(wcError.statusCode).toBe(400);
+    }
+    itFn(
+      "should reject checkout when billing email is empty",
+      async () => {
+        const client = await createReadyClient();
+        await expectRejection(
+          "empty billing email",
+          () => client.checkout.process({
+            payment_method: "cod",
+            billing_address: { ...TEST_BILLING_ADDRESS, email: "" },
+            shipping_address: TEST_SHIPPING_ADDRESS
+          })
+        );
+      },
+      timeout
+    );
+    itFn(
+      "should reject checkout when billing email is invalid",
+      async () => {
+        const client = await createReadyClient();
+        await expectRejection(
+          "invalid billing email",
+          () => client.checkout.process({
+            payment_method: "cod",
+            billing_address: { ...TEST_BILLING_ADDRESS, email: "not-an-email" },
+            shipping_address: TEST_SHIPPING_ADDRESS
+          })
+        );
+      },
+      timeout
+    );
+    const billingRequiredFields = [
+      "first_name",
+      "last_name",
+      "address_1",
+      "city",
+      "postcode"
+    ];
+    for (const field of billingRequiredFields) {
+      itFn(
+        `should reject checkout when billing ${field} is empty`,
+        async () => {
+          const client = await createReadyClient();
+          await expectRejection(
+            `empty billing ${field}`,
+            () => client.checkout.process({
+              payment_method: "cod",
+              billing_address: { ...TEST_BILLING_ADDRESS, [field]: "" },
+              shipping_address: TEST_SHIPPING_ADDRESS
+            })
+          );
+        },
+        timeout
+      );
+    }
+    itFn(
+      "should document server behavior for empty billing phone",
+      async () => {
+        const client = await createReadyClient();
+        let serverAccepted = false;
+        let orderId = 0;
+        try {
+          const result = await client.checkout.process({
+            payment_method: "cod",
+            billing_address: { ...TEST_BILLING_ADDRESS, phone: "" },
+            shipping_address: { ...TEST_SHIPPING_ADDRESS, phone: "" }
+          });
+          serverAccepted = result.order_id > 0;
+          orderId = result.order_id;
+        } catch (error2) {
+          expectFn(error2).toBeInstanceOf(WooCommerceApiError);
+        }
+        if (serverAccepted) {
+          leakedOrderIds.push(orderId);
+        }
+        console.log(
+          `[checkout-validation] Server ${serverAccepted ? "ACCEPTED" : "REJECTED"} checkout with empty phone`
+        );
+        expectFn(typeof serverAccepted).toBe("boolean");
+      },
+      timeout
+    );
+    const shippingRequiredFields = [
+      "first_name",
+      "last_name",
+      "address_1",
+      "city",
+      "postcode"
+    ];
+    for (const field of shippingRequiredFields) {
+      itFn(
+        `should reject checkout when shipping ${field} is empty`,
+        async () => {
+          const client = await createReadyClient();
+          await expectRejection(
+            `empty shipping ${field}`,
+            () => client.checkout.process({
+              payment_method: "cod",
+              billing_address: TEST_BILLING_ADDRESS,
+              shipping_address: { ...TEST_SHIPPING_ADDRESS, [field]: "" }
+            })
+          );
+        },
+        timeout
+      );
+    }
+    itFn(
+      "should document server behavior for empty shipping phone",
+      async () => {
+        const client = await createReadyClient();
+        let serverAccepted = false;
+        let orderId = 0;
+        try {
+          const result = await client.checkout.process({
+            payment_method: "cod",
+            billing_address: TEST_BILLING_ADDRESS,
+            shipping_address: { ...TEST_SHIPPING_ADDRESS, phone: "" }
+          });
+          serverAccepted = result.order_id > 0;
+          orderId = result.order_id;
+        } catch (error2) {
+          expectFn(error2).toBeInstanceOf(WooCommerceApiError);
+        }
+        if (serverAccepted) {
+          leakedOrderIds.push(orderId);
+        }
+        console.log(
+          `[checkout-validation] Server ${serverAccepted ? "ACCEPTED" : "REJECTED"} checkout with empty shipping phone`
+        );
+        expectFn(typeof serverAccepted).toBe("boolean");
+      },
+      timeout
+    );
+    itFn(
+      "should reject checkout with empty payment method",
+      async () => {
+        const client = await createReadyClient();
+        await expectRejection(
+          "empty payment method",
+          () => client.checkout.process({
+            payment_method: "",
+            billing_address: TEST_BILLING_ADDRESS,
+            shipping_address: TEST_SHIPPING_ADDRESS
+          })
+        );
+      },
+      timeout
+    );
+  });
+}
+
+// src/testing/suites/guest-checkout.suite.ts
+function guestCheckoutSuite(options) {
+  const { timeout = 3e4 } = options;
+  const g = globalThis;
+  const describeFn = options.describe || g.describe;
+  const itFn = options.it || g.it;
+  const expectFn = options.expect || g.expect;
+  const beforeAllFn = options.beforeAll || g.beforeAll;
+  const afterAllFn = options.afterAll || g.afterAll;
+  describeFn("Guest Checkout E2E", () => {
+    let client;
+    let adminClient;
+    let createdOrderId = null;
+    beforeAllFn(() => {
+      client = createClient({
+        baseURL: options.baseURL,
+        storeApiVersion: options.storeApiVersion ?? "v1",
+        cartHeaders: createInMemoryCartAdapter(),
+        validationMode: "strict"
+      });
+      adminClient = createAdminClient({
+        baseURL: options.baseURL,
+        consumerKey: options.consumerKey,
+        consumerSecret: options.consumerSecret
+      });
+    }, timeout);
+    afterAllFn(async () => {
+      if (createdOrderId) {
+        try {
+          await adminClient.deleteOrder(createdOrderId);
+        } catch {
+          console.warn(`[e2e cleanup] Failed to delete order ${createdOrderId}`);
+        }
+      }
+    }, timeout);
+    let productId;
+    itFn(
+      "should fetch products and find at least one",
+      async () => {
+        const result = await client.products.list({ page: 1, per_page: 5 });
+        expectFn(result.data.length).toBeGreaterThan(0);
+        expectFn(result.pagination).toHaveProperty("total");
+        productId = result.data[0].id;
+      },
+      timeout
+    );
+    let cartItemKey;
+    itFn(
+      "should add item to cart",
+      async () => {
+        const cart = await client.cart.addItem({ id: productId, quantity: 1 });
+        expectFn(cart.items_count).toBe(1);
+        expectFn(cart.items.length).toBe(1);
+        expectFn(cart.items[0].id).toBe(productId);
+        cartItemKey = cart.items[0].key;
+      },
+      timeout
+    );
+    itFn(
+      "should fetch cart with item present",
+      async () => {
+        const cart = await client.cart.get();
+        expectFn(cart.items_count).toBe(1);
+        expectFn(cart.needs_payment).toBe(true);
+      },
+      timeout
+    );
+    itFn(
+      "should update customer billing and shipping addresses",
+      async () => {
+        const cart = await client.cart.updateCustomer({
+          billing_address: TEST_BILLING_ADDRESS,
+          shipping_address: TEST_SHIPPING_ADDRESS
+        });
+        assertAddressMatch(cart.billing_address, TEST_BILLING_ADDRESS, expectFn);
+        assertAddressMatch(cart.shipping_address, TEST_SHIPPING_ADDRESS, expectFn);
+        expectFn(cart.billing_address.email).toBe(TEST_BILLING_ADDRESS.email);
+      },
+      timeout
+    );
+    itFn(
+      "should return persisted addresses on cart fetch",
+      async () => {
+        const cart = await client.cart.get();
+        expectFn(cart.billing_address.email).toBe(TEST_BILLING_ADDRESS.email);
+        assertAddressMatch(cart.shipping_address, TEST_SHIPPING_ADDRESS, expectFn);
+      },
+      timeout
+    );
+    itFn(
+      "should remove item from cart",
+      async () => {
+        const cart = await client.cart.removeItem({ key: cartItemKey });
+        expectFn(cart.items_count).toBe(0);
+        expectFn(cart.items.length).toBe(0);
+      },
+      timeout
+    );
+    itFn(
+      "should re-add item to cart for checkout",
+      async () => {
+        const cart = await client.cart.addItem({ id: productId, quantity: 1 });
+        expectFn(cart.items_count).toBe(1);
+      },
+      timeout
+    );
+    itFn(
+      "should fetch checkout state",
+      async () => {
+        const checkout = await client.checkout.get();
+        expectFn(checkout).toHaveProperty("order_id");
+        expectFn(checkout).toHaveProperty("billing_address");
+        expectFn(checkout).toHaveProperty("shipping_address");
+        expectFn(checkout).toHaveProperty("payment_method");
+      },
+      timeout
+    );
+    let orderKey;
+    itFn(
+      "should process checkout with COD payment",
+      async () => {
+        const checkout = await client.checkout.process({
+          payment_method: "cod",
+          billing_address: TEST_BILLING_ADDRESS,
+          shipping_address: TEST_SHIPPING_ADDRESS
+        });
+        expectFn(checkout.order_id).toBeGreaterThan(0);
+        expectFn(checkout.order_key).toMatch(/^wc_order_/);
+        expectFn(checkout.status).toBeTruthy();
+        createdOrderId = checkout.order_id;
+        orderKey = checkout.order_key;
+      },
+      timeout
+    );
+    itFn(
+      "should retrieve order as guest using billing email and order key",
+      async () => {
+        const order = await client.orders.get({
+          id: createdOrderId,
+          billing_email: TEST_BILLING_ADDRESS.email,
+          key: orderKey
+        });
+        expectFn(order.id).toBe(createdOrderId);
+        assertAddressMatch(order.billing_address, TEST_BILLING_ADDRESS, expectFn);
+        assertAddressMatch(order.shipping_address, TEST_SHIPPING_ADDRESS, expectFn);
+        expectFn(order.billing_address.email).toBe(TEST_BILLING_ADDRESS.email);
+        expectFn(order.items.length).toBeGreaterThan(0);
+      },
+      timeout
+    );
+  });
+}
+
+// src/testing/createTestSuite.ts
+function createWooCommerceTestSuite(options) {
+  guestCheckoutSuite(options);
+  authenticatedCheckoutSuite(options);
+  checkoutValidationSuite(options);
+}
+
+exports.TEST_BILLING_ADDRESS = TEST_BILLING_ADDRESS;
+exports.TEST_SHIPPING_ADDRESS = TEST_SHIPPING_ADDRESS;
+exports.createAdminClient = createAdminClient;
+exports.createInMemoryCartAdapter = createInMemoryCartAdapter;
+exports.createStaticJwtAdapter = createStaticJwtAdapter;
+exports.createWooCommerceTestSuite = createWooCommerceTestSuite;
+exports.loginForJwt = loginForJwt;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map