@szymonpiatek/nextwordpress 0.0.6 → 0.0.8

package/dist/index.cjs

@@ -9,10 +9,96 @@ function resolveBaseUrl(config) {
   return typeof window === "undefined" ? config.serverURL : config.clientURL;
 }
 
+// src/shared/errors/codes.ts
+var ErrorCode = {
+  // WordPress REST API
+  WP_REQUEST_FAILED: "WP_REQUEST_FAILED",
+  WP_NOT_FOUND: "WP_NOT_FOUND",
+  WP_UNAUTHORIZED: "WP_UNAUTHORIZED",
+  WP_FORBIDDEN: "WP_FORBIDDEN",
+  // WPGraphQL
+  GQL_REQUEST_FAILED: "GQL_REQUEST_FAILED",
+  GQL_NO_DATA: "GQL_NO_DATA",
+  GQL_ERRORS_IN_RESPONSE: "GQL_ERRORS_IN_RESPONSE",
+  // WooCommerce — generic
+  WOO_REQUEST_FAILED: "WOO_REQUEST_FAILED",
+  WOO_NOT_FOUND: "WOO_NOT_FOUND",
+  WOO_UNAUTHORIZED: "WOO_UNAUTHORIZED",
+  WOO_FORBIDDEN: "WOO_FORBIDDEN",
+  // WooCommerce — resource-specific
+  WOO_COUPON_NOT_FOUND: "WOO_COUPON_NOT_FOUND",
+  WOO_PRODUCT_NOT_FOUND: "WOO_PRODUCT_NOT_FOUND",
+  WOO_ORDER_NOT_FOUND: "WOO_ORDER_NOT_FOUND",
+  WOO_CUSTOMER_NOT_FOUND: "WOO_CUSTOMER_NOT_FOUND",
+  WOO_CATEGORY_NOT_FOUND: "WOO_CATEGORY_NOT_FOUND",
+  WOO_TAG_NOT_FOUND: "WOO_TAG_NOT_FOUND",
+  WOO_REVIEW_NOT_FOUND: "WOO_REVIEW_NOT_FOUND",
+  WOO_WEBHOOK_NOT_FOUND: "WOO_WEBHOOK_NOT_FOUND",
+  WOO_SHIPPING_ZONE_NOT_FOUND: "WOO_SHIPPING_ZONE_NOT_FOUND",
+  // Auth
+  AUTH_JWT_FAILED: "AUTH_JWT_FAILED",
+  AUTH_CREDENTIALS_INVALID: "AUTH_CREDENTIALS_INVALID",
+  AUTH_TOKEN_INVALID: "AUTH_TOKEN_INVALID"
+};
+var defaultMessages = {
+  WP_REQUEST_FAILED: "WordPress API request failed",
+  WP_NOT_FOUND: "WordPress resource not found",
+  WP_UNAUTHORIZED: "WordPress authentication required",
+  WP_FORBIDDEN: "WordPress access denied",
+  GQL_REQUEST_FAILED: "WPGraphQL request failed",
+  GQL_NO_DATA: "No data returned from WPGraphQL",
+  GQL_ERRORS_IN_RESPONSE: "WPGraphQL returned errors",
+  WOO_REQUEST_FAILED: "WooCommerce API request failed",
+  WOO_NOT_FOUND: "WooCommerce resource not found",
+  WOO_UNAUTHORIZED: "WooCommerce authentication required",
+  WOO_FORBIDDEN: "WooCommerce access denied",
+  WOO_COUPON_NOT_FOUND: "Coupon not found",
+  WOO_PRODUCT_NOT_FOUND: "Product not found",
+  WOO_ORDER_NOT_FOUND: "Order not found",
+  WOO_CUSTOMER_NOT_FOUND: "Customer not found",
+  WOO_CATEGORY_NOT_FOUND: "Category not found",
+  WOO_TAG_NOT_FOUND: "Tag not found",
+  WOO_REVIEW_NOT_FOUND: "Product review not found",
+  WOO_WEBHOOK_NOT_FOUND: "Webhook not found",
+  WOO_SHIPPING_ZONE_NOT_FOUND: "Shipping zone not found",
+  AUTH_JWT_FAILED: "JWT authentication failed",
+  AUTH_CREDENTIALS_INVALID: "Invalid credentials",
+  AUTH_TOKEN_INVALID: "JWT token is invalid or expired"
+};
+var defaultMessagesPl = {
+  WP_REQUEST_FAILED: "B\u0142\u0105d \u017C\u0105dania do WordPress API",
+  WP_NOT_FOUND: "Zas\xF3b WordPress nie istnieje",
+  WP_UNAUTHORIZED: "Wymagane uwierzytelnienie WordPress",
+  WP_FORBIDDEN: "Brak dost\u0119pu do zasobu WordPress",
+  GQL_REQUEST_FAILED: "B\u0142\u0105d \u017C\u0105dania WPGraphQL",
+  GQL_NO_DATA: "WPGraphQL nie zwr\xF3ci\u0142o danych",
+  GQL_ERRORS_IN_RESPONSE: "WPGraphQL zwr\xF3ci\u0142o b\u0142\u0119dy",
+  WOO_REQUEST_FAILED: "B\u0142\u0105d \u017C\u0105dania do WooCommerce API",
+  WOO_NOT_FOUND: "Zas\xF3b WooCommerce nie istnieje",
+  WOO_UNAUTHORIZED: "Wymagane uwierzytelnienie WooCommerce",
+  WOO_FORBIDDEN: "Brak dost\u0119pu do zasobu WooCommerce",
+  WOO_COUPON_NOT_FOUND: "Kupon nie istnieje",
+  WOO_PRODUCT_NOT_FOUND: "Produkt nie istnieje",
+  WOO_ORDER_NOT_FOUND: "Zam\xF3wienie nie istnieje",
+  WOO_CUSTOMER_NOT_FOUND: "Klient nie istnieje",
+  WOO_CATEGORY_NOT_FOUND: "Kategoria produkt\xF3w nie istnieje",
+  WOO_TAG_NOT_FOUND: "Tag produkt\xF3w nie istnieje",
+  WOO_REVIEW_NOT_FOUND: "Opinia o produkcie nie istnieje",
+  WOO_WEBHOOK_NOT_FOUND: "Webhook nie istnieje",
+  WOO_SHIPPING_ZONE_NOT_FOUND: "Strefa wysy\u0142ki nie istnieje",
+  AUTH_JWT_FAILED: "B\u0142\u0105d uwierzytelnienia JWT",
+  AUTH_CREDENTIALS_INVALID: "Nieprawid\u0142owe dane logowania",
+  AUTH_TOKEN_INVALID: "Token JWT jest nieprawid\u0142owy lub wygas\u0142"
+};
+function resolveMessage(code, overrides) {
+  return overrides?.[code] ?? defaultMessages[code];
+}
+
 // src/integrations/restApi/core/client/types.ts
 var WordPressAPIError = class extends Error {
-  constructor(message, status, endpoint) {
-    super(message);
+  constructor(code, status, endpoint, message, detail) {
+    super(detail ? `${message}: ${detail}` : message);
+    __publicField(this, "code", code);
     __publicField(this, "status", status);
     __publicField(this, "endpoint", endpoint);
     this.name = "WordPressAPIError";
@@ -35,19 +121,28 @@ function buildUrl(config, path, query) {
 
 // src/integrations/restApi/core/client/fetcher.ts
 var USER_AGENT = "NextWordpress Client";
-async function doFetch(url, init = {}) {
-  const response = await fetch(url, init);
-  if (!response.ok) {
-    throw new WordPressAPIError(
-      `WordPress API request failed: ${response.statusText}`,
-      response.status,
-      url
-    );
-  }
-  return response;
+function resolveWpErrorCode(status) {
+  if (status === 401) return ErrorCode.WP_UNAUTHORIZED;
+  if (status === 403) return ErrorCode.WP_FORBIDDEN;
+  if (status === 404) return ErrorCode.WP_NOT_FOUND;
+  return ErrorCode.WP_REQUEST_FAILED;
 }
 function createFetcher(config) {
   const cacheTtl = config.cacheTTL ?? 300;
+  async function doFetch(url, init = {}) {
+    const response = await fetch(url, init);
+    if (!response.ok) {
+      const code = resolveWpErrorCode(response.status);
+      throw new WordPressAPIError(
+        code,
+        response.status,
+        url,
+        resolveMessage(code, config.errorMessages),
+        response.statusText
+      );
+    }
+    return response;
+  }
   async function wpFetch(path, query, tags = ["wordpress"]) {
     const url = buildUrl(config, path, query);
     const res = await doFetch(url, {
@@ -710,6 +805,42 @@ function withOmnibusVariation(variation) {
   };
 }
 
+// src/integrations/restApi/woocommerce/client/types.ts
+var WooCommerceError = class extends Error {
+  constructor(code, status, endpoint, message, upstreamCode, detail) {
+    super(detail ? `${message}: ${detail}` : message);
+    __publicField(this, "code", code);
+    __publicField(this, "status", status);
+    __publicField(this, "endpoint", endpoint);
+    __publicField(this, "upstreamCode", upstreamCode);
+    this.name = "WooCommerceError";
+  }
+};
+
+// src/integrations/restApi/woocommerce/client/errorMap.ts
+var upstreamToErrorCode = {
+  woocommerce_rest_coupon_invalid_id: ErrorCode.WOO_COUPON_NOT_FOUND,
+  woocommerce_rest_product_invalid_id: ErrorCode.WOO_PRODUCT_NOT_FOUND,
+  woocommerce_rest_order_invalid_id: ErrorCode.WOO_ORDER_NOT_FOUND,
+  woocommerce_rest_customer_invalid_id: ErrorCode.WOO_CUSTOMER_NOT_FOUND,
+  woocommerce_rest_term_invalid: ErrorCode.WOO_CATEGORY_NOT_FOUND,
+  woocommerce_rest_review_invalid_id: ErrorCode.WOO_REVIEW_NOT_FOUND,
+  woocommerce_rest_webhook_invalid_id: ErrorCode.WOO_WEBHOOK_NOT_FOUND,
+  woocommerce_rest_shipping_zone_invalid_id: ErrorCode.WOO_SHIPPING_ZONE_NOT_FOUND
+};
+function resolveWooErrorCode(status, upstreamCode) {
+  if (status === 401) return ErrorCode.WOO_UNAUTHORIZED;
+  if (status === 403) return ErrorCode.WOO_FORBIDDEN;
+  if (status === 404) {
+    if (upstreamCode) {
+      const mapped = upstreamToErrorCode[upstreamCode];
+      if (mapped) return mapped;
+    }
+    return ErrorCode.WOO_NOT_FOUND;
+  }
+  return ErrorCode.WOO_REQUEST_FAILED;
+}
+
 // src/integrations/restApi/woocommerce/client/fetcher.ts
 var USER_AGENT2 = "NextWordpress WooCommerce Client";
 var DEFAULT_CACHE_TTL = 3600;
@@ -727,7 +858,20 @@ function createWooCommerceFetcher(config) {
     return { ...query, consumer_key: config.consumerKey, consumer_secret: config.consumerSecret };
   }
   function buildUrl2(path, query) {
-    return `${config.serverURL}${path}?${toQueryString(withAuth(query))}`;
+    const base = typeof window !== "undefined" && config.clientURL ? config.clientURL : config.serverURL;
+    return `${base}${path}?${toQueryString(withAuth(query))}`;
+  }
+  async function throwWooError(response, url) {
+    const body = await response.json().catch(() => ({}));
+    const errorCode = resolveWooErrorCode(response.status, body.code);
+    throw new WooCommerceError(
+      errorCode,
+      response.status,
+      url,
+      resolveMessage(errorCode, config.errorMessages),
+      body.code,
+      body.message
+    );
   }
   async function wcFetch(path, query, tags = ["woocommerce"], options) {
     const url = buildUrl2(path, query);
@@ -743,9 +887,7 @@ function createWooCommerceFetcher(config) {
       next: isMutation || noStore ? void 0 : { tags, revalidate: cacheTTL }
     });
     if (!response.ok) {
-      const body = await response.json().catch(() => ({}));
-      const detail = body.message ? ` \u2013 ${body.message}` : "";
-      throw new Error(`WooCommerce API ${response.status}: ${response.statusText}${detail} [${url}]`);
+      await throwWooError(response, url);
     }
     return response.json();
   }
@@ -764,7 +906,7 @@ function createWooCommerceFetcher(config) {
       next: { tags, revalidate: cacheTTL }
     });
     if (!response.ok) {
-      throw new Error(`WooCommerce API ${response.status}: ${response.statusText} [${url}]`);
+      await throwWooError(response, url);
     }
     return {
       data: await response.json(),
@@ -1211,6 +1353,725 @@ function createCustomersQueries(fetcher) {
   };
 }
 
+// src/integrations/restApi/woocommerce/payment_gateways/queries.ts
+function createPaymentGatewaysQueries(fetcher) {
+  const { wcFetch, wcFetchGraceful } = fetcher;
+  async function getPaymentGateways() {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/payment_gateways",
+      [],
+      void 0,
+      ["woocommerce", "payment_gateways"]
+    );
+  }
+  async function getEnabledPaymentGateways() {
+    const gateways = await wcFetchGraceful(
+      "/wp-json/wc/v3/payment_gateways",
+      [],
+      void 0,
+      ["woocommerce", "payment_gateways"]
+    );
+    return gateways.filter((g) => g.enabled);
+  }
+  async function getPaymentGatewayById(id) {
+    return wcFetch(
+      `/wp-json/wc/v3/payment_gateways/${id}`,
+      void 0,
+      ["woocommerce", "payment_gateways", `payment_gateway-${id}`]
+    );
+  }
+  return {
+    getPaymentGateways,
+    getEnabledPaymentGateways,
+    getPaymentGatewayById
+  };
+}
+
+// src/integrations/restApi/woocommerce/order_notes/queries.ts
+function createOrderNotesQueries(fetcher) {
+  const { wcFetch, wcFetchGraceful, wcMutate } = fetcher;
+  async function getNotesByOrderId(orderId) {
+    return wcFetchGraceful(
+      `/wp-json/wc/v3/orders/${orderId}/notes`,
+      [],
+      void 0,
+      ["woocommerce", "order_notes", `order-${orderId}-notes`]
+    );
+  }
+  async function getOrderNoteById(orderId, noteId) {
+    return wcFetch(
+      `/wp-json/wc/v3/orders/${orderId}/notes/${noteId}`,
+      void 0,
+      ["woocommerce", "order_notes", `order-${orderId}-note-${noteId}`]
+    );
+  }
+  async function createOrderNote(orderId, input) {
+    return wcMutate(
+      `/wp-json/wc/v3/orders/${orderId}/notes`,
+      input,
+      "POST"
+    );
+  }
+  async function deleteOrderNote(orderId, noteId, force = true) {
+    return wcMutate(
+      `/wp-json/wc/v3/orders/${orderId}/notes/${noteId}`,
+      { force },
+      "DELETE"
+    );
+  }
+  return {
+    getNotesByOrderId,
+    getOrderNoteById,
+    createOrderNote,
+    deleteOrderNote
+  };
+}
+
+// src/integrations/restApi/woocommerce/order_refunds/queries.ts
+function createOrderRefundsQueries(fetcher) {
+  const { wcFetch, wcFetchGraceful, wcMutate } = fetcher;
+  async function getRefundsByOrderId(orderId) {
+    return wcFetchGraceful(
+      `/wp-json/wc/v3/orders/${orderId}/refunds`,
+      [],
+      void 0,
+      ["woocommerce", "order_refunds", `order-${orderId}-refunds`]
+    );
+  }
+  async function getOrderRefundById(orderId, refundId) {
+    return wcFetch(
+      `/wp-json/wc/v3/orders/${orderId}/refunds/${refundId}`,
+      void 0,
+      ["woocommerce", "order_refunds", `order-${orderId}-refund-${refundId}`]
+    );
+  }
+  async function createOrderRefund(orderId, input) {
+    return wcMutate(
+      `/wp-json/wc/v3/orders/${orderId}/refunds`,
+      input,
+      "POST"
+    );
+  }
+  async function deleteOrderRefund(orderId, refundId, force = true) {
+    return wcMutate(
+      `/wp-json/wc/v3/orders/${orderId}/refunds/${refundId}`,
+      { force },
+      "DELETE"
+    );
+  }
+  return {
+    getRefundsByOrderId,
+    getOrderRefundById,
+    createOrderRefund,
+    deleteOrderRefund
+  };
+}
+
+// src/integrations/restApi/woocommerce/product_attributes/queries.ts
+function createProductAttributesQueries(fetcher) {
+  const { wcFetch, wcFetchGraceful, wcMutate } = fetcher;
+  async function getProductAttributes() {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/products/attributes",
+      [],
+      void 0,
+      ["woocommerce", "product_attributes"]
+    );
+  }
+  async function getProductAttributeById(id) {
+    return wcFetch(
+      `/wp-json/wc/v3/products/attributes/${id}`,
+      void 0,
+      ["woocommerce", "product_attributes", `attribute-${id}`]
+    );
+  }
+  async function createProductAttribute(input) {
+    return wcMutate("/wp-json/wc/v3/products/attributes", input, "POST");
+  }
+  async function updateProductAttribute(id, input) {
+    return wcMutate(
+      `/wp-json/wc/v3/products/attributes/${id}`,
+      input,
+      "PUT"
+    );
+  }
+  async function deleteProductAttribute(id, force = true) {
+    return wcMutate(
+      `/wp-json/wc/v3/products/attributes/${id}`,
+      { force },
+      "DELETE"
+    );
+  }
+  async function getAttributeTerms(attributeId) {
+    return wcFetchGraceful(
+      `/wp-json/wc/v3/products/attributes/${attributeId}/terms`,
+      [],
+      void 0,
+      ["woocommerce", "attribute_terms", `attribute-${attributeId}-terms`]
+    );
+  }
+  async function getAttributeTermById(attributeId, termId) {
+    return wcFetch(
+      `/wp-json/wc/v3/products/attributes/${attributeId}/terms/${termId}`,
+      void 0,
+      ["woocommerce", "attribute_terms", `attribute-${attributeId}-term-${termId}`]
+    );
+  }
+  async function createAttributeTerm(attributeId, input) {
+    return wcMutate(
+      `/wp-json/wc/v3/products/attributes/${attributeId}/terms`,
+      input,
+      "POST"
+    );
+  }
+  async function updateAttributeTerm(attributeId, termId, input) {
+    return wcMutate(
+      `/wp-json/wc/v3/products/attributes/${attributeId}/terms/${termId}`,
+      input,
+      "PUT"
+    );
+  }
+  async function deleteAttributeTerm(attributeId, termId, force = true) {
+    return wcMutate(
+      `/wp-json/wc/v3/products/attributes/${attributeId}/terms/${termId}`,
+      { force },
+      "DELETE"
+    );
+  }
+  return {
+    getProductAttributes,
+    getProductAttributeById,
+    createProductAttribute,
+    updateProductAttribute,
+    deleteProductAttribute,
+    getAttributeTerms,
+    getAttributeTermById,
+    createAttributeTerm,
+    updateAttributeTerm,
+    deleteAttributeTerm
+  };
+}
+
+// src/integrations/restApi/woocommerce/product_reviews/queries.ts
+function createProductReviewsQueries(fetcher) {
+  const { wcFetch, wcFetchGraceful, wcMutate } = fetcher;
+  async function getProductReviews(params) {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/products/reviews",
+      [],
+      params,
+      ["woocommerce", "product_reviews"]
+    );
+  }
+  async function getProductReviewsByProductId(productId) {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/products/reviews",
+      [],
+      { product: [productId] },
+      ["woocommerce", "product_reviews", `reviews-product-${productId}`]
+    );
+  }
+  async function getProductReviewById(id) {
+    return wcFetch(
+      `/wp-json/wc/v3/products/reviews/${id}`,
+      void 0,
+      ["woocommerce", "product_reviews", `review-${id}`]
+    );
+  }
+  async function createProductReview(input) {
+    return wcMutate("/wp-json/wc/v3/products/reviews", input, "POST");
+  }
+  async function updateProductReview(id, input) {
+    return wcMutate(`/wp-json/wc/v3/products/reviews/${id}`, input, "PUT");
+  }
+  async function deleteProductReview(id, force = true) {
+    return wcMutate(
+      `/wp-json/wc/v3/products/reviews/${id}`,
+      { force },
+      "DELETE"
+    );
+  }
+  return {
+    getProductReviews,
+    getProductReviewsByProductId,
+    getProductReviewById,
+    createProductReview,
+    updateProductReview,
+    deleteProductReview
+  };
+}
+
+// src/integrations/restApi/woocommerce/shipping_classes/queries.ts
+function createShippingClassesQueries(fetcher) {
+  const { wcFetch, wcFetchGraceful, wcMutate } = fetcher;
+  async function getShippingClasses() {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/products/shipping_classes",
+      [],
+      void 0,
+      ["woocommerce", "shipping_classes"]
+    );
+  }
+  async function getShippingClassById(id) {
+    return wcFetch(
+      `/wp-json/wc/v3/products/shipping_classes/${id}`,
+      void 0,
+      ["woocommerce", "shipping_classes", `shipping-class-${id}`]
+    );
+  }
+  async function createShippingClass(input) {
+    return wcMutate("/wp-json/wc/v3/products/shipping_classes", input, "POST");
+  }
+  async function updateShippingClass(id, input) {
+    return wcMutate(
+      `/wp-json/wc/v3/products/shipping_classes/${id}`,
+      input,
+      "PUT"
+    );
+  }
+  async function deleteShippingClass(id, force = true) {
+    return wcMutate(
+      `/wp-json/wc/v3/products/shipping_classes/${id}`,
+      { force },
+      "DELETE"
+    );
+  }
+  return {
+    getShippingClasses,
+    getShippingClassById,
+    createShippingClass,
+    updateShippingClass,
+    deleteShippingClass
+  };
+}
+
+// src/integrations/restApi/woocommerce/taxes/queries.ts
+function createTaxesQueries(fetcher) {
+  const { wcFetch, wcFetchGraceful, wcMutate } = fetcher;
+  async function getTaxRates(params) {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/taxes",
+      [],
+      params,
+      ["woocommerce", "tax_rates"]
+    );
+  }
+  async function getTaxRateById(id) {
+    return wcFetch(
+      `/wp-json/wc/v3/taxes/${id}`,
+      void 0,
+      ["woocommerce", "tax_rates", `tax-rate-${id}`]
+    );
+  }
+  async function createTaxRate(input) {
+    return wcMutate("/wp-json/wc/v3/taxes", input, "POST");
+  }
+  async function updateTaxRate(id, input) {
+    return wcMutate(`/wp-json/wc/v3/taxes/${id}`, input, "PUT");
+  }
+  async function deleteTaxRate(id, force = true) {
+    return wcMutate(
+      `/wp-json/wc/v3/taxes/${id}`,
+      { force },
+      "DELETE"
+    );
+  }
+  async function getTaxClasses() {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/taxes/classes",
+      [],
+      void 0,
+      ["woocommerce", "tax_classes"]
+    );
+  }
+  async function createTaxClass(input) {
+    return wcMutate("/wp-json/wc/v3/taxes/classes", input, "POST");
+  }
+  async function deleteTaxClass(slug, force = true) {
+    return wcMutate(
+      `/wp-json/wc/v3/taxes/classes/${slug}`,
+      { force },
+      "DELETE"
+    );
+  }
+  return {
+    getTaxRates,
+    getTaxRateById,
+    createTaxRate,
+    updateTaxRate,
+    deleteTaxRate,
+    getTaxClasses,
+    createTaxClass,
+    deleteTaxClass
+  };
+}
+
+// src/integrations/restApi/woocommerce/shipping/queries.ts
+function createShippingQueries(fetcher) {
+  const { wcFetch, wcFetchGraceful, wcMutate } = fetcher;
+  async function getShippingZones() {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/shipping/zones",
+      [],
+      void 0,
+      ["woocommerce", "shipping_zones"]
+    );
+  }
+  async function getShippingZoneById(id) {
+    return wcFetch(
+      `/wp-json/wc/v3/shipping/zones/${id}`,
+      void 0,
+      ["woocommerce", "shipping_zones", `zone-${id}`]
+    );
+  }
+  async function createShippingZone(input) {
+    return wcMutate("/wp-json/wc/v3/shipping/zones", input, "POST");
+  }
+  async function updateShippingZone(id, input) {
+    return wcMutate(`/wp-json/wc/v3/shipping/zones/${id}`, input, "PUT");
+  }
+  async function deleteShippingZone(id, force = true) {
+    return wcMutate(
+      `/wp-json/wc/v3/shipping/zones/${id}`,
+      { force },
+      "DELETE"
+    );
+  }
+  async function getShippingZoneLocations(zoneId) {
+    return wcFetchGraceful(
+      `/wp-json/wc/v3/shipping/zones/${zoneId}/locations`,
+      [],
+      void 0,
+      ["woocommerce", "shipping_zone_locations", `zone-${zoneId}-locations`]
+    );
+  }
+  async function updateShippingZoneLocations(zoneId, locations) {
+    return wcMutate(
+      `/wp-json/wc/v3/shipping/zones/${zoneId}/locations`,
+      locations,
+      "PUT"
+    );
+  }
+  async function getShippingZoneMethods(zoneId) {
+    return wcFetchGraceful(
+      `/wp-json/wc/v3/shipping/zones/${zoneId}/methods`,
+      [],
+      void 0,
+      ["woocommerce", "shipping_zone_methods", `zone-${zoneId}-methods`]
+    );
+  }
+  async function getShippingZoneMethodById(zoneId, instanceId) {
+    return wcFetch(
+      `/wp-json/wc/v3/shipping/zones/${zoneId}/methods/${instanceId}`,
+      void 0,
+      ["woocommerce", "shipping_zone_methods", `zone-${zoneId}-method-${instanceId}`]
+    );
+  }
+  async function createShippingZoneMethod(zoneId, input) {
+    return wcMutate(
+      `/wp-json/wc/v3/shipping/zones/${zoneId}/methods`,
+      input,
+      "POST"
+    );
+  }
+  async function updateShippingZoneMethod(zoneId, instanceId, input) {
+    return wcMutate(
+      `/wp-json/wc/v3/shipping/zones/${zoneId}/methods/${instanceId}`,
+      input,
+      "PUT"
+    );
+  }
+  async function deleteShippingZoneMethod(zoneId, instanceId, force = true) {
+    return wcMutate(
+      `/wp-json/wc/v3/shipping/zones/${zoneId}/methods/${instanceId}`,
+      { force },
+      "DELETE"
+    );
+  }
+  async function getShippingMethods() {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/shipping_methods",
+      [],
+      void 0,
+      ["woocommerce", "shipping_methods"]
+    );
+  }
+  async function getShippingMethodById(id) {
+    return wcFetch(
+      `/wp-json/wc/v3/shipping_methods/${id}`,
+      void 0,
+      ["woocommerce", "shipping_methods", `shipping-method-${id}`]
+    );
+  }
+  return {
+    getShippingZones,
+    getShippingZoneById,
+    createShippingZone,
+    updateShippingZone,
+    deleteShippingZone,
+    getShippingZoneLocations,
+    updateShippingZoneLocations,
+    getShippingZoneMethods,
+    getShippingZoneMethodById,
+    createShippingZoneMethod,
+    updateShippingZoneMethod,
+    deleteShippingZoneMethod,
+    getShippingMethods,
+    getShippingMethodById
+  };
+}
+
+// src/integrations/restApi/woocommerce/webhooks/queries.ts
+function createWebhooksQueries(fetcher) {
+  const { wcFetch, wcFetchGraceful, wcMutate } = fetcher;
+  async function getWebhooks(params) {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/webhooks",
+      [],
+      params,
+      ["woocommerce", "webhooks"]
+    );
+  }
+  async function getWebhookById(id) {
+    return wcFetch(
+      `/wp-json/wc/v3/webhooks/${id}`,
+      void 0,
+      ["woocommerce", "webhooks", `webhook-${id}`]
+    );
+  }
+  async function createWebhook(input) {
+    return wcMutate("/wp-json/wc/v3/webhooks", input, "POST");
+  }
+  async function updateWebhook(id, input) {
+    return wcMutate(`/wp-json/wc/v3/webhooks/${id}`, input, "PUT");
+  }
+  async function deleteWebhook(id, force = true) {
+    return wcMutate(
+      `/wp-json/wc/v3/webhooks/${id}`,
+      { force },
+      "DELETE"
+    );
+  }
+  return {
+    getWebhooks,
+    getWebhookById,
+    createWebhook,
+    updateWebhook,
+    deleteWebhook
+  };
+}
+
+// src/integrations/restApi/woocommerce/settings/queries.ts
+function createSettingsQueries(fetcher) {
+  const { wcFetch, wcFetchGraceful, wcMutate } = fetcher;
+  async function getSettingGroups() {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/settings",
+      [],
+      void 0,
+      ["woocommerce", "settings"]
+    );
+  }
+  async function getSettingOptions(groupId) {
+    return wcFetchGraceful(
+      `/wp-json/wc/v3/settings/${groupId}`,
+      [],
+      void 0,
+      ["woocommerce", "settings", `settings-${groupId}`]
+    );
+  }
+  async function getSettingOption(groupId, optionId) {
+    return wcFetch(
+      `/wp-json/wc/v3/settings/${groupId}/${optionId}`,
+      void 0,
+      ["woocommerce", "settings", `settings-${groupId}-${optionId}`]
+    );
+  }
+  async function updateSettingOption(groupId, optionId, value) {
+    return wcMutate(
+      `/wp-json/wc/v3/settings/${groupId}/${optionId}`,
+      { value },
+      "PUT"
+    );
+  }
+  return {
+    getSettingGroups,
+    getSettingOptions,
+    getSettingOption,
+    updateSettingOption
+  };
+}
+
+// src/integrations/restApi/woocommerce/reports/queries.ts
+function createReportsQueries(fetcher) {
+  const { wcFetchGraceful } = fetcher;
+  async function getSalesReport(params) {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/reports/sales",
+      [],
+      params,
+      ["woocommerce", "reports", "sales"]
+    );
+  }
+  async function getTopSellers(params) {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/reports/top_sellers",
+      [],
+      params,
+      ["woocommerce", "reports", "top_sellers"]
+    );
+  }
+  async function getOrdersTotals() {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/reports/orders/totals",
+      [],
+      void 0,
+      ["woocommerce", "reports", "orders_totals"]
+    );
+  }
+  async function getProductsTotals() {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/reports/products/totals",
+      [],
+      void 0,
+      ["woocommerce", "reports", "products_totals"]
+    );
+  }
+  async function getCustomersTotals() {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/reports/customers/totals",
+      [],
+      void 0,
+      ["woocommerce", "reports", "customers_totals"]
+    );
+  }
+  async function getCouponsTotals() {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/reports/coupons/totals",
+      [],
+      void 0,
+      ["woocommerce", "reports", "coupons_totals"]
+    );
+  }
+  async function getReviewsTotals() {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/reports/reviews/totals",
+      [],
+      void 0,
+      ["woocommerce", "reports", "reviews_totals"]
+    );
+  }
+  return {
+    getSalesReport,
+    getTopSellers,
+    getOrdersTotals,
+    getProductsTotals,
+    getCustomersTotals,
+    getCouponsTotals,
+    getReviewsTotals
+  };
+}
+
+// src/integrations/restApi/woocommerce/data/queries.ts
+function createDataQueries(fetcher) {
+  const { wcFetch, wcFetchGraceful, wcMutate } = fetcher;
+  async function getCurrencies() {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/data/currencies",
+      [],
+      void 0,
+      ["woocommerce", "data", "currencies"]
+    );
+  }
+  async function getCurrentCurrency() {
+    return wcFetch(
+      "/wp-json/wc/v3/data/currencies/current",
+      void 0,
+      ["woocommerce", "data", "currency_current"]
+    );
+  }
+  async function getCurrencyByCode(code) {
+    return wcFetch(
+      `/wp-json/wc/v3/data/currencies/${code.toUpperCase()}`,
+      void 0,
+      ["woocommerce", "data", `currency-${code}`]
+    );
+  }
+  async function getContinents() {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/data/continents",
+      [],
+      void 0,
+      ["woocommerce", "data", "continents"]
+    );
+  }
+  async function getContinentByCode(code) {
+    return wcFetch(
+      `/wp-json/wc/v3/data/continents/${code.toUpperCase()}`,
+      void 0,
+      ["woocommerce", "data", `continent-${code}`]
+    );
+  }
+  async function getCountries() {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/data/countries",
+      [],
+      void 0,
+      ["woocommerce", "data", "countries"]
+    );
+  }
+  async function getCountryByCode(code) {
+    return wcFetch(
+      `/wp-json/wc/v3/data/countries/${code.toUpperCase()}`,
+      void 0,
+      ["woocommerce", "data", `country-${code}`]
+    );
+  }
+  async function getTimeZones() {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/data/time_zones",
+      {},
+      void 0,
+      ["woocommerce", "data", "time_zones"]
+    );
+  }
+  async function getSystemStatus() {
+    return wcFetch(
+      "/wp-json/wc/v3/system_status",
+      void 0,
+      ["woocommerce", "system_status"]
+    );
+  }
+  async function getSystemStatusTools() {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/system_status/tools",
+      [],
+      void 0,
+      ["woocommerce", "system_status_tools"]
+    );
+  }
+  async function runSystemStatusTool(toolId) {
+    return wcMutate(
+      `/wp-json/wc/v3/system_status/tools/${toolId}`,
+      {},
+      "PUT"
+    );
+  }
+  return {
+    getCurrencies,
+    getCurrentCurrency,
+    getCurrencyByCode,
+    getContinents,
+    getContinentByCode,
+    getCountries,
+    getCountryByCode,
+    getTimeZones,
+    getSystemStatus,
+    getSystemStatusTools,
+    runSystemStatusTool
+  };
+}
+
 // src/integrations/restApi/woocommerce/index.ts
 function createWooCommerceClient(config) {
   const fetcher = createWooCommerceFetcher(config);
@@ -1222,16 +2083,29 @@ function createWooCommerceClient(config) {
     ...createTagsQueries2(fetcher),
     ...createTagsMutations2(fetcher),
     ...createOrdersQueries(fetcher),
+    ...createOrderNotesQueries(fetcher),
+    ...createOrderRefundsQueries(fetcher),
+    ...createProductAttributesQueries(fetcher),
+    ...createProductReviewsQueries(fetcher),
+    ...createShippingClassesQueries(fetcher),
+    ...createTaxesQueries(fetcher),
+    ...createShippingQueries(fetcher),
+    ...createWebhooksQueries(fetcher),
+    ...createSettingsQueries(fetcher),
+    ...createReportsQueries(fetcher),
+    ...createDataQueries(fetcher),
     ...createCouponsQueries(fetcher),
     ...createCouponsMutations(fetcher),
-    ...createCustomersQueries(fetcher)
+    ...createCustomersQueries(fetcher),
+    ...createPaymentGatewaysQueries(fetcher)
   };
 }
 
 // src/integrations/wpGraphQL/client/types.ts
 var WPGraphQLError = class extends Error {
-  constructor(message, status, endpoint, gqlErrors) {
+  constructor(code, status, endpoint, message, gqlErrors) {
     super(message);
+    __publicField(this, "code", code);
     __publicField(this, "status", status);
     __publicField(this, "endpoint", endpoint);
     __publicField(this, "gqlErrors", gqlErrors);
@@ -1256,22 +2130,29 @@ function createWPGraphQLFetcher(config) {
     });
     if (!response.ok) {
       throw new WPGraphQLError(
-        `WPGraphQL request failed: ${response.statusText}`,
+        ErrorCode.GQL_REQUEST_FAILED,
         response.status,
-        url
+        url,
+        resolveMessage(ErrorCode.GQL_REQUEST_FAILED, config.errorMessages)
       );
     }
     const parsed = await response.json();
     if (parsed.errors && parsed.errors.length > 0) {
       throw new WPGraphQLError(
-        parsed.errors[0].message,
+        ErrorCode.GQL_ERRORS_IN_RESPONSE,
         200,
         url,
+        resolveMessage(ErrorCode.GQL_ERRORS_IN_RESPONSE, config.errorMessages),
         parsed.errors
       );
     }
     if (parsed.data === void 0) {
-      throw new WPGraphQLError("No data returned from WPGraphQL", 200, url);
+      throw new WPGraphQLError(
+        ErrorCode.GQL_NO_DATA,
+        200,
+        url,
+        resolveMessage(ErrorCode.GQL_NO_DATA, config.errorMessages)
+      );
     }
     return parsed.data;
   }
@@ -1299,22 +2180,29 @@ function createWPGraphQLFetcher(config) {
     });
     if (!response.ok) {
       throw new WPGraphQLError(
-        `WPGraphQL mutation failed: ${response.statusText}`,
+        ErrorCode.GQL_REQUEST_FAILED,
         response.status,
-        url
+        url,
+        resolveMessage(ErrorCode.GQL_REQUEST_FAILED, config.errorMessages)
       );
     }
     const parsed = await response.json();
     if (parsed.errors && parsed.errors.length > 0) {
       throw new WPGraphQLError(
-        parsed.errors[0].message,
+        ErrorCode.GQL_ERRORS_IN_RESPONSE,
         200,
         url,
+        resolveMessage(ErrorCode.GQL_ERRORS_IN_RESPONSE, config.errorMessages),
         parsed.errors
       );
     }
     if (parsed.data === void 0) {
-      throw new WPGraphQLError("No data returned from WPGraphQL mutation", 200, url);
+      throw new WPGraphQLError(
+        ErrorCode.GQL_NO_DATA,
+        200,
+        url,
+        resolveMessage(ErrorCode.GQL_NO_DATA, config.errorMessages)
+      );
     }
     return parsed.data;
   }
@@ -3297,14 +4185,20 @@ function createApplicationPasswordToken(username, appPassword) {
 
 // src/auth/types.ts
 var AuthenticationError = class extends Error {
-  constructor(message, status) {
-    super(message);
+  constructor(code, status, message, detail) {
+    super(detail ? `${message}: ${detail}` : message);
+    __publicField(this, "code", code);
     __publicField(this, "status", status);
     this.name = "AuthenticationError";
   }
 };
 
 // src/auth/jwt.ts
+function resolveAuthErrorCode(status) {
+  if (status === 401) return ErrorCode.AUTH_CREDENTIALS_INVALID;
+  if (status === 403) return ErrorCode.AUTH_TOKEN_INVALID;
+  return ErrorCode.AUTH_JWT_FAILED;
+}
 async function authenticateJwt(config, credentials) {
   const url = `${resolveBaseUrl(config)}/wp-json/jwt-auth/v1/token`;
   const response = await fetch(url, {
@@ -3314,9 +4208,12 @@ async function authenticateJwt(config, credentials) {
     cache: "no-store"
   });
   if (!response.ok) {
+    const code = resolveAuthErrorCode(response.status);
     throw new AuthenticationError(
-      `JWT authentication failed: ${response.statusText}`,
-      response.status
+      code,
+      response.status,
+      resolveMessage(code, config.errorMessages),
+      response.statusText
     );
   }
   return response.json();
@@ -3332,7 +4229,10 @@ async function validateJwtToken(config, token) {
 }
 
 exports.AuthenticationError = AuthenticationError;
+exports.ErrorCode = ErrorCode;
 exports.WPGraphQLError = WPGraphQLError;
+exports.WooCommerceError = WooCommerceError;
+exports.WordPressAPIError = WordPressAPIError;
 exports.authenticateJwt = authenticateJwt;
 exports.buildACFFragment = buildACFFragment;
 exports.buildPageWithACFQuery = buildPageWithACFQuery;
@@ -3362,8 +4262,11 @@ exports.createWooCommerceFetcher = createWooCommerceFetcher;
 exports.createWordPressClient = createWordPressClient;
 exports.createWordPressMutationsClient = createWordPressMutationsClient;
 exports.createYoastQueries = createYoastQueries;
+exports.defaultMessages = defaultMessages;
+exports.defaultMessagesPl = defaultMessagesPl;
 exports.extractOmnibusData = extractOmnibusData;
 exports.resolveBaseUrl = resolveBaseUrl;
+exports.resolveMessage = resolveMessage;
 exports.validateJwtToken = validateJwtToken;
 exports.withOmnibus = withOmnibus;
 exports.withOmnibusVariation = withOmnibusVariation;