@szymonpiatek/nextwordpress 0.0.10 → 0.0.12

package/dist/server/index.cjs

@@ -0,0 +1,4308 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/shared/url.ts
+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(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";
+  }
+};
+
+// src/integrations/restApi/core/client/url.ts
+function buildUrl(config, path, query) {
+  const base = resolveBaseUrl(config);
+  if (!query) return `${base}${path}`;
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== void 0 && value !== null) {
+      params.set(key, String(value));
+    }
+  }
+  const qs = params.toString();
+  return qs ? `${base}${path}?${qs}` : `${base}${path}`;
+}
+
+// src/integrations/restApi/core/client/fetcher.ts
+var USER_AGENT = "NextWordpress Client";
+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, {
+      headers: { "User-Agent": USER_AGENT },
+      next: { tags, revalidate: cacheTtl }
+    });
+    return await res.json();
+  }
+  async function wpFetchGraceful(path, fallback, query, tags = ["wordpress"]) {
+    try {
+      return await wpFetch(path, query, tags);
+    } catch {
+      console.warn(`WordPress fetch failed for ${path}`);
+      return fallback;
+    }
+  }
+  async function wpFetchPaginated(path, query, tags = ["wordpress"]) {
+    const url = buildUrl(config, path, query);
+    const res = await doFetch(url, {
+      headers: { "User-Agent": USER_AGENT },
+      next: { tags, revalidate: cacheTtl }
+    });
+    return {
+      data: await res.json(),
+      headers: {
+        total: parseInt(res.headers.get("X-WP-Total") ?? "0", 10),
+        totalPages: parseInt(res.headers.get("X-WP-TotalPages") ?? "0", 10)
+      }
+    };
+  }
+  async function wpFetchPaginatedGraceful(path, query, tags = ["wordpress"]) {
+    const empty = { data: [], headers: { total: 0, totalPages: 0 } };
+    try {
+      return await wpFetchPaginated(path, query, tags);
+    } catch {
+      console.warn(`WordPress paginated fetch failed for ${path}`);
+      return empty;
+    }
+  }
+  async function wpMutate(path, body, method = "POST", authToken) {
+    const url = buildUrl(config, path);
+    const headers = {
+      "Content-Type": "application/json",
+      "User-Agent": USER_AGENT
+    };
+    if (authToken) {
+      headers["Authorization"] = authToken.startsWith("Basic ") || authToken.startsWith("Bearer ") ? authToken : `Bearer ${authToken}`;
+    }
+    const res = await doFetch(url, {
+      method,
+      headers,
+      body: JSON.stringify(body),
+      cache: "no-store"
+    });
+    return await res.json();
+  }
+  async function wpUpload(path, file, filename, mimeType, authToken) {
+    const url = buildUrl(config, path);
+    const res = await doFetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Disposition": `attachment; filename="${filename}"`,
+        "Content-Type": mimeType,
+        "User-Agent": USER_AGENT,
+        "Authorization": authToken.startsWith("Basic ") || authToken.startsWith("Bearer ") ? authToken : `Bearer ${authToken}`
+      },
+      body: file,
+      cache: "no-store"
+    });
+    return await res.json();
+  }
+  return { wpFetch, wpFetchGraceful, wpFetchPaginated, wpFetchPaginatedGraceful, wpMutate, wpUpload };
+}
+
+// src/integrations/restApi/core/contactForm7/queries.ts
+function createCF7Queries(config) {
+  async function submitForm(formId, data) {
+    const url = buildUrl(config, `/wp-json/contact-form-7/v1/contact-forms/${formId}/feedback`);
+    const body = new FormData();
+    for (const [key, value] of Object.entries(data)) {
+      body.append(key, value);
+    }
+    const res = await fetch(url, { method: "POST", body, cache: "no-store" });
+    return res.json();
+  }
+  return { submitForm };
+}
+
+// src/integrations/restApi/core/mutations/posts/mutations.ts
+function createPostsMutations(fetcher) {
+  const { wpMutate } = fetcher;
+  async function createPost(input, authToken) {
+    return wpMutate("/wp-json/wp/v2/posts", input, "POST", authToken);
+  }
+  async function updatePost(id, input, authToken) {
+    return wpMutate(`/wp-json/wp/v2/posts/${id}`, input, "PATCH", authToken);
+  }
+  async function deletePost(id, authToken, force = false) {
+    return wpMutate(
+      `/wp-json/wp/v2/posts/${id}`,
+      { force },
+      "DELETE",
+      authToken
+    );
+  }
+  return { createPost, updatePost, deletePost };
+}
+
+// src/integrations/restApi/core/mutations/comments/mutations.ts
+function createCommentsMutations(fetcher) {
+  const { wpMutate } = fetcher;
+  async function createComment(input, authToken) {
+    return wpMutate("/wp-json/wp/v2/comments", input, "POST", authToken);
+  }
+  async function updateComment(id, input, authToken) {
+    return wpMutate(`/wp-json/wp/v2/comments/${id}`, input, "PATCH", authToken);
+  }
+  async function deleteComment(id, authToken, force = false) {
+    return wpMutate(
+      `/wp-json/wp/v2/comments/${id}`,
+      { force },
+      "DELETE",
+      authToken
+    );
+  }
+  return { createComment, updateComment, deleteComment };
+}
+
+// src/integrations/restApi/core/mutations/pages/mutations.ts
+function createPagesMutations(fetcher) {
+  const { wpMutate } = fetcher;
+  async function createPage(input, authToken) {
+    return wpMutate("/wp-json/wp/v2/pages", input, "POST", authToken);
+  }
+  async function updatePage(id, input, authToken) {
+    return wpMutate(`/wp-json/wp/v2/pages/${id}`, input, "PATCH", authToken);
+  }
+  async function deletePage(id, authToken, force = false) {
+    return wpMutate(
+      `/wp-json/wp/v2/pages/${id}`,
+      { force },
+      "DELETE",
+      authToken
+    );
+  }
+  return { createPage, updatePage, deletePage };
+}
+
+// src/integrations/restApi/core/mutations/categories/mutations.ts
+function createCategoriesMutations(fetcher) {
+  const { wpMutate } = fetcher;
+  async function createCategory(input, authToken) {
+    return wpMutate("/wp-json/wp/v2/categories", input, "POST", authToken);
+  }
+  async function updateCategory(id, input, authToken) {
+    return wpMutate(`/wp-json/wp/v2/categories/${id}`, input, "PATCH", authToken);
+  }
+  async function deleteCategory(id, authToken, force = false) {
+    return wpMutate(
+      `/wp-json/wp/v2/categories/${id}`,
+      { force },
+      "DELETE",
+      authToken
+    );
+  }
+  return { createCategory, updateCategory, deleteCategory };
+}
+
+// src/integrations/restApi/core/mutations/tags/mutations.ts
+function createTagsMutations(fetcher) {
+  const { wpMutate } = fetcher;
+  async function createTag(input, authToken) {
+    return wpMutate("/wp-json/wp/v2/tags", input, "POST", authToken);
+  }
+  async function updateTag(id, input, authToken) {
+    return wpMutate(`/wp-json/wp/v2/tags/${id}`, input, "PATCH", authToken);
+  }
+  async function deleteTag(id, authToken, force = false) {
+    return wpMutate(
+      `/wp-json/wp/v2/tags/${id}`,
+      { force },
+      "DELETE",
+      authToken
+    );
+  }
+  return { createTag, updateTag, deleteTag };
+}
+
+// src/integrations/restApi/core/mutations/authors/mutations.ts
+function createAuthorsMutations(fetcher) {
+  const { wpMutate } = fetcher;
+  async function createAuthor(input, authToken) {
+    return wpMutate("/wp-json/wp/v2/users", input, "POST", authToken);
+  }
+  async function updateAuthor(id, input, authToken) {
+    return wpMutate(`/wp-json/wp/v2/users/${id}`, input, "PATCH", authToken);
+  }
+  async function deleteAuthor(id, authToken, reassign) {
+    return wpMutate(
+      `/wp-json/wp/v2/users/${id}`,
+      { force: true, reassign },
+      "DELETE",
+      authToken
+    );
+  }
+  return { createAuthor, updateAuthor, deleteAuthor };
+}
+
+// src/integrations/restApi/core/mutations/menus/mutations.ts
+function createMenusMutations(fetcher) {
+  const { wpMutate } = fetcher;
+  async function createMenu(input, authToken) {
+    return wpMutate("/wp-json/wp/v2/menus", input, "POST", authToken);
+  }
+  async function updateMenu(id, input, authToken) {
+    return wpMutate(`/wp-json/wp/v2/menus/${id}`, input, "PATCH", authToken);
+  }
+  async function deleteMenu(id, authToken) {
+    return wpMutate(
+      `/wp-json/wp/v2/menus/${id}`,
+      {},
+      "DELETE",
+      authToken
+    );
+  }
+  async function createMenuItem(input, authToken) {
+    return wpMutate("/wp-json/wp/v2/menu-items", input, "POST", authToken);
+  }
+  async function updateMenuItem(id, input, authToken) {
+    return wpMutate(`/wp-json/wp/v2/menu-items/${id}`, input, "PATCH", authToken);
+  }
+  async function deleteMenuItem(id, authToken, force = false) {
+    return wpMutate(
+      `/wp-json/wp/v2/menu-items/${id}`,
+      { force },
+      "DELETE",
+      authToken
+    );
+  }
+  return { createMenu, updateMenu, deleteMenu, createMenuItem, updateMenuItem, deleteMenuItem };
+}
+
+// src/integrations/restApi/core/mutations/media/mutations.ts
+function createMediaMutations(fetcher) {
+  const { wpMutate, wpUpload } = fetcher;
+  async function uploadMedia(input, authToken) {
+    const media = await wpUpload(
+      "/wp-json/wp/v2/media",
+      input.file,
+      input.filename,
+      input.mimeType,
+      authToken
+    );
+    if (input.title || input.caption || input.alt_text) {
+      return wpMutate(
+        `/wp-json/wp/v2/media/${media.id}`,
+        {
+          ...input.title && { title: input.title },
+          ...input.caption && { caption: input.caption },
+          ...input.alt_text && { alt_text: input.alt_text }
+        },
+        "PATCH",
+        authToken
+      );
+    }
+    return media;
+  }
+  async function updateMedia(id, input, authToken) {
+    return wpMutate(`/wp-json/wp/v2/media/${id}`, input, "PATCH", authToken);
+  }
+  async function deleteMedia(id, authToken, force = true) {
+    return wpMutate(
+      `/wp-json/wp/v2/media/${id}`,
+      { force },
+      "DELETE",
+      authToken
+    );
+  }
+  return { uploadMedia, updateMedia, deleteMedia };
+}
+
+// src/integrations/restApi/core/mutations/index.ts
+function createWordPressMutationsClient(config) {
+  const fetcher = createFetcher(config);
+  return {
+    ...createPostsMutations(fetcher),
+    ...createCommentsMutations(fetcher),
+    ...createPagesMutations(fetcher),
+    ...createCategoriesMutations(fetcher),
+    ...createTagsMutations(fetcher),
+    ...createAuthorsMutations(fetcher),
+    ...createMenusMutations(fetcher),
+    ...createMediaMutations(fetcher)
+  };
+}
+
+// src/integrations/restApi/core/posts/queries.ts
+function createPostsQueries(fetcher) {
+  const { wpFetch, wpFetchGraceful, wpFetchPaginated, wpFetchPaginatedGraceful } = fetcher;
+  async function getPostsPaginated(page = 1, perPage = 9, filterParams) {
+    const query = { _embed: true, per_page: perPage, page };
+    const cacheTags = ["wordpress", "posts", `posts-page-${page}`];
+    if (filterParams?.search) {
+      query.search = filterParams.search;
+      cacheTags.push("posts-search");
+    }
+    if (filterParams?.author) {
+      query.author = filterParams.author;
+      cacheTags.push(`posts-author-${filterParams.author}`);
+    }
+    if (filterParams?.tag) {
+      query.tags = filterParams.tag;
+      cacheTags.push(`posts-tag-${filterParams.tag}`);
+    }
+    if (filterParams?.category) {
+      query.categories = filterParams.category;
+      cacheTags.push(`posts-category-${filterParams.category}`);
+    }
+    return wpFetchPaginatedGraceful("/wp-json/wp/v2/posts", query, cacheTags);
+  }
+  async function getRecentPosts(filterParams) {
+    const query = { _embed: true, per_page: 100 };
+    if (filterParams?.search) query.search = filterParams.search;
+    if (filterParams?.author) query.author = filterParams.author;
+    if (filterParams?.tag) query.tags = filterParams.tag;
+    if (filterParams?.category) query.categories = filterParams.category;
+    return wpFetchGraceful("/wp-json/wp/v2/posts", [], query, ["wordpress", "posts"]);
+  }
+  async function getPostById(id) {
+    return wpFetch(`/wp-json/wp/v2/posts/${id}`);
+  }
+  async function getPostBySlug(slug) {
+    const posts = await wpFetchGraceful("/wp-json/wp/v2/posts", [], { slug, _embed: true });
+    return posts[0];
+  }
+  async function getPostsByCategory(categoryId) {
+    return wpFetch("/wp-json/wp/v2/posts", { categories: categoryId });
+  }
+  async function getPostsByTag(tagId) {
+    return wpFetch("/wp-json/wp/v2/posts", { tags: tagId });
+  }
+  async function getPostsByAuthor(authorId) {
+    return wpFetch("/wp-json/wp/v2/posts", { author: authorId });
+  }
+  async function getPostsByCategoryPaginated(categoryId, page = 1, perPage = 9) {
+    return wpFetchPaginatedGraceful("/wp-json/wp/v2/posts", {
+      _embed: true,
+      per_page: perPage,
+      page,
+      categories: categoryId
+    });
+  }
+  async function getPostsByTagPaginated(tagId, page = 1, perPage = 9) {
+    return wpFetchPaginatedGraceful("/wp-json/wp/v2/posts", {
+      _embed: true,
+      per_page: perPage,
+      page,
+      tags: tagId
+    });
+  }
+  async function getPostsByAuthorPaginated(authorId, page = 1, perPage = 9) {
+    return wpFetchPaginatedGraceful("/wp-json/wp/v2/posts", {
+      _embed: true,
+      per_page: perPage,
+      page,
+      author: authorId
+    });
+  }
+  async function getAllPostSlugs() {
+    try {
+      const allSlugs = [];
+      let page = 1;
+      let hasMore = true;
+      while (hasMore) {
+        const response = await wpFetchPaginated(
+          "/wp-json/wp/v2/posts",
+          { per_page: 100, page, _fields: "slug" }
+        );
+        allSlugs.push(...response.data.map((post) => ({ slug: post.slug })));
+        hasMore = page < response.headers.totalPages;
+        page++;
+      }
+      return allSlugs;
+    } catch {
+      console.warn("WordPress unavailable, skipping static generation for posts");
+      return [];
+    }
+  }
+  async function getAllPostsForSitemap() {
+    try {
+      const allPosts = [];
+      let page = 1;
+      let hasMore = true;
+      while (hasMore) {
+        const response = await wpFetchPaginated(
+          "/wp-json/wp/v2/posts",
+          { per_page: 100, page, _fields: "slug,modified" }
+        );
+        allPosts.push(...response.data.map((post) => ({ slug: post.slug, modified: post.modified })));
+        hasMore = page < response.headers.totalPages;
+        page++;
+      }
+      return allPosts;
+    } catch {
+      console.warn("WordPress unavailable, skipping sitemap generation");
+      return [];
+    }
+  }
+  return {
+    getPostsPaginated,
+    getRecentPosts,
+    getPostById,
+    getPostBySlug,
+    getPostsByCategory,
+    getPostsByTag,
+    getPostsByAuthor,
+    getPostsByCategoryPaginated,
+    getPostsByTagPaginated,
+    getPostsByAuthorPaginated,
+    getAllPostSlugs,
+    getAllPostsForSitemap
+  };
+}
+
+// src/integrations/restApi/core/categories/queries.ts
+function createCategoriesQueries(fetcher) {
+  const { wpFetch, wpFetchGraceful } = fetcher;
+  async function getAllCategories() {
+    return wpFetchGraceful("/wp-json/wp/v2/categories", [], { per_page: 100 }, [
+      "wordpress",
+      "categories"
+    ]);
+  }
+  async function getCategoryById(id) {
+    return wpFetch(`/wp-json/wp/v2/categories/${id}`);
+  }
+  async function getCategoryBySlug(slug) {
+    const categories = await wpFetch("/wp-json/wp/v2/categories", { slug });
+    return categories[0];
+  }
+  async function searchCategories(query) {
+    return wpFetchGraceful("/wp-json/wp/v2/categories", [], {
+      search: query,
+      per_page: 100
+    });
+  }
+  return { getAllCategories, getCategoryById, getCategoryBySlug, searchCategories };
+}
+
+// src/integrations/restApi/core/tags/queries.ts
+function createTagsQueries(fetcher) {
+  const { wpFetch, wpFetchGraceful } = fetcher;
+  async function getAllTags() {
+    return wpFetchGraceful("/wp-json/wp/v2/tags", [], { per_page: 100 }, [
+      "wordpress",
+      "tags"
+    ]);
+  }
+  async function getTagById(id) {
+    return wpFetch(`/wp-json/wp/v2/tags/${id}`);
+  }
+  async function getTagBySlug(slug) {
+    const tags = await wpFetch("/wp-json/wp/v2/tags", { slug });
+    return tags[0];
+  }
+  async function getTagsByPost(postId) {
+    return wpFetch("/wp-json/wp/v2/tags", { post: postId });
+  }
+  async function searchTags(query) {
+    return wpFetchGraceful("/wp-json/wp/v2/tags", [], { search: query, per_page: 100 });
+  }
+  return { getAllTags, getTagById, getTagBySlug, getTagsByPost, searchTags };
+}
+
+// src/integrations/restApi/core/authors/queries.ts
+function createAuthorsQueries(fetcher) {
+  const { wpFetch, wpFetchGraceful } = fetcher;
+  async function getAllAuthors() {
+    return wpFetchGraceful("/wp-json/wp/v2/users", [], { per_page: 100 }, [
+      "wordpress",
+      "authors"
+    ]);
+  }
+  async function getAuthorById(id) {
+    return wpFetch(`/wp-json/wp/v2/users/${id}`);
+  }
+  async function getAuthorBySlug(slug) {
+    const users = await wpFetch("/wp-json/wp/v2/users", { slug });
+    return users[0];
+  }
+  async function searchAuthors(query) {
+    return wpFetchGraceful("/wp-json/wp/v2/users", [], { search: query, per_page: 100 });
+  }
+  return { getAllAuthors, getAuthorById, getAuthorBySlug, searchAuthors };
+}
+
+// src/integrations/restApi/core/media/queries.ts
+function createMediaQueries(fetcher) {
+  const { wpFetch } = fetcher;
+  async function getFeaturedMediaById(id) {
+    return wpFetch(`/wp-json/wp/v2/media/${id}`);
+  }
+  return { getFeaturedMediaById };
+}
+
+// src/integrations/restApi/core/pages/queries.ts
+function createPagesQueries(fetcher) {
+  const { wpFetch, wpFetchGraceful } = fetcher;
+  async function getAllPages() {
+    return wpFetchGraceful("/wp-json/wp/v2/pages", [], { per_page: 100 }, [
+      "wordpress",
+      "pages"
+    ]);
+  }
+  async function getPageById(id) {
+    return wpFetch(`/wp-json/wp/v2/pages/${id}`);
+  }
+  async function getPageBySlug(slug) {
+    const pages = await wpFetchGraceful("/wp-json/wp/v2/pages", [], { slug });
+    return pages[0];
+  }
+  return { getAllPages, getPageById, getPageBySlug };
+}
+
+// src/integrations/restApi/core/menus/queries.ts
+function createMenusQueries(fetcher) {
+  const { wpFetch, wpFetchGraceful } = fetcher;
+  async function getMenus() {
+    return wpFetchGraceful("/wp-json/wp/v2/menus", [], void 0, ["wordpress", "menus"]);
+  }
+  async function getMenuById(id) {
+    return wpFetch(`/wp-json/wp/v2/menus/${id}`, void 0, ["wordpress", "menus", `menu-${id}`]);
+  }
+  async function getMenuBySlug(slug) {
+    const menus = await wpFetchGraceful("/wp-json/wp/v2/menus", [], { slug }, ["wordpress", "menus"]);
+    return menus[0];
+  }
+  async function getMenuItemsByMenuId(menuId) {
+    return wpFetchGraceful(
+      "/wp-json/wp/v2/menu-items",
+      [],
+      { menus: menuId, per_page: 100, orderby: "menu_order", order: "asc" },
+      ["wordpress", "menus", `menu-items-${menuId}`]
+    );
+  }
+  async function getMenuLocations() {
+    return wpFetchGraceful(
+      "/wp-json/wp/v2/menu-locations",
+      {},
+      void 0,
+      ["wordpress", "menus", "menu-locations"]
+    );
+  }
+  async function getMenuByLocation(location) {
+    const locations = await getMenuLocations();
+    const loc = locations[location];
+    if (!loc || !loc.menu) return void 0;
+    const [menu, items] = await Promise.all([
+      getMenuById(loc.menu),
+      getMenuItemsByMenuId(loc.menu)
+    ]);
+    return { menu, items };
+  }
+  return {
+    getMenus,
+    getMenuById,
+    getMenuBySlug,
+    getMenuItemsByMenuId,
+    getMenuLocations,
+    getMenuByLocation
+  };
+}
+
+// src/integrations/restApi/core/comments/queries.ts
+function createCommentsQueries(fetcher) {
+  const { wpFetch, wpFetchGraceful, wpFetchPaginatedGraceful, wpMutate } = fetcher;
+  async function getCommentsByPostId(postId, page = 1, perPage = 10) {
+    return wpFetchPaginatedGraceful(
+      "/wp-json/wp/v2/comments",
+      { post: postId, per_page: perPage, page, status: "approve" },
+      ["wordpress", "comments", `comments-post-${postId}`]
+    );
+  }
+  async function getAllCommentsByPostId(postId) {
+    return wpFetchGraceful(
+      "/wp-json/wp/v2/comments",
+      [],
+      { post: postId, per_page: 100, status: "approve" },
+      ["wordpress", "comments", `comments-post-${postId}`]
+    );
+  }
+  async function getCommentById(id) {
+    return wpFetch(`/wp-json/wp/v2/comments/${id}`, void 0, [
+      "wordpress",
+      "comments",
+      `comment-${id}`
+    ]);
+  }
+  async function getCommentReplies(parentId) {
+    return wpFetchGraceful(
+      "/wp-json/wp/v2/comments",
+      [],
+      { parent: parentId, per_page: 100, status: "approve" },
+      ["wordpress", "comments", `comments-parent-${parentId}`]
+    );
+  }
+  async function createComment(input) {
+    return wpMutate("/wp-json/wp/v2/comments", input, "POST");
+  }
+  return {
+    getCommentsByPostId,
+    getAllCommentsByPostId,
+    getCommentById,
+    getCommentReplies,
+    createComment
+  };
+}
+
+// src/integrations/restApi/core/index.ts
+function createWordPressClient(config) {
+  const fetcher = createFetcher(config);
+  return {
+    ...createPostsQueries(fetcher),
+    ...createCategoriesQueries(fetcher),
+    ...createTagsQueries(fetcher),
+    ...createAuthorsQueries(fetcher),
+    ...createMediaQueries(fetcher),
+    ...createPagesQueries(fetcher),
+    ...createMenusQueries(fetcher),
+    ...createCommentsQueries(fetcher)
+  };
+}
+
+// src/integrations/restApi/woocommerce/omnibus/queries.ts
+var META_KEY_LOWEST_PRICE = "wpo_lowest_price";
+var META_KEY_PRICE_HISTORY = "_alg_wc_price_history";
+function extractMetaValue(meta_data, key) {
+  return meta_data.find((m) => m.key === key)?.value;
+}
+function parseHistory(raw) {
+  if (!raw || typeof raw !== "object") return [];
+  if (Array.isArray(raw)) {
+    return raw.filter((e) => e && typeof e.price === "string" && typeof e.date === "string").map((e) => ({ price: e.price, date: e.date }));
+  }
+  return Object.entries(raw).map(([date, price]) => ({ date, price })).sort((a, b) => a.date.localeCompare(b.date));
+}
+function extractOmnibusData(meta_data) {
+  const lowestPrice = extractMetaValue(meta_data, META_KEY_LOWEST_PRICE) ?? null;
+  const rawHistory = extractMetaValue(meta_data, META_KEY_PRICE_HISTORY);
+  const priceHistory = parseHistory(rawHistory);
+  return { lowestPrice, priceHistory };
+}
+function withOmnibus(product) {
+  return { ...product, omnibus: extractOmnibusData(product.meta_data) };
+}
+function withOmnibusVariation(variation) {
+  return {
+    ...variation,
+    omnibus: extractOmnibusData(variation.meta_data ?? [])
+  };
+}
+
+// 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;
+function toQueryString(params) {
+  const pairs = [];
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0 || value === null) continue;
+    pairs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+  }
+  return pairs.join("&");
+}
+function createWooCommerceFetcher(config) {
+  const cacheTTL = config.cacheTTL ?? DEFAULT_CACHE_TTL;
+  function withAuth(query) {
+    return { ...query, consumer_key: config.consumerKey, consumer_secret: config.consumerSecret };
+  }
+  function buildUrl2(path, 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);
+    const isMutation = options?.method && options.method !== "GET";
+    const noStore = options?.cache === "no-store";
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        "User-Agent": USER_AGENT2,
+        "Content-Type": "application/json",
+        ...options?.headers
+      },
+      next: isMutation || noStore ? void 0 : { tags, revalidate: cacheTTL }
+    });
+    if (!response.ok) {
+      await throwWooError(response, url);
+    }
+    return response.json();
+  }
+  async function wcFetchGraceful(path, fallback, query, tags = ["woocommerce"]) {
+    try {
+      return await wcFetch(path, query, tags);
+    } catch (err) {
+      console.warn(`WooCommerce fetch failed for ${path}`, err);
+      return fallback;
+    }
+  }
+  async function wcFetchPaginated(path, query, tags = ["woocommerce"]) {
+    const url = buildUrl2(path, query);
+    const response = await fetch(url, {
+      headers: { "User-Agent": USER_AGENT2 },
+      next: { tags, revalidate: cacheTTL }
+    });
+    if (!response.ok) {
+      await throwWooError(response, url);
+    }
+    return {
+      data: await response.json(),
+      headers: {
+        total: parseInt(response.headers.get("X-WP-Total") ?? "0", 10),
+        totalPages: parseInt(response.headers.get("X-WP-TotalPages") ?? "0", 10)
+      }
+    };
+  }
+  async function wcFetchPaginatedGraceful(path, query, tags = ["woocommerce"]) {
+    const empty = { data: [], headers: { total: 0, totalPages: 0 } };
+    try {
+      return await wcFetchPaginated(path, query, tags);
+    } catch (err) {
+      console.warn(`WooCommerce paginated fetch failed for ${path}`, err);
+      return empty;
+    }
+  }
+  async function wcMutate(path, body, method = "POST") {
+    return wcFetch(path, void 0, ["woocommerce"], {
+      method,
+      body: JSON.stringify(body)
+    });
+  }
+  return { wcFetch, wcFetchGraceful, wcFetchPaginated, wcFetchPaginatedGraceful, wcMutate };
+}
+
+// src/integrations/restApi/woocommerce/products/queries.ts
+function buildProductQuery(base, filterParams) {
+  const query = { ...base };
+  if (!filterParams) return query;
+  if (filterParams.category !== void 0) query.category = filterParams.category;
+  if (filterParams.tag !== void 0) query.tag = filterParams.tag;
+  if (filterParams.featured !== void 0) query.featured = filterParams.featured;
+  if (filterParams.on_sale !== void 0) query.on_sale = filterParams.on_sale;
+  if (filterParams.min_price !== void 0) query.min_price = filterParams.min_price;
+  if (filterParams.max_price !== void 0) query.max_price = filterParams.max_price;
+  if (filterParams.search !== void 0) query.search = filterParams.search;
+  if (filterParams.orderby !== void 0) query.orderby = filterParams.orderby;
+  if (filterParams.order !== void 0) query.order = filterParams.order;
+  if (filterParams.stock_status !== void 0) query.stock_status = filterParams.stock_status;
+  if (filterParams.type !== void 0) query.type = filterParams.type;
+  return query;
+}
+function createProductsQueries(fetcher) {
+  const { wcFetch, wcFetchGraceful, wcFetchPaginated, wcFetchPaginatedGraceful } = fetcher;
+  async function getProducts(filterParams) {
+    const query = buildProductQuery({ per_page: 100, status: "publish" }, filterParams);
+    return wcFetchGraceful("/wp-json/wc/v3/products", [], query, [
+      "woocommerce",
+      "products"
+    ]);
+  }
+  async function getProductsPaginated(page = 1, perPage = 12, filterParams) {
+    const query = buildProductQuery({ per_page: perPage, page, status: "publish" }, filterParams);
+    const cacheTags = ["woocommerce", "products", `products-page-${page}`];
+    if (filterParams?.category) cacheTags.push(`products-category-${filterParams.category}`);
+    if (filterParams?.tag) cacheTags.push(`products-tag-${filterParams.tag}`);
+    if (filterParams?.search) cacheTags.push("products-search");
+    return wcFetchPaginatedGraceful("/wp-json/wc/v3/products", query, cacheTags);
+  }
+  async function getProductById(id) {
+    return wcFetch(`/wp-json/wc/v3/products/${id}`, void 0, [
+      "woocommerce",
+      "products",
+      `product-${id}`
+    ]);
+  }
+  async function getProductBySlug(slug) {
+    const products = await wcFetchGraceful(
+      "/wp-json/wc/v3/products",
+      [],
+      { slug },
+      ["woocommerce", "products", `product-slug-${slug}`]
+    );
+    return products[0];
+  }
+  async function getFeaturedProducts(limit = 10) {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/products",
+      [],
+      { featured: true, per_page: limit, status: "publish" },
+      ["woocommerce", "products", "featured"]
+    );
+  }
+  async function getOnSaleProducts(limit = 10) {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/products",
+      [],
+      { on_sale: true, per_page: limit, status: "publish" },
+      ["woocommerce", "products", "on-sale"]
+    );
+  }
+  async function getRelatedProducts(productId) {
+    const product = await getProductById(productId);
+    if (!product.related_ids.length) return [];
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/products",
+      [],
+      { include: product.related_ids.join(","), per_page: 10, status: "publish" },
+      ["woocommerce", "products", `related-${productId}`]
+    );
+  }
+  async function getAllProductSlugs() {
+    try {
+      const allSlugs = [];
+      let page = 1;
+      let hasMore = true;
+      while (hasMore) {
+        const response = await wcFetchPaginated("/wp-json/wc/v3/products", {
+          per_page: 100,
+          page,
+          status: "publish",
+          _fields: "slug"
+        });
+        allSlugs.push(...response.data.map((p) => ({ slug: p.slug })));
+        hasMore = page < response.headers.totalPages;
+        page++;
+      }
+      return allSlugs;
+    } catch {
+      console.warn("WooCommerce unavailable, skipping static generation for products");
+      return [];
+    }
+  }
+  async function getProductVariations(productId) {
+    return wcFetchGraceful(
+      `/wp-json/wc/v3/products/${productId}/variations`,
+      [],
+      { per_page: 100 },
+      ["woocommerce", "products", `product-${productId}`, "variations"]
+    );
+  }
+  async function getProductVariationById(productId, variationId) {
+    return wcFetch(
+      `/wp-json/wc/v3/products/${productId}/variations/${variationId}`,
+      void 0,
+      ["woocommerce", "products", `product-${productId}`, `variation-${variationId}`]
+    );
+  }
+  return {
+    getProducts,
+    getProductsPaginated,
+    getProductById,
+    getProductBySlug,
+    getFeaturedProducts,
+    getOnSaleProducts,
+    getRelatedProducts,
+    getAllProductSlugs,
+    getProductVariations,
+    getProductVariationById
+  };
+}
+
+// src/integrations/restApi/woocommerce/products/mutations.ts
+function createProductsMutations(fetcher) {
+  const { wcMutate } = fetcher;
+  async function createProduct(input) {
+    return wcMutate("/wp-json/wc/v3/products", input, "POST");
+  }
+  async function updateProduct(id, input) {
+    return wcMutate(`/wp-json/wc/v3/products/${id}`, input, "PUT");
+  }
+  async function deleteProduct(id, force = true) {
+    return wcMutate(
+      `/wp-json/wc/v3/products/${id}`,
+      { force },
+      "DELETE"
+    );
+  }
+  return { createProduct, updateProduct, deleteProduct };
+}
+
+// src/integrations/restApi/woocommerce/categories/queries.ts
+function createCategoriesQueries2(fetcher) {
+  const { wcFetch, wcFetchGraceful } = fetcher;
+  async function getAllProductCategories() {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/products/categories",
+      [],
+      { per_page: 100, hide_empty: false },
+      ["woocommerce", "product-categories"]
+    );
+  }
+  async function getProductCategoryById(id) {
+    return wcFetch(
+      `/wp-json/wc/v3/products/categories/${id}`,
+      void 0,
+      ["woocommerce", "product-categories", `product-category-${id}`]
+    );
+  }
+  async function getProductCategoryBySlug(slug) {
+    const categories = await wcFetchGraceful(
+      "/wp-json/wc/v3/products/categories",
+      [],
+      { slug },
+      ["woocommerce", "product-categories", `product-category-slug-${slug}`]
+    );
+    return categories[0];
+  }
+  async function getProductsByCategory(categoryId, limit = 100) {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/products",
+      [],
+      { category: categoryId, per_page: limit, status: "publish" },
+      ["woocommerce", "products", `products-category-${categoryId}`]
+    );
+  }
+  async function getProductsByCategorySlug(categorySlug) {
+    const category = await getProductCategoryBySlug(categorySlug);
+    if (!category) return [];
+    return getProductsByCategory(category.id);
+  }
+  return {
+    getAllProductCategories,
+    getProductCategoryById,
+    getProductCategoryBySlug,
+    getProductsByCategory,
+    getProductsByCategorySlug
+  };
+}
+
+// src/integrations/restApi/woocommerce/categories/mutations.ts
+function createCategoriesMutations2(fetcher) {
+  const { wcMutate } = fetcher;
+  async function createProductCategory(input) {
+    return wcMutate("/wp-json/wc/v3/products/categories", input, "POST");
+  }
+  async function updateProductCategory(id, input) {
+    return wcMutate(
+      `/wp-json/wc/v3/products/categories/${id}`,
+      input,
+      "PUT"
+    );
+  }
+  async function deleteProductCategory(id, force = true) {
+    return wcMutate(
+      `/wp-json/wc/v3/products/categories/${id}`,
+      { force },
+      "DELETE"
+    );
+  }
+  return { createProductCategory, updateProductCategory, deleteProductCategory };
+}
+
+// src/integrations/restApi/woocommerce/tags/queries.ts
+function createTagsQueries2(fetcher) {
+  const { wcFetch, wcFetchGraceful } = fetcher;
+  async function getAllProductTags() {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/products/tags",
+      [],
+      { per_page: 100 },
+      ["woocommerce", "product-tags"]
+    );
+  }
+  async function getProductTagById(id) {
+    return wcFetch(`/wp-json/wc/v3/products/tags/${id}`, void 0, [
+      "woocommerce",
+      "product-tags",
+      `product-tag-${id}`
+    ]);
+  }
+  async function getProductsByTag(tagId, limit = 100) {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/products",
+      [],
+      { tag: tagId, per_page: limit },
+      ["woocommerce", "products", `products-tag-${tagId}`]
+    );
+  }
+  return {
+    getAllProductTags,
+    getProductTagById,
+    getProductsByTag
+  };
+}
+
+// src/integrations/restApi/woocommerce/tags/mutations.ts
+function createTagsMutations2(fetcher) {
+  const { wcMutate } = fetcher;
+  async function createProductTag(input) {
+    return wcMutate("/wp-json/wc/v3/products/tags", input, "POST");
+  }
+  async function updateProductTag(id, input) {
+    return wcMutate(`/wp-json/wc/v3/products/tags/${id}`, input, "PUT");
+  }
+  async function deleteProductTag(id, force = true) {
+    return wcMutate(
+      `/wp-json/wc/v3/products/tags/${id}`,
+      { force },
+      "DELETE"
+    );
+  }
+  return { createProductTag, updateProductTag, deleteProductTag };
+}
+
+// src/integrations/restApi/woocommerce/orders/queries.ts
+function createOrdersQueries(fetcher) {
+  const { wcFetch, wcFetchGraceful, wcMutate } = fetcher;
+  async function createOrder(input) {
+    return wcMutate("/wp-json/wc/v3/orders", input, "POST");
+  }
+  async function getOrderById(id) {
+    return wcFetch(`/wp-json/wc/v3/orders/${id}`, void 0, [
+      "woocommerce",
+      "orders",
+      `order-${id}`
+    ]);
+  }
+  async function updateOrder(id, data) {
+    return wcMutate(`/wp-json/wc/v3/orders/${id}`, data, "PUT");
+  }
+  async function getOrdersByCustomer(customerId) {
+    return wcFetchGraceful(
+      "/wp-json/wc/v3/orders",
+      [],
+      { customer: customerId, per_page: 100 },
+      ["woocommerce", "orders", `orders-customer-${customerId}`]
+    );
+  }
+  async function deleteOrder(id, force = true) {
+    return wcMutate(
+      `/wp-json/wc/v3/orders/${id}`,
+      { force },
+      "DELETE"
+    );
+  }
+  return {
+    createOrder,
+    getOrderById,
+    updateOrder,
+    getOrdersByCustomer,
+    deleteOrder
+  };
+}
+
+// src/integrations/restApi/woocommerce/coupons/queries.ts
+function createCouponsQueries(fetcher) {
+  const { wcFetchGraceful } = fetcher;
+  async function getCouponByCode(code) {
+    const coupons = await wcFetchGraceful(
+      "/wp-json/wc/v3/coupons",
+      [],
+      { code },
+      ["woocommerce", "coupons"]
+    );
+    return coupons[0];
+  }
+  async function validateCoupon(code) {
+    const coupon = await getCouponByCode(code);
+    if (!coupon) return { valid: false, reason: "Coupon not found" };
+    if (coupon.date_expires) {
+      const expiry = new Date(coupon.date_expires);
+      if (expiry < /* @__PURE__ */ new Date()) return { valid: false, reason: "Coupon has expired", coupon };
+    }
+    if (coupon.usage_limit !== null && coupon.usage_count >= coupon.usage_limit) {
+      return { valid: false, reason: "Coupon usage limit reached", coupon };
+    }
+    return { valid: true, coupon };
+  }
+  return {
+    getCouponByCode,
+    validateCoupon
+  };
+}
+
+// src/integrations/restApi/woocommerce/coupons/mutations.ts
+function createCouponsMutations(fetcher) {
+  const { wcMutate } = fetcher;
+  async function createCoupon(input) {
+    return wcMutate("/wp-json/wc/v3/coupons", input, "POST");
+  }
+  async function updateCoupon(id, input) {
+    return wcMutate(`/wp-json/wc/v3/coupons/${id}`, input, "PUT");
+  }
+  async function deleteCoupon(id, force = true) {
+    return wcMutate(
+      `/wp-json/wc/v3/coupons/${id}`,
+      { force },
+      "DELETE"
+    );
+  }
+  return { createCoupon, updateCoupon, deleteCoupon };
+}
+
+// src/integrations/restApi/woocommerce/customers/queries.ts
+function createCustomersQueries(fetcher) {
+  const { wcFetch, wcFetchGraceful, wcMutate } = fetcher;
+  async function getCustomerById(id) {
+    return wcFetch(`/wp-json/wc/v3/customers/${id}`, void 0, [
+      "woocommerce",
+      "customers",
+      `customer-${id}`
+    ]);
+  }
+  async function getCustomerByEmail(email) {
+    const customers = await wcFetchGraceful(
+      "/wp-json/wc/v3/customers",
+      [],
+      { email },
+      ["woocommerce", "customers"]
+    );
+    return customers[0];
+  }
+  async function getCustomerByEmailNoCache(email) {
+    try {
+      const customers = await wcFetch(
+        "/wp-json/wc/v3/customers",
+        { email },
+        ["woocommerce", "customers"],
+        { cache: "no-store" }
+      );
+      return customers[0];
+    } catch {
+      return void 0;
+    }
+  }
+  async function createCustomer(data) {
+    return wcFetch(
+      "/wp-json/wc/v3/customers",
+      void 0,
+      ["woocommerce", "customers"],
+      { method: "POST", body: JSON.stringify(data) }
+    );
+  }
+  async function updateCustomer(id, data) {
+    return wcMutate(`/wp-json/wc/v3/customers/${id}`, data, "PUT");
+  }
+  async function deleteCustomer(id, reassign) {
+    return wcMutate(
+      `/wp-json/wc/v3/customers/${id}`,
+      { force: true, ...reassign !== void 0 && { reassign } },
+      "DELETE"
+    );
+  }
+  return {
+    getCustomerById,
+    getCustomerByEmail,
+    getCustomerByEmailNoCache,
+    createCustomer,
+    updateCustomer,
+    deleteCustomer
+  };
+}
+
+// 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);
+  return {
+    ...createProductsQueries(fetcher),
+    ...createProductsMutations(fetcher),
+    ...createCategoriesQueries2(fetcher),
+    ...createCategoriesMutations2(fetcher),
+    ...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),
+    ...createPaymentGatewaysQueries(fetcher)
+  };
+}
+
+// src/integrations/restApi/wpulike/queries.ts
+function createWPULikeQueries(fetcher) {
+  const { wpFetch, wpMutate } = fetcher;
+  async function getLikeStats(params, tags) {
+    return wpFetch(
+      "/wp-json/wp-ulike/v1/stats",
+      params,
+      tags ?? ["wpulike", `wpulike-${params.id}`]
+    );
+  }
+  async function checkLikeStatus(params, tags) {
+    return wpFetch(
+      "/wp-json/wp-ulike/v1/check",
+      params,
+      tags ?? ["wpulike", `wpulike-${params.id}`]
+    );
+  }
+  async function vote(params, authToken) {
+    return wpMutate(
+      "/wp-json/wp-ulike/v1/vote",
+      params,
+      "POST",
+      authToken
+    );
+  }
+  return { getLikeStats, checkLikeStatus, vote };
+}
+function createWPULikeClient(config) {
+  const fetcher = createFetcher(config);
+  return createWPULikeQueries(fetcher);
+}
+
+// src/integrations/wpGraphQL/client/types.ts
+var WPGraphQLError = class extends Error {
+  constructor(code, status, endpoint, message, gqlErrors) {
+    super(message);
+    __publicField(this, "code", code);
+    __publicField(this, "status", status);
+    __publicField(this, "endpoint", endpoint);
+    __publicField(this, "gqlErrors", gqlErrors);
+    this.name = "WPGraphQLError";
+  }
+};
+
+// src/integrations/wpGraphQL/client/fetcher.ts
+var USER_AGENT3 = "NextWordpress WPGraphQL Client";
+function createWPGraphQLFetcher(config) {
+  const url = `${resolveBaseUrl(config)}/graphql`;
+  const cacheTTL = config.cacheTTL ?? 300;
+  async function gqlFetch(document, variables, tags = ["wpgraphql"]) {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": USER_AGENT3
+      },
+      body: JSON.stringify({ query: document, variables }),
+      next: { tags, revalidate: cacheTTL }
+    });
+    if (!response.ok) {
+      throw new WPGraphQLError(
+        ErrorCode.GQL_REQUEST_FAILED,
+        response.status,
+        url,
+        resolveMessage(ErrorCode.GQL_REQUEST_FAILED, config.errorMessages)
+      );
+    }
+    const parsed = await response.json();
+    if (parsed.errors && parsed.errors.length > 0) {
+      throw new WPGraphQLError(
+        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(
+        ErrorCode.GQL_NO_DATA,
+        200,
+        url,
+        resolveMessage(ErrorCode.GQL_NO_DATA, config.errorMessages)
+      );
+    }
+    return parsed.data;
+  }
+  async function gqlFetchGraceful(document, fallback, variables, tags = ["wpgraphql"]) {
+    try {
+      return await gqlFetch(document, variables, tags);
+    } catch {
+      console.warn(`WPGraphQL fetch failed for query`);
+      return fallback;
+    }
+  }
+  async function gqlMutate(document, variables, authToken) {
+    const headers = {
+      "Content-Type": "application/json",
+      "User-Agent": USER_AGENT3
+    };
+    if (authToken) {
+      headers["Authorization"] = authToken;
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ query: document, variables }),
+      cache: "no-store"
+    });
+    if (!response.ok) {
+      throw new WPGraphQLError(
+        ErrorCode.GQL_REQUEST_FAILED,
+        response.status,
+        url,
+        resolveMessage(ErrorCode.GQL_REQUEST_FAILED, config.errorMessages)
+      );
+    }
+    const parsed = await response.json();
+    if (parsed.errors && parsed.errors.length > 0) {
+      throw new WPGraphQLError(
+        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(
+        ErrorCode.GQL_NO_DATA,
+        200,
+        url,
+        resolveMessage(ErrorCode.GQL_NO_DATA, config.errorMessages)
+      );
+    }
+    return parsed.data;
+  }
+  return { gqlFetch, gqlFetchGraceful, gqlMutate };
+}
+
+// src/integrations/wpGraphQL/core/posts/queries.ts
+var DEFAULT_FIRST = 10;
+var BATCH_FIRST = 100;
+var POST_FIELDS = `
+  id
+  databaseId
+  slug
+  title
+  excerpt
+  date
+  modified
+  status
+  uri
+  author {
+    node {
+      databaseId
+      name
+      slug
+      avatar { url }
+    }
+  }
+  featuredImage {
+    node {
+      sourceUrl
+      altText
+      mediaDetails { width height }
+    }
+  }
+  categories {
+    nodes { databaseId name slug }
+  }
+  tags {
+    nodes { databaseId name slug }
+  }
+`;
+var POST_FIELDS_WITH_CONTENT = `
+  ${POST_FIELDS}
+  content
+`;
+var GQL_GET_POSTS = `
+  query GetPosts($first: Int, $after: String, $where: RootQueryToPostConnectionWhereArgs) {
+    posts(first: $first, after: $after, where: $where) {
+      nodes { ${POST_FIELDS} }
+      pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+    }
+  }
+`;
+var GQL_GET_POST_BY_SLUG = `
+  query GetPostBySlug($slug: ID!) {
+    post(id: $slug, idType: SLUG) { ${POST_FIELDS_WITH_CONTENT} }
+  }
+`;
+var GQL_GET_POST_BY_DATABASE_ID = `
+  query GetPostByDatabaseId($id: ID!) {
+    post(id: $id, idType: DATABASE_ID) { ${POST_FIELDS_WITH_CONTENT} }
+  }
+`;
+var GQL_GET_ALL_POST_SLUGS = `
+  query GetAllPostSlugs($first: Int, $after: String) {
+    posts(first: $first, after: $after) {
+      nodes { slug }
+      pageInfo { hasNextPage endCursor }
+    }
+  }
+`;
+var GQL_GET_ALL_POSTS_FOR_SITEMAP = `
+  query GetAllPostsForSitemap($first: Int, $after: String) {
+    posts(first: $first, after: $after) {
+      nodes { slug modified }
+      pageInfo { hasNextPage endCursor }
+    }
+  }
+`;
+function createPostsQueries2(fetcher) {
+  const { gqlFetch, gqlFetchGraceful } = fetcher;
+  async function getPosts(first = DEFAULT_FIRST, after, filter) {
+    const where = {};
+    if (filter?.authorName) where["authorName"] = filter.authorName;
+    if (filter?.categoryName) where["categoryName"] = filter.categoryName;
+    if (filter?.tag) where["tag"] = filter.tag;
+    if (filter?.search) where["search"] = filter.search;
+    if (filter?.status) where["status"] = filter.status;
+    const data = await gqlFetchGraceful(
+      GQL_GET_POSTS,
+      { posts: { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } } },
+      { first, after, where: Object.keys(where).length > 0 ? where : void 0 },
+      ["wpgraphql", "gql-posts"]
+    );
+    return data.posts;
+  }
+  async function getPostBySlug(slug) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_POST_BY_SLUG,
+      { post: null },
+      { slug },
+      ["wpgraphql", "gql-posts", `gql-post-${slug}`]
+    );
+    return data.post;
+  }
+  async function getPostByDatabaseId(id) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_POST_BY_DATABASE_ID,
+      { post: null },
+      { id: String(id) },
+      ["wpgraphql", "gql-posts", `gql-post-id-${id}`]
+    );
+    return data.post;
+  }
+  async function getRecentPosts(first = DEFAULT_FIRST) {
+    const connection = await getPosts(first);
+    return connection.nodes;
+  }
+  async function getAllPostSlugs() {
+    try {
+      const all = [];
+      let after = void 0;
+      let hasNextPage = true;
+      while (hasNextPage) {
+        const data = await gqlFetch(GQL_GET_ALL_POST_SLUGS, { first: BATCH_FIRST, after }, ["wpgraphql"]);
+        all.push(...data.posts.nodes);
+        hasNextPage = data.posts.pageInfo.hasNextPage;
+        after = data.posts.pageInfo.endCursor;
+      }
+      return all;
+    } catch {
+      console.warn("WPGraphQL unavailable, skipping static generation for posts");
+      return [];
+    }
+  }
+  async function getAllPostsForSitemap() {
+    try {
+      const all = [];
+      let after = void 0;
+      let hasNextPage = true;
+      while (hasNextPage) {
+        const data = await gqlFetch(
+          GQL_GET_ALL_POSTS_FOR_SITEMAP,
+          { first: BATCH_FIRST, after },
+          ["wpgraphql"]
+        );
+        all.push(...data.posts.nodes);
+        hasNextPage = data.posts.pageInfo.hasNextPage;
+        after = data.posts.pageInfo.endCursor;
+      }
+      return all;
+    } catch {
+      console.warn("WPGraphQL unavailable, skipping sitemap generation");
+      return [];
+    }
+  }
+  return {
+    getPosts,
+    getPostBySlug,
+    getPostByDatabaseId,
+    getRecentPosts,
+    getAllPostSlugs,
+    getAllPostsForSitemap
+  };
+}
+
+// src/integrations/wpGraphQL/core/pages/queries.ts
+var DEFAULT_FIRST2 = 10;
+var BATCH_FIRST2 = 100;
+var PAGE_FIELDS = `
+  id
+  databaseId
+  slug
+  title
+  content
+  date
+  modified
+  status
+  uri
+  featuredImage {
+    node {
+      sourceUrl
+      altText
+      mediaDetails { width height }
+    }
+  }
+`;
+var GQL_GET_PAGES = `
+  query GetPages($first: Int, $after: String) {
+    pages(first: $first, after: $after) {
+      nodes { ${PAGE_FIELDS} }
+      pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+    }
+  }
+`;
+var GQL_GET_PAGE_BY_SLUG = `
+  query GetPageBySlug($uri: ID!) {
+    page(id: $uri, idType: URI) { ${PAGE_FIELDS} }
+  }
+`;
+var GQL_GET_PAGE_BY_URI = `
+  query GetPageByUri($uri: ID!) {
+    page(id: $uri, idType: URI) { ${PAGE_FIELDS} }
+  }
+`;
+var GQL_GET_ALL_PAGE_URIS = `
+  query GetAllPageUris($first: Int, $after: String) {
+    pages(first: $first, after: $after) {
+      nodes { uri }
+      pageInfo { hasNextPage endCursor }
+    }
+  }
+`;
+function createPagesQueries2(fetcher) {
+  const { gqlFetch, gqlFetchGraceful } = fetcher;
+  async function getPages(first = DEFAULT_FIRST2, after) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_PAGES,
+      { pages: { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } } },
+      { first, after },
+      ["wpgraphql", "gql-pages"]
+    );
+    return data.pages;
+  }
+  async function getPageBySlug(slug) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_PAGE_BY_SLUG,
+      { page: null },
+      { uri: `/${slug}/` },
+      ["wpgraphql", "gql-pages", `gql-page-${slug}`]
+    );
+    return data.page;
+  }
+  async function getPageByUri(uri) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_PAGE_BY_URI,
+      { page: null },
+      { uri },
+      ["wpgraphql", "gql-pages", `gql-page-uri-${uri.replace(/\//g, "-")}`]
+    );
+    return data.page;
+  }
+  async function getAllPageUris() {
+    try {
+      const all = [];
+      let after = void 0;
+      let hasNextPage = true;
+      while (hasNextPage) {
+        const data = await gqlFetch(GQL_GET_ALL_PAGE_URIS, { first: BATCH_FIRST2, after }, ["wpgraphql"]);
+        all.push(...data.pages.nodes);
+        hasNextPage = data.pages.pageInfo.hasNextPage;
+        after = data.pages.pageInfo.endCursor;
+      }
+      return all;
+    } catch {
+      console.warn("WPGraphQL unavailable, skipping static generation for pages");
+      return [];
+    }
+  }
+  return { getPages, getPageBySlug, getPageByUri, getAllPageUris };
+}
+
+// src/integrations/wpGraphQL/core/categories/queries.ts
+var DEFAULT_FIRST3 = 100;
+var CATEGORY_FIELDS = `
+  id
+  databaseId
+  name
+  slug
+  description
+  count
+  uri
+  parent {
+    node { databaseId name slug }
+  }
+`;
+var GQL_GET_CATEGORIES = `
+  query GetCategories($first: Int, $after: String) {
+    categories(first: $first, after: $after) {
+      nodes { ${CATEGORY_FIELDS} }
+      pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+    }
+  }
+`;
+var GQL_GET_CATEGORY_BY_SLUG = `
+  query GetCategoryBySlug($slug: ID!) {
+    category(id: $slug, idType: SLUG) { ${CATEGORY_FIELDS} }
+  }
+`;
+var GQL_GET_CATEGORY_BY_DATABASE_ID = `
+  query GetCategoryByDatabaseId($id: ID!) {
+    category(id: $id, idType: DATABASE_ID) { ${CATEGORY_FIELDS} }
+  }
+`;
+function createCategoriesQueries3(fetcher) {
+  const { gqlFetchGraceful } = fetcher;
+  async function getCategories(first = DEFAULT_FIRST3, after) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_CATEGORIES,
+      { categories: { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } } },
+      { first, after },
+      ["wpgraphql", "gql-categories"]
+    );
+    return data.categories;
+  }
+  async function getCategoryBySlug(slug) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_CATEGORY_BY_SLUG,
+      { category: null },
+      { slug },
+      ["wpgraphql", "gql-categories", `gql-category-${slug}`]
+    );
+    return data.category;
+  }
+  async function getCategoryByDatabaseId(id) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_CATEGORY_BY_DATABASE_ID,
+      { category: null },
+      { id: String(id) },
+      ["wpgraphql", "gql-categories", `gql-category-id-${id}`]
+    );
+    return data.category;
+  }
+  return { getCategories, getCategoryBySlug, getCategoryByDatabaseId };
+}
+
+// src/integrations/wpGraphQL/core/tags/queries.ts
+var DEFAULT_FIRST4 = 100;
+var TAG_FIELDS = `
+  id
+  databaseId
+  name
+  slug
+  description
+  count
+  uri
+`;
+var GQL_GET_TAGS = `
+  query GetTags($first: Int, $after: String) {
+    tags(first: $first, after: $after) {
+      nodes { ${TAG_FIELDS} }
+      pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+    }
+  }
+`;
+var GQL_GET_TAG_BY_SLUG = `
+  query GetTagBySlug($slug: ID!) {
+    tag(id: $slug, idType: SLUG) { ${TAG_FIELDS} }
+  }
+`;
+function createTagsQueries3(fetcher) {
+  const { gqlFetchGraceful } = fetcher;
+  async function getTags(first = DEFAULT_FIRST4, after) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_TAGS,
+      { tags: { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } } },
+      { first, after },
+      ["wpgraphql", "gql-tags"]
+    );
+    return data.tags;
+  }
+  async function getTagBySlug(slug) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_TAG_BY_SLUG,
+      { tag: null },
+      { slug },
+      ["wpgraphql", "gql-tags", `gql-tag-${slug}`]
+    );
+    return data.tag;
+  }
+  return { getTags, getTagBySlug };
+}
+
+// src/integrations/wpGraphQL/core/authors/queries.ts
+var DEFAULT_FIRST5 = 100;
+var AUTHOR_FIELDS = `
+  id
+  databaseId
+  name
+  slug
+  description
+  email
+  uri
+  avatar { url width height }
+`;
+var GQL_GET_AUTHORS = `
+  query GetAuthors($first: Int, $after: String) {
+    users(first: $first, after: $after) {
+      nodes { ${AUTHOR_FIELDS} }
+      pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+    }
+  }
+`;
+var GQL_GET_AUTHOR_BY_SLUG = `
+  query GetAuthorBySlug($slug: String!) {
+    users(where: { login: $slug }) {
+      nodes { ${AUTHOR_FIELDS} }
+    }
+  }
+`;
+function createAuthorsQueries2(fetcher) {
+  const { gqlFetchGraceful } = fetcher;
+  async function getAuthors(first = DEFAULT_FIRST5, after) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_AUTHORS,
+      { users: { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } } },
+      { first, after },
+      ["wpgraphql", "gql-authors"]
+    );
+    return data.users;
+  }
+  async function getAuthorBySlug(slug) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_AUTHOR_BY_SLUG,
+      { users: { nodes: [] } },
+      { slug },
+      ["wpgraphql", "gql-authors", `gql-author-${slug}`]
+    );
+    return data.users.nodes[0] ?? null;
+  }
+  return { getAuthors, getAuthorBySlug };
+}
+
+// src/integrations/wpGraphQL/core/menus/queries.ts
+var MENU_ITEM_FIELDS = `
+  id
+  databaseId
+  label
+  url
+  parentId
+  order
+  target
+  cssClasses
+  description
+  connectedNode {
+    node {
+      __typename
+      ... on Page { id databaseId slug }
+      ... on Post { id databaseId slug }
+      ... on Category { id databaseId slug }
+      ... on Tag { id databaseId slug }
+    }
+  }
+`;
+var MENU_FIELDS = `
+  id
+  databaseId
+  name
+  slug
+  locations
+  menuItems(first: 100) {
+    nodes { ${MENU_ITEM_FIELDS} }
+  }
+`;
+var GQL_GET_MENUS = `
+  query GetMenus {
+    menus(first: 100) {
+      nodes { ${MENU_FIELDS} }
+    }
+  }
+`;
+var GQL_GET_MENU_BY_ID = `
+  query GetMenuById($id: ID!) {
+    menu(id: $id, idType: DATABASE_ID) { ${MENU_FIELDS} }
+  }
+`;
+var GQL_GET_MENU_BY_SLUG = `
+  query GetMenuBySlug($id: ID!) {
+    menu(id: $id, idType: SLUG) { ${MENU_FIELDS} }
+  }
+`;
+var GQL_GET_MENUS_BY_LOCATION = `
+  query GetMenusByLocation($location: MenuLocationEnum!) {
+    menus(where: { location: $location }, first: 1) {
+      nodes { ${MENU_FIELDS} }
+    }
+  }
+`;
+function createMenusQueries2(fetcher) {
+  const { gqlFetch, gqlFetchGraceful } = fetcher;
+  async function getMenus() {
+    const data = await gqlFetchGraceful(
+      GQL_GET_MENUS,
+      { menus: { nodes: [] } },
+      void 0,
+      ["wpgraphql", "gql-menus"]
+    );
+    return data.menus.nodes;
+  }
+  async function getMenuById(id) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_MENU_BY_ID,
+      { menu: null },
+      { id: String(id) },
+      ["wpgraphql", "gql-menus", `gql-menu-${id}`]
+    );
+    return data.menu;
+  }
+  async function getMenuBySlug(slug) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_MENU_BY_SLUG,
+      { menu: null },
+      { id: slug },
+      ["wpgraphql", "gql-menus", `gql-menu-${slug}`]
+    );
+    return data.menu;
+  }
+  async function getMenuByLocation(location) {
+    const data = await gqlFetch(
+      GQL_GET_MENUS_BY_LOCATION,
+      { location: location.toUpperCase() },
+      ["wpgraphql", "gql-menus", `gql-menu-location-${location}`]
+    );
+    return data.menus.nodes[0] ?? null;
+  }
+  async function getMenuItems(menuSlug) {
+    const menu = await getMenuBySlug(menuSlug);
+    return menu?.menuItems?.nodes ?? [];
+  }
+  return {
+    getMenus,
+    getMenuById,
+    getMenuBySlug,
+    getMenuByLocation,
+    getMenuItems
+  };
+}
+
+// src/integrations/wpGraphQL/core/comments/queries.ts
+var COMMENT_AUTHOR_FIELDS = `
+  name
+  url
+  avatar { url width height }
+`;
+var COMMENT_FIELDS = `
+  id
+  databaseId
+  content(format: RENDERED)
+  date
+  parentId
+  status
+  author { node { ${COMMENT_AUTHOR_FIELDS} } }
+`;
+var GQL_GET_COMMENTS_BY_POST = `
+  query GetCommentsByPost($contentId: ID!, $first: Int, $after: String) {
+    comments(
+      first: $first
+      after: $after
+      where: { contentId: $contentId, status: "approve", parent: 0 }
+    ) {
+      nodes {
+        ${COMMENT_FIELDS}
+        replies(first: 100) {
+          nodes { ${COMMENT_FIELDS} }
+        }
+      }
+      pageInfo { hasNextPage endCursor }
+    }
+  }
+`;
+var GQL_GET_ALL_COMMENTS_BY_POST = `
+  query GetAllCommentsByPost($contentId: ID!) {
+    comments(
+      first: 100
+      where: { contentId: $contentId, status: "approve" }
+    ) {
+      nodes { ${COMMENT_FIELDS} }
+    }
+  }
+`;
+var GQL_GET_COMMENT_BY_ID = `
+  query GetCommentById($id: ID!) {
+    comment(id: $id, idType: DATABASE_ID) { ${COMMENT_FIELDS} }
+  }
+`;
+function createCommentsQueries2(fetcher) {
+  const { gqlFetchGraceful } = fetcher;
+  async function getCommentsByPostId(postId, first = 10, after) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_COMMENTS_BY_POST,
+      { comments: { nodes: [], pageInfo: { hasNextPage: false } } },
+      { contentId: String(postId), first, after },
+      ["wpgraphql", "gql-comments", `gql-comments-post-${postId}`]
+    );
+    return data.comments;
+  }
+  async function getAllCommentsByPostId(postId) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_ALL_COMMENTS_BY_POST,
+      { comments: { nodes: [] } },
+      { contentId: String(postId) },
+      ["wpgraphql", "gql-comments", `gql-comments-post-${postId}`]
+    );
+    return data.comments.nodes;
+  }
+  async function getCommentById(id) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_COMMENT_BY_ID,
+      { comment: null },
+      { id: String(id) },
+      ["wpgraphql", "gql-comments", `gql-comment-${id}`]
+    );
+    return data.comment;
+  }
+  return {
+    getCommentsByPostId,
+    getAllCommentsByPostId,
+    getCommentById
+  };
+}
+
+// src/integrations/wpGraphQL/core/media/queries.ts
+var DEFAULT_FIRST6 = 10;
+var MEDIA_FIELDS = `
+  id
+  databaseId
+  slug
+  title
+  date
+  sourceUrl
+  altText
+  caption
+  description
+  mediaType
+  mimeType
+  uri
+  mediaDetails {
+    width
+    height
+    file
+    sizes { name width height mimeType sourceUrl }
+  }
+`;
+var GQL_GET_MEDIA_ITEMS = `
+  query GetMediaItems($first: Int, $after: String) {
+    mediaItems(first: $first, after: $after) {
+      nodes { ${MEDIA_FIELDS} }
+      pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+    }
+  }
+`;
+var GQL_GET_MEDIA_ITEM_BY_ID = `
+  query GetMediaItemById($id: ID!) {
+    mediaItem(id: $id, idType: DATABASE_ID) { ${MEDIA_FIELDS} }
+  }
+`;
+var GQL_GET_MEDIA_ITEM_BY_SLUG = `
+  query GetMediaItemBySlug($id: ID!) {
+    mediaItem(id: $id, idType: SLUG) { ${MEDIA_FIELDS} }
+  }
+`;
+function createMediaQueries2(fetcher) {
+  const { gqlFetchGraceful } = fetcher;
+  async function getMediaItems(first = DEFAULT_FIRST6, after) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_MEDIA_ITEMS,
+      { mediaItems: { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } } },
+      { first, after },
+      ["wpgraphql", "gql-media"]
+    );
+    return data.mediaItems;
+  }
+  async function getMediaItemById(id) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_MEDIA_ITEM_BY_ID,
+      { mediaItem: null },
+      { id: String(id) },
+      ["wpgraphql", "gql-media", `gql-media-${id}`]
+    );
+    return data.mediaItem;
+  }
+  async function getMediaItemBySlug(slug) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_MEDIA_ITEM_BY_SLUG,
+      { mediaItem: null },
+      { id: slug },
+      ["wpgraphql", "gql-media", `gql-media-${slug}`]
+    );
+    return data.mediaItem;
+  }
+  return { getMediaItems, getMediaItemById, getMediaItemBySlug };
+}
+
+// src/integrations/wpGraphQL/core/mutations/posts/mutations.ts
+var MUTATED_POST_FIELDS = `
+  id
+  databaseId
+  slug
+  title
+  status
+`;
+var GQL_CREATE_POST = `
+  mutation CreatePost($input: CreatePostInput!) {
+    createPost(input: $input) {
+      post { ${MUTATED_POST_FIELDS} }
+    }
+  }
+`;
+var GQL_UPDATE_POST = `
+  mutation UpdatePost($input: UpdatePostInput!) {
+    updatePost(input: $input) {
+      post { ${MUTATED_POST_FIELDS} }
+    }
+  }
+`;
+var GQL_DELETE_POST = `
+  mutation DeletePost($input: DeletePostInput!) {
+    deletePost(input: $input) {
+      deletedId
+      post { ${MUTATED_POST_FIELDS} }
+    }
+  }
+`;
+function createPostsMutations2(fetcher) {
+  const { gqlMutate } = fetcher;
+  async function createPost(input, authToken) {
+    const data = await gqlMutate(
+      GQL_CREATE_POST,
+      { input },
+      authToken
+    );
+    return data.createPost.post;
+  }
+  async function updatePost(input, authToken) {
+    const data = await gqlMutate(
+      GQL_UPDATE_POST,
+      { input },
+      authToken
+    );
+    return data.updatePost.post;
+  }
+  async function deletePost(id, authToken, forceDelete = false) {
+    const data = await gqlMutate(
+      GQL_DELETE_POST,
+      { input: { id, forceDelete } },
+      authToken
+    );
+    return data.deletePost;
+  }
+  return { createPost, updatePost, deletePost };
+}
+
+// src/integrations/wpGraphQL/core/mutations/comments/mutations.ts
+var MUTATED_COMMENT_FIELDS = `
+  id
+  databaseId
+  content(format: RENDERED)
+  date
+  status
+  parentId
+  author { node { name url } }
+`;
+var GQL_CREATE_COMMENT = `
+  mutation CreateComment($input: CreateCommentInput!) {
+    createComment(input: $input) {
+      success
+      comment { ${MUTATED_COMMENT_FIELDS} }
+    }
+  }
+`;
+var GQL_UPDATE_COMMENT = `
+  mutation UpdateComment($input: UpdateCommentInput!) {
+    updateComment(input: $input) {
+      comment { ${MUTATED_COMMENT_FIELDS} }
+    }
+  }
+`;
+var GQL_DELETE_COMMENT = `
+  mutation DeleteComment($input: DeleteCommentInput!) {
+    deleteComment(input: $input) {
+      deletedId
+      comment { ${MUTATED_COMMENT_FIELDS} }
+    }
+  }
+`;
+function createCommentsMutations2(fetcher) {
+  const { gqlMutate } = fetcher;
+  async function createComment(input, authToken) {
+    const gqlInput = {
+      commentOn: input.postId,
+      content: input.content
+    };
+    if (input.authorName) gqlInput["author"] = input.authorName;
+    if (input.authorEmail) gqlInput["authorEmail"] = input.authorEmail;
+    if (input.authorUrl) gqlInput["authorUrl"] = input.authorUrl;
+    if (input.parentId) gqlInput["parent"] = input.parentId;
+    const data = await gqlMutate(
+      GQL_CREATE_COMMENT,
+      { input: gqlInput },
+      authToken
+    );
+    return data.createComment;
+  }
+  async function updateComment(input, authToken) {
+    const data = await gqlMutate(
+      GQL_UPDATE_COMMENT,
+      { input },
+      authToken
+    );
+    return data.updateComment.comment;
+  }
+  async function deleteComment(id, authToken, forceDelete = false) {
+    const data = await gqlMutate(
+      GQL_DELETE_COMMENT,
+      { input: { id, forceDelete } },
+      authToken
+    );
+    return data.deleteComment;
+  }
+  return { createComment, updateComment, deleteComment };
+}
+
+// src/integrations/wpGraphQL/core/mutations/pages/mutations.ts
+var MUTATED_PAGE_FIELDS = `
+  id
+  databaseId
+  slug
+  title
+  status
+  uri
+`;
+var GQL_CREATE_PAGE = `
+  mutation CreatePage($input: CreatePageInput!) {
+    createPage(input: $input) {
+      page { ${MUTATED_PAGE_FIELDS} }
+    }
+  }
+`;
+var GQL_UPDATE_PAGE = `
+  mutation UpdatePage($input: UpdatePageInput!) {
+    updatePage(input: $input) {
+      page { ${MUTATED_PAGE_FIELDS} }
+    }
+  }
+`;
+var GQL_DELETE_PAGE = `
+  mutation DeletePage($input: DeletePageInput!) {
+    deletePage(input: $input) {
+      deletedId
+      page { ${MUTATED_PAGE_FIELDS} }
+    }
+  }
+`;
+function createPagesMutations2(fetcher) {
+  const { gqlMutate } = fetcher;
+  async function createPage(input, authToken) {
+    const data = await gqlMutate(
+      GQL_CREATE_PAGE,
+      { input },
+      authToken
+    );
+    return data.createPage.page;
+  }
+  async function updatePage(input, authToken) {
+    const data = await gqlMutate(
+      GQL_UPDATE_PAGE,
+      { input },
+      authToken
+    );
+    return data.updatePage.page;
+  }
+  async function deletePage(id, authToken, forceDelete = false) {
+    const data = await gqlMutate(
+      GQL_DELETE_PAGE,
+      { input: { id, forceDelete } },
+      authToken
+    );
+    return data.deletePage;
+  }
+  return { createPage, updatePage, deletePage };
+}
+
+// src/integrations/wpGraphQL/core/mutations/categories/mutations.ts
+var MUTATED_CATEGORY_FIELDS = `
+  id
+  databaseId
+  name
+  slug
+`;
+var GQL_CREATE_CATEGORY = `
+  mutation CreateCategory($input: CreateCategoryInput!) {
+    createCategory(input: $input) {
+      category { ${MUTATED_CATEGORY_FIELDS} }
+    }
+  }
+`;
+var GQL_UPDATE_CATEGORY = `
+  mutation UpdateCategory($input: UpdateCategoryInput!) {
+    updateCategory(input: $input) {
+      category { ${MUTATED_CATEGORY_FIELDS} }
+    }
+  }
+`;
+var GQL_DELETE_CATEGORY = `
+  mutation DeleteCategory($input: DeleteCategoryInput!) {
+    deleteCategory(input: $input) {
+      deletedId
+      category { ${MUTATED_CATEGORY_FIELDS} }
+    }
+  }
+`;
+function createCategoriesMutations3(fetcher) {
+  const { gqlMutate } = fetcher;
+  async function createCategory(input, authToken) {
+    const data = await gqlMutate(
+      GQL_CREATE_CATEGORY,
+      { input },
+      authToken
+    );
+    return data.createCategory.category;
+  }
+  async function updateCategory(input, authToken) {
+    const data = await gqlMutate(
+      GQL_UPDATE_CATEGORY,
+      { input },
+      authToken
+    );
+    return data.updateCategory.category;
+  }
+  async function deleteCategory(id, authToken) {
+    const data = await gqlMutate(
+      GQL_DELETE_CATEGORY,
+      { input: { id } },
+      authToken
+    );
+    return data.deleteCategory;
+  }
+  return { createCategory, updateCategory, deleteCategory };
+}
+
+// src/integrations/wpGraphQL/core/mutations/tags/mutations.ts
+var MUTATED_TAG_FIELDS = `
+  id
+  databaseId
+  name
+  slug
+`;
+var GQL_CREATE_TAG = `
+  mutation CreateTag($input: CreateTagInput!) {
+    createTag(input: $input) {
+      tag { ${MUTATED_TAG_FIELDS} }
+    }
+  }
+`;
+var GQL_UPDATE_TAG = `
+  mutation UpdateTag($input: UpdateTagInput!) {
+    updateTag(input: $input) {
+      tag { ${MUTATED_TAG_FIELDS} }
+    }
+  }
+`;
+var GQL_DELETE_TAG = `
+  mutation DeleteTag($input: DeleteTagInput!) {
+    deleteTag(input: $input) {
+      deletedId
+      tag { ${MUTATED_TAG_FIELDS} }
+    }
+  }
+`;
+function createTagsMutations3(fetcher) {
+  const { gqlMutate } = fetcher;
+  async function createTag(input, authToken) {
+    const data = await gqlMutate(
+      GQL_CREATE_TAG,
+      { input },
+      authToken
+    );
+    return data.createTag.tag;
+  }
+  async function updateTag(input, authToken) {
+    const data = await gqlMutate(
+      GQL_UPDATE_TAG,
+      { input },
+      authToken
+    );
+    return data.updateTag.tag;
+  }
+  async function deleteTag(id, authToken) {
+    const data = await gqlMutate(
+      GQL_DELETE_TAG,
+      { input: { id } },
+      authToken
+    );
+    return data.deleteTag;
+  }
+  return { createTag, updateTag, deleteTag };
+}
+
+// src/integrations/wpGraphQL/core/mutations/authors/mutations.ts
+var MUTATED_USER_FIELDS = `
+  id
+  databaseId
+  name
+  slug
+  email
+`;
+var GQL_REGISTER_USER = `
+  mutation RegisterUser($input: RegisterUserInput!) {
+    registerUser(input: $input) {
+      user { ${MUTATED_USER_FIELDS} }
+    }
+  }
+`;
+var GQL_UPDATE_USER = `
+  mutation UpdateUser($input: UpdateUserInput!) {
+    updateUser(input: $input) {
+      user { ${MUTATED_USER_FIELDS} }
+    }
+  }
+`;
+var GQL_DELETE_USER = `
+  mutation DeleteUser($input: DeleteUserInput!) {
+    deleteUser(input: $input) {
+      deletedId
+      user { ${MUTATED_USER_FIELDS} }
+    }
+  }
+`;
+function createAuthorsMutations2(fetcher) {
+  const { gqlMutate } = fetcher;
+  async function registerUser(input, authToken) {
+    const data = await gqlMutate(
+      GQL_REGISTER_USER,
+      { input },
+      authToken
+    );
+    return data.registerUser.user;
+  }
+  async function updateUser(input, authToken) {
+    const data = await gqlMutate(
+      GQL_UPDATE_USER,
+      { input },
+      authToken
+    );
+    return data.updateUser.user;
+  }
+  async function deleteUser(id, authToken, reassignPosts) {
+    const input = { id };
+    if (reassignPosts) input["reassignId"] = reassignPosts;
+    const data = await gqlMutate(
+      GQL_DELETE_USER,
+      { input },
+      authToken
+    );
+    return data.deleteUser;
+  }
+  return { registerUser, updateUser, deleteUser };
+}
+
+// src/integrations/wpGraphQL/core/mutations/media/mutations.ts
+var MUTATED_MEDIA_FIELDS = `
+  id
+  databaseId
+  slug
+  title
+  sourceUrl
+  altText
+`;
+var GQL_CREATE_MEDIA_ITEM = `
+  mutation CreateMediaItem($input: CreateMediaItemInput!) {
+    createMediaItem(input: $input) {
+      mediaItem { ${MUTATED_MEDIA_FIELDS} }
+    }
+  }
+`;
+var GQL_UPDATE_MEDIA_ITEM = `
+  mutation UpdateMediaItem($input: UpdateMediaItemInput!) {
+    updateMediaItem(input: $input) {
+      mediaItem { ${MUTATED_MEDIA_FIELDS} }
+    }
+  }
+`;
+var GQL_DELETE_MEDIA_ITEM = `
+  mutation DeleteMediaItem($input: DeleteMediaItemInput!) {
+    deleteMediaItem(input: $input) {
+      deletedId
+      mediaItem { ${MUTATED_MEDIA_FIELDS} }
+    }
+  }
+`;
+function createMediaMutations2(fetcher) {
+  const { gqlMutate } = fetcher;
+  async function createMediaItem(input, authToken) {
+    const data = await gqlMutate(
+      GQL_CREATE_MEDIA_ITEM,
+      { input },
+      authToken
+    );
+    return data.createMediaItem.mediaItem;
+  }
+  async function updateMediaItem(input, authToken) {
+    const data = await gqlMutate(
+      GQL_UPDATE_MEDIA_ITEM,
+      { input },
+      authToken
+    );
+    return data.updateMediaItem.mediaItem;
+  }
+  async function deleteMediaItem(id, authToken, forceDelete = true) {
+    const data = await gqlMutate(
+      GQL_DELETE_MEDIA_ITEM,
+      { input: { id, forceDelete } },
+      authToken
+    );
+    return data.deleteMediaItem;
+  }
+  return { createMediaItem, updateMediaItem, deleteMediaItem };
+}
+
+// src/integrations/wpGraphQL/core/mutations/index.ts
+function createWPGraphQLMutationsClient(config) {
+  const fetcher = createWPGraphQLFetcher(config);
+  return {
+    ...createPostsMutations2(fetcher),
+    ...createCommentsMutations2(fetcher),
+    ...createPagesMutations2(fetcher),
+    ...createCategoriesMutations3(fetcher),
+    ...createTagsMutations3(fetcher),
+    ...createAuthorsMutations2(fetcher),
+    ...createMediaMutations2(fetcher)
+  };
+}
+
+// src/integrations/wpGraphQL/core/index.ts
+function createWPGraphQLCoreClient(config) {
+  const fetcher = createWPGraphQLFetcher(config);
+  return {
+    ...createPostsQueries2(fetcher),
+    ...createPagesQueries2(fetcher),
+    ...createCategoriesQueries3(fetcher),
+    ...createTagsQueries3(fetcher),
+    ...createAuthorsQueries2(fetcher),
+    ...createMenusQueries2(fetcher),
+    ...createCommentsQueries2(fetcher),
+    ...createMediaQueries2(fetcher)
+  };
+}
+
+// src/integrations/wpGraphQL/yoast/queries.ts
+var SEO_FIELDS = `
+  seo {
+    title
+    metaDesc
+    canonical
+    opengraphTitle
+    opengraphDescription
+    opengraphImage { sourceUrl altText }
+    twitterTitle
+    twitterDescription
+    twitterImage { sourceUrl }
+    schema { raw }
+  }
+`;
+var POST_FIELDS_WITH_SEO = `
+  id
+  databaseId
+  slug
+  title
+  content
+  excerpt
+  date
+  modified
+  status
+  uri
+  author {
+    node {
+      databaseId
+      name
+      slug
+      avatar { url }
+    }
+  }
+  featuredImage {
+    node {
+      sourceUrl
+      altText
+      mediaDetails { width height }
+    }
+  }
+  categories {
+    nodes { databaseId name slug }
+  }
+  tags {
+    nodes { databaseId name slug }
+  }
+  ${SEO_FIELDS}
+`;
+var PAGE_FIELDS_WITH_SEO = `
+  id
+  databaseId
+  slug
+  title
+  content
+  date
+  modified
+  status
+  uri
+  featuredImage {
+    node {
+      sourceUrl
+      altText
+      mediaDetails { width height }
+    }
+  }
+  ${SEO_FIELDS}
+`;
+var GQL_GET_POST_WITH_SEO = `
+  query GetPostWithSEO($slug: ID!) {
+    post(id: $slug, idType: SLUG) { ${POST_FIELDS_WITH_SEO} }
+  }
+`;
+var GQL_GET_PAGE_WITH_SEO = `
+  query GetPageWithSEO($slug: ID!) {
+    page(id: $slug, idType: SLUG) { ${PAGE_FIELDS_WITH_SEO} }
+  }
+`;
+var GQL_GET_PAGE_WITH_SEO_BY_URI = `
+  query GetPageWithSEOByUri($uri: ID!) {
+    page(id: $uri, idType: URI) { ${PAGE_FIELDS_WITH_SEO} }
+  }
+`;
+function createYoastQueries(fetcher) {
+  const { gqlFetchGraceful } = fetcher;
+  async function getPostWithSEO(slug) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_POST_WITH_SEO,
+      { post: null },
+      { slug },
+      ["wpgraphql", "gql-posts", "gql-yoast", `gql-post-${slug}`]
+    );
+    return data.post;
+  }
+  async function getPageWithSEO(slug) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_PAGE_WITH_SEO,
+      { page: null },
+      { slug },
+      ["wpgraphql", "gql-pages", "gql-yoast", `gql-page-${slug}`]
+    );
+    return data.page;
+  }
+  async function getPageWithSEOByUri(uri) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_PAGE_WITH_SEO_BY_URI,
+      { page: null },
+      { uri },
+      ["wpgraphql", "gql-pages", "gql-yoast", `gql-page-uri-${uri.replace(/\//g, "-")}`]
+    );
+    return data.page;
+  }
+  return { getPostWithSEO, getPageWithSEO, getPageWithSEOByUri };
+}
+
+// src/integrations/wpGraphQL/acf/helpers.ts
+var BASE_POST_FIELDS = `
+  id databaseId slug title content excerpt date modified status uri
+  author { node { databaseId name slug avatar { url } } }
+  featuredImage { node { sourceUrl altText mediaDetails { width height } } }
+  categories { nodes { databaseId name slug } }
+  tags { nodes { databaseId name slug } }
+`;
+var BASE_PAGE_FIELDS = `
+  id databaseId slug title content date modified status uri
+  featuredImage { node { sourceUrl altText mediaDetails { width height } } }
+`;
+function buildACFFragment(fieldGroupName, fields) {
+  return `${fieldGroupName} { ${fields.join(" ")} }`;
+}
+function buildPostWithACFQuery(fieldGroupName, fields) {
+  return `
+    query GetPostWithACF($slug: ID!) {
+      post(id: $slug, idType: SLUG) {
+        ${BASE_POST_FIELDS}
+        ${buildACFFragment(fieldGroupName, fields)}
+      }
+    }
+  `;
+}
+function buildPageWithACFQuery(fieldGroupName, fields) {
+  return `
+    query GetPageWithACF($slug: ID!) {
+      page(id: $slug, idType: SLUG) {
+        ${BASE_PAGE_FIELDS}
+        ${buildACFFragment(fieldGroupName, fields)}
+      }
+    }
+  `;
+}
+function buildPostsWithACFQuery(fieldGroupName, fields) {
+  return `
+    query GetPostsWithACF($first: Int, $after: String) {
+      posts(first: $first, after: $after) {
+        nodes {
+          ${BASE_POST_FIELDS}
+          ${buildACFFragment(fieldGroupName, fields)}
+        }
+        pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+      }
+    }
+  `;
+}
+
+// src/integrations/wpGraphQL/woocommerce/products/queries.ts
+var DEFAULT_FIRST7 = 10;
+var BATCH_FIRST3 = 100;
+var PRODUCT_FIELDS = `
+  id
+  databaseId
+  slug
+  name
+  status
+  description
+  shortDescription
+  type
+  onSale
+  featuredImage { node { sourceUrl altText } }
+  galleryImages { nodes { sourceUrl altText } }
+  productCategories { nodes { databaseId name slug } }
+  productTags { nodes { databaseId name slug } }
+  ... on SimpleProduct {
+    sku
+    price
+    regularPrice
+    salePrice
+    stockStatus
+    stockQuantity
+    manageStock
+  }
+  ... on VariableProduct {
+    price
+    regularPrice
+    salePrice
+    stockStatus
+    stockQuantity
+    manageStock
+    variations {
+      nodes {
+        id
+        databaseId
+        slug
+        sku
+        price
+        regularPrice
+        salePrice
+        onSale
+        stockStatus
+        stockQuantity
+        image { sourceUrl altText }
+        attributes { nodes { name value } }
+      }
+    }
+  }
+`;
+var GQL_GET_PRODUCTS = `
+  query GetProducts($first: Int, $after: String, $where: RootQueryToProductConnectionWhereArgs) {
+    products(first: $first, after: $after, where: $where) {
+      nodes { ${PRODUCT_FIELDS} }
+      pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+    }
+  }
+`;
+var GQL_GET_PRODUCT_BY_SLUG = `
+  query GetProductBySlug($slug: ID!) {
+    product(id: $slug, idType: SLUG) { ${PRODUCT_FIELDS} }
+  }
+`;
+var GQL_GET_PRODUCT_BY_DATABASE_ID = `
+  query GetProductByDatabaseId($id: ID!) {
+    product(id: $id, idType: DATABASE_ID) { ${PRODUCT_FIELDS} }
+  }
+`;
+var GQL_GET_ALL_PRODUCT_SLUGS = `
+  query GetAllProductSlugs($first: Int, $after: String) {
+    products(first: $first, after: $after) {
+      nodes { slug }
+      pageInfo { hasNextPage endCursor }
+    }
+  }
+`;
+function createProductsQueries2(fetcher) {
+  const { gqlFetch, gqlFetchGraceful } = fetcher;
+  async function getProducts(first = DEFAULT_FIRST7, after, filter) {
+    const where = {};
+    if (filter?.search) where["search"] = filter.search;
+    if (filter?.onSale !== void 0) where["onSale"] = filter.onSale;
+    if (filter?.featured !== void 0) where["featured"] = filter.featured;
+    if (filter?.stockStatus) where["stockStatus"] = filter.stockStatus;
+    if (filter?.minPrice) where["minPrice"] = filter.minPrice;
+    if (filter?.maxPrice) where["maxPrice"] = filter.maxPrice;
+    if (filter?.categoryId) where["categoryIdIn"] = [filter.categoryId];
+    if (filter?.tagId) where["tagIdIn"] = [filter.tagId];
+    const data = await gqlFetchGraceful(
+      GQL_GET_PRODUCTS,
+      { products: { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } } },
+      { first, after, where: Object.keys(where).length > 0 ? where : void 0 },
+      ["wpgraphql", "gql-products"]
+    );
+    return data.products;
+  }
+  async function getProductBySlug(slug) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_PRODUCT_BY_SLUG,
+      { product: null },
+      { slug },
+      ["wpgraphql", "gql-products", `gql-product-${slug}`]
+    );
+    return data.product;
+  }
+  async function getProductByDatabaseId(id) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_PRODUCT_BY_DATABASE_ID,
+      { product: null },
+      { id: String(id) },
+      ["wpgraphql", "gql-products", `gql-product-id-${id}`]
+    );
+    return data.product;
+  }
+  async function getFeaturedProducts(first = DEFAULT_FIRST7) {
+    const connection = await getProducts(first, void 0, { featured: true });
+    return connection.nodes;
+  }
+  async function getOnSaleProducts(first = DEFAULT_FIRST7) {
+    const connection = await getProducts(first, void 0, { onSale: true });
+    return connection.nodes;
+  }
+  async function getAllProductSlugs() {
+    try {
+      const all = [];
+      let after = void 0;
+      let hasNextPage = true;
+      while (hasNextPage) {
+        const data = await gqlFetch(GQL_GET_ALL_PRODUCT_SLUGS, { first: BATCH_FIRST3, after }, ["wpgraphql"]);
+        all.push(...data.products.nodes);
+        hasNextPage = data.products.pageInfo.hasNextPage;
+        after = data.products.pageInfo.endCursor;
+      }
+      return all;
+    } catch {
+      console.warn("WPGraphQL unavailable, skipping static generation for products");
+      return [];
+    }
+  }
+  return {
+    getProducts,
+    getProductBySlug,
+    getProductByDatabaseId,
+    getFeaturedProducts,
+    getOnSaleProducts,
+    getAllProductSlugs
+  };
+}
+
+// src/integrations/wpGraphQL/woocommerce/orders/queries.ts
+var DEFAULT_FIRST8 = 10;
+var ADDRESS_FIELDS = `
+  firstName lastName address1 address2 city postcode country email phone
+`;
+var ORDER_FIELDS = `
+  id
+  databaseId
+  orderNumber
+  status
+  date
+  modified
+  total
+  subtotal
+  totalTax
+  shippingTotal
+  currency
+  billing { ${ADDRESS_FIELDS} }
+  shipping { ${ADDRESS_FIELDS} }
+  lineItems {
+    nodes {
+      productId
+      variationId
+      quantity
+      subtotal
+      total
+      product { node { databaseId name slug } }
+    }
+  }
+`;
+var GQL_GET_ORDER = `
+  query GetOrder($id: ID!) {
+    order(id: $id, idType: DATABASE_ID) { ${ORDER_FIELDS} }
+  }
+`;
+var GQL_GET_MY_ORDERS = `
+  query GetMyOrders($first: Int, $after: String) {
+    orders(first: $first, after: $after) {
+      nodes { ${ORDER_FIELDS} }
+      pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+    }
+  }
+`;
+function createOrdersQueries2(fetcher) {
+  const { gqlFetchGraceful } = fetcher;
+  async function getOrder(id) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_ORDER,
+      { order: null },
+      { id: String(id) },
+      ["wpgraphql", "gql-orders", `gql-order-${id}`]
+    );
+    return data.order;
+  }
+  async function getMyOrders(first = DEFAULT_FIRST8, after) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_MY_ORDERS,
+      { orders: { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } } },
+      { first, after },
+      ["wpgraphql", "gql-orders"]
+    );
+    return data.orders;
+  }
+  return { getOrder, getMyOrders };
+}
+
+// src/integrations/wpGraphQL/woocommerce/customers/queries.ts
+var ADDRESS_FIELDS2 = `
+  firstName lastName address1 address2 city postcode country
+`;
+var CUSTOMER_FIELDS = `
+  id
+  databaseId
+  email
+  firstName
+  lastName
+  username
+  billing { ${ADDRESS_FIELDS2} phone }
+  shipping { ${ADDRESS_FIELDS2} }
+`;
+var GQL_GET_CUSTOMER = `
+  query GetCustomer {
+    customer { ${CUSTOMER_FIELDS} }
+  }
+`;
+var GQL_GET_CUSTOMER_BY_ID = `
+  query GetCustomerById($id: ID!) {
+    customer(customerId: $id) { ${CUSTOMER_FIELDS} }
+  }
+`;
+function createCustomersQueries2(fetcher) {
+  const { gqlFetchGraceful } = fetcher;
+  async function getCustomer() {
+    const data = await gqlFetchGraceful(
+      GQL_GET_CUSTOMER,
+      { customer: null },
+      void 0,
+      ["wpgraphql", "gql-customer"]
+    );
+    return data.customer;
+  }
+  async function getCustomerById(id) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_CUSTOMER_BY_ID,
+      { customer: null },
+      { id: String(id) },
+      ["wpgraphql", "gql-customer", `gql-customer-${id}`]
+    );
+    return data.customer;
+  }
+  return { getCustomer, getCustomerById };
+}
+
+// src/integrations/wpGraphQL/woocommerce/categories/queries.ts
+var DEFAULT_FIRST9 = 100;
+var CATEGORY_FIELDS2 = `
+  id
+  databaseId
+  name
+  slug
+  description
+  count
+  parent { node { id databaseId name slug } }
+  image { sourceUrl altText }
+`;
+var GQL_GET_PRODUCT_CATEGORIES = `
+  query GetProductCategories($first: Int, $after: String) {
+    productCategories(first: $first, after: $after) {
+      nodes { ${CATEGORY_FIELDS2} }
+      pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+    }
+  }
+`;
+var GQL_GET_PRODUCT_CATEGORY_BY_SLUG = `
+  query GetProductCategoryBySlug($id: ID!) {
+    productCategory(id: $id, idType: SLUG) { ${CATEGORY_FIELDS2} }
+  }
+`;
+var GQL_GET_PRODUCT_CATEGORY_BY_ID = `
+  query GetProductCategoryById($id: ID!) {
+    productCategory(id: $id, idType: DATABASE_ID) { ${CATEGORY_FIELDS2} }
+  }
+`;
+function createCategoriesQueries4(fetcher) {
+  const { gqlFetchGraceful } = fetcher;
+  async function getProductCategories(first = DEFAULT_FIRST9, after) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_PRODUCT_CATEGORIES,
+      { productCategories: { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } } },
+      { first, after },
+      ["wpgraphql", "gql-product-categories"]
+    );
+    return data.productCategories;
+  }
+  async function getProductCategoryBySlug(slug) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_PRODUCT_CATEGORY_BY_SLUG,
+      { productCategory: null },
+      { id: slug },
+      ["wpgraphql", "gql-product-categories", `gql-product-category-${slug}`]
+    );
+    return data.productCategory;
+  }
+  async function getProductCategoryById(id) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_PRODUCT_CATEGORY_BY_ID,
+      { productCategory: null },
+      { id: String(id) },
+      ["wpgraphql", "gql-product-categories", `gql-product-category-${id}`]
+    );
+    return data.productCategory;
+  }
+  return { getProductCategories, getProductCategoryBySlug, getProductCategoryById };
+}
+
+// src/integrations/wpGraphQL/woocommerce/tags/queries.ts
+var DEFAULT_FIRST10 = 100;
+var TAG_FIELDS2 = `
+  id
+  databaseId
+  name
+  slug
+  description
+  count
+`;
+var GQL_GET_PRODUCT_TAGS = `
+  query GetProductTags($first: Int, $after: String) {
+    productTags(first: $first, after: $after) {
+      nodes { ${TAG_FIELDS2} }
+      pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+    }
+  }
+`;
+var GQL_GET_PRODUCT_TAG_BY_SLUG = `
+  query GetProductTagBySlug($id: ID!) {
+    productTag(id: $id, idType: SLUG) { ${TAG_FIELDS2} }
+  }
+`;
+var GQL_GET_PRODUCT_TAG_BY_ID = `
+  query GetProductTagById($id: ID!) {
+    productTag(id: $id, idType: DATABASE_ID) { ${TAG_FIELDS2} }
+  }
+`;
+function createTagsQueries4(fetcher) {
+  const { gqlFetchGraceful } = fetcher;
+  async function getProductTags(first = DEFAULT_FIRST10, after) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_PRODUCT_TAGS,
+      { productTags: { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } } },
+      { first, after },
+      ["wpgraphql", "gql-product-tags"]
+    );
+    return data.productTags;
+  }
+  async function getProductTagBySlug(slug) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_PRODUCT_TAG_BY_SLUG,
+      { productTag: null },
+      { id: slug },
+      ["wpgraphql", "gql-product-tags", `gql-product-tag-${slug}`]
+    );
+    return data.productTag;
+  }
+  async function getProductTagById(id) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_PRODUCT_TAG_BY_ID,
+      { productTag: null },
+      { id: String(id) },
+      ["wpgraphql", "gql-product-tags", `gql-product-tag-${id}`]
+    );
+    return data.productTag;
+  }
+  return { getProductTags, getProductTagBySlug, getProductTagById };
+}
+
+// src/integrations/wpGraphQL/woocommerce/coupons/queries.ts
+var DEFAULT_FIRST11 = 100;
+var COUPON_FIELDS = `
+  id
+  databaseId
+  code
+  discountType
+  amount
+  dateExpiry
+  usageCount
+  usageLimit
+  usageLimitPerUser
+  individualUse
+  freeShipping
+  minimumAmount
+  maximumAmount
+  description
+`;
+var GQL_GET_COUPONS = `
+  query GetCoupons($first: Int, $after: String) {
+    coupons(first: $first, after: $after) {
+      nodes { ${COUPON_FIELDS} }
+      pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+    }
+  }
+`;
+var GQL_GET_COUPON_BY_CODE = `
+  query GetCouponByCode($id: ID!) {
+    coupon(id: $id, idType: CODE) { ${COUPON_FIELDS} }
+  }
+`;
+var GQL_GET_COUPON_BY_ID = `
+  query GetCouponById($id: ID!) {
+    coupon(id: $id, idType: DATABASE_ID) { ${COUPON_FIELDS} }
+  }
+`;
+function createCouponsQueries2(fetcher) {
+  const { gqlFetchGraceful } = fetcher;
+  async function getCoupons(first = DEFAULT_FIRST11, after) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_COUPONS,
+      { coupons: { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } } },
+      { first, after },
+      ["wpgraphql", "gql-coupons"]
+    );
+    return data.coupons;
+  }
+  async function getCouponByCode(code) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_COUPON_BY_CODE,
+      { coupon: null },
+      { id: code },
+      ["wpgraphql", "gql-coupons", `gql-coupon-${code}`]
+    );
+    return data.coupon;
+  }
+  async function getCouponById(id) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_COUPON_BY_ID,
+      { coupon: null },
+      { id: String(id) },
+      ["wpgraphql", "gql-coupons", `gql-coupon-${id}`]
+    );
+    return data.coupon;
+  }
+  return { getCoupons, getCouponByCode, getCouponById };
+}
+
+// src/integrations/wpGraphQL/woocommerce/index.ts
+function createWPGraphQLWooCommerceClient(config) {
+  const fetcher = createWPGraphQLFetcher(config);
+  return {
+    ...createProductsQueries2(fetcher),
+    ...createOrdersQueries2(fetcher),
+    ...createCustomersQueries2(fetcher),
+    ...createCategoriesQueries4(fetcher),
+    ...createTagsQueries4(fetcher),
+    ...createCouponsQueries2(fetcher)
+  };
+}
+
+// src/integrations/wpGraphQL/cpt/queries.ts
+var DEFAULT_FIRST12 = 10;
+var BATCH_FIRST4 = 100;
+var BASE_CPT_FIELDS = `
+  id databaseId slug title date modified status uri
+`;
+function createCPTQueries(fetcher, typeName, singularTypeName, extraFields) {
+  const { gqlFetch, gqlFetchGraceful } = fetcher;
+  const fields = extraFields ? `${BASE_CPT_FIELDS} ${extraFields}` : BASE_CPT_FIELDS;
+  const GQL_GET_ITEMS = `
+    query GetCPT_${typeName}($first: Int, $after: String) {
+      ${typeName}(first: $first, after: $after) {
+        nodes { ${fields} }
+        pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+      }
+    }
+  `;
+  const GQL_GET_ITEM_BY_SLUG = `
+    query GetCPT_${singularTypeName}BySlug($slug: ID!) {
+      ${singularTypeName}(id: $slug, idType: SLUG) { ${fields} }
+    }
+  `;
+  const GQL_GET_ALL_SLUGS = `
+    query GetAllCPT_${typeName}Slugs($first: Int, $after: String) {
+      ${typeName}(first: $first, after: $after) {
+        nodes { slug }
+        pageInfo { hasNextPage endCursor }
+      }
+    }
+  `;
+  async function getItems(first = DEFAULT_FIRST12, after) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_ITEMS,
+      { [typeName]: { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } } },
+      { first, after },
+      ["wpgraphql", `gql-${typeName}`]
+    );
+    return data[typeName] ?? { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } };
+  }
+  async function getItemBySlug(slug) {
+    const data = await gqlFetchGraceful(
+      GQL_GET_ITEM_BY_SLUG,
+      { [singularTypeName]: null },
+      { slug },
+      ["wpgraphql", `gql-${typeName}`, `gql-${singularTypeName}-${slug}`]
+    );
+    return data[singularTypeName] ?? null;
+  }
+  async function getAllSlugs() {
+    try {
+      const all = [];
+      let after = void 0;
+      let hasNextPage = true;
+      while (hasNextPage) {
+        const data = await gqlFetch(GQL_GET_ALL_SLUGS, { first: BATCH_FIRST4, after }, ["wpgraphql"]);
+        const connection = data[typeName];
+        if (!connection) break;
+        all.push(...connection.nodes);
+        hasNextPage = connection.pageInfo.hasNextPage;
+        after = connection.pageInfo.endCursor;
+      }
+      return all;
+    } catch {
+      console.warn(`WPGraphQL unavailable, skipping static generation for ${typeName}`);
+      return [];
+    }
+  }
+  return { getItems, getItemBySlug, getAllSlugs };
+}
+
+// src/nextjs/revalidation.ts
+var ACTION_TAG_MAP = {
+  save_post: ["wordpress", "posts"],
+  save_post_post: ["wordpress", "posts"],
+  save_post_page: ["wordpress", "pages"],
+  delete_post: ["wordpress", "posts", "pages"],
+  created_term: ["wordpress", "categories", "tags"],
+  edited_term: ["wordpress", "categories", "tags"],
+  delete_term: ["wordpress", "categories", "tags"],
+  wp_update_nav_menu: ["wordpress", "menus"],
+  woocommerce_product_updated: ["woocommerce", "products"],
+  woocommerce_new_product: ["woocommerce", "products"],
+  woocommerce_delete_product: ["woocommerce", "products"],
+  woocommerce_new_order: ["woocommerce", "orders"],
+  woocommerce_order_status_changed: ["woocommerce", "orders"],
+  woocommerce_update_order: ["woocommerce", "orders"],
+  woocommerce_product_category_updated: ["woocommerce", "categories"],
+  woocommerce_product_tag_updated: ["woocommerce", "tags"]
+};
+function extractSecret(request) {
+  const auth = request.headers.get("Authorization");
+  if (auth?.startsWith("Bearer ")) return auth.slice(7);
+  return new URL(request.url).searchParams.get("secret");
+}
+function createRevalidationHandler(config, revalidateTag) {
+  return async function handler(request) {
+    if (extractSecret(request) !== config.secret) {
+      return Response.json({ revalidated: false, tags: [], message: "Unauthorized" }, { status: 401 });
+    }
+    let payload;
+    try {
+      payload = await request.json();
+    } catch {
+      return Response.json({ revalidated: false, tags: [], message: "Invalid JSON body" }, { status: 400 });
+    }
+    const { action } = payload;
+    const matched = ACTION_TAG_MAP[action];
+    if (!matched) {
+      return Response.json(
+        { revalidated: false, tags: [], message: `Unknown action: ${action}` },
+        { status: 400 }
+      );
+    }
+    const tags = [...new Set(matched)];
+    for (const tag of tags) {
+      revalidateTag(tag);
+    }
+    return Response.json({ revalidated: true, tags });
+  };
+}
+
+// src/nextjs/faust.ts
+function createFaustAuthHandler(config) {
+  const cookieName = config.cookieName ?? "faustwp-rt";
+  return async function handler(request, routePath) {
+    if (routePath === "auth/token") {
+      const url = new URL(request.url);
+      const code = url.searchParams.get("code");
+      const redirectUri = url.searchParams.get("redirect_uri") ?? "/";
+      const refreshToken = parseCookie(request, cookieName);
+      if (!code && !refreshToken) {
+        return Response.json({ error: "Unauthorized" }, { status: 401 });
+      }
+      const wpRes = await fetch(`${config.wpUrl}/?rest_route=/faustwp/v1/authorize`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-faustwp-secret": config.secretKey
+        },
+        body: JSON.stringify({ code, refreshToken })
+      });
+      if (!wpRes.ok) {
+        const body = await wpRes.text();
+        return new Response(body, { status: wpRes.status });
+      }
+      const data = await wpRes.json();
+      return new Response(null, {
+        status: 302,
+        headers: {
+          Location: new URL(redirectUri, request.url).toString(),
+          "Set-Cookie": buildSetCookie(cookieName, data.refreshToken, 2592e3)
+        }
+      });
+    }
+    if (routePath === "auth/logout") {
+      return new Response(JSON.stringify({}), {
+        status: 200,
+        headers: {
+          "Content-Type": "application/json",
+          "Set-Cookie": `${cookieName}=; Max-Age=0; Path=/; HttpOnly`
+        }
+      });
+    }
+    return Response.json({ error: "Not Found" }, { status: 404 });
+  };
+}
+function createPreviewHandler(config, deps) {
+  const previewPath = config.previewPath ?? "posts";
+  return async function handler(request) {
+    const url = new URL(request.url);
+    const postId = url.searchParams.get("postId");
+    const previewPathname = url.searchParams.get("previewPathname");
+    if (!postId) {
+      return new Response("Missing postId", { status: 400 });
+    }
+    const slug = await resolvePreviewSlug(config, postId, previewPathname);
+    if (!slug) {
+      return new Response("Post not found", { status: 404 });
+    }
+    await deps.enableDraftMode();
+    deps.redirect(`/${previewPath}/${slug}?postId=${postId}`);
+  };
+}
+function parseCookie(request, name) {
+  const header = request.headers.get("cookie") ?? "";
+  const match = header.match(new RegExp(`(?:^|;\\s*)${name}=([^;]*)`));
+  return match?.[1];
+}
+function buildSetCookie(name, value, maxAge) {
+  const secure = process.env.NODE_ENV === "production" ? "; Secure" : "";
+  return `${name}=${value}; HttpOnly; Path=/; SameSite=Strict; Max-Age=${maxAge}${secure}`;
+}
+async function resolvePreviewSlug(config, postId, previewPathname) {
+  if (previewPathname && !previewPathname.includes("p=")) {
+    const slug = previewPathname.replace(/\/$/, "").split("/").pop();
+    if (slug) return slug;
+  }
+  const res = await fetch(`${config.wpUrl}/wp-json/wp/v2/posts/${postId}?_fields=slug`, {
+    headers: { "x-faustwp-secret": config.secretKey },
+    cache: "no-store"
+  });
+  if (!res.ok) return null;
+  const data = await res.json();
+  return data.slug ?? `preview-${postId}`;
+}
+
+// src/auth/applicationPassword.ts
+function createApplicationPasswordToken(username, appPassword) {
+  const encoded = Buffer.from(`${username}:${appPassword}`).toString("base64");
+  return `Basic ${encoded}`;
+}
+
+// src/auth/types.ts
+var AuthenticationError = class extends Error {
+  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, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(credentials),
+    cache: "no-store"
+  });
+  if (!response.ok) {
+    const code = resolveAuthErrorCode(response.status);
+    throw new AuthenticationError(
+      code,
+      response.status,
+      resolveMessage(code, config.errorMessages),
+      response.statusText
+    );
+  }
+  return response.json();
+}
+async function validateJwtToken(config, token) {
+  const url = `${resolveBaseUrl(config)}/wp-json/jwt-auth/v1/token/validate`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}` },
+    cache: "no-store"
+  });
+  return response.ok;
+}
+
+exports.AuthenticationError = AuthenticationError;
+exports.ErrorCode = ErrorCode;
+exports.WPGraphQLError = WPGraphQLError;
+exports.WooCommerceError = WooCommerceError;
+exports.WordPressAPIError = WordPressAPIError;
+exports.authenticateJwt = authenticateJwt;
+exports.buildACFFragment = buildACFFragment;
+exports.buildPageWithACFQuery = buildPageWithACFQuery;
+exports.buildPostWithACFQuery = buildPostWithACFQuery;
+exports.buildPostsWithACFQuery = buildPostsWithACFQuery;
+exports.createApplicationPasswordToken = createApplicationPasswordToken;
+exports.createAuthorsMutations = createAuthorsMutations;
+exports.createCF7Queries = createCF7Queries;
+exports.createCPTQueries = createCPTQueries;
+exports.createCategoriesMutations = createCategoriesMutations;
+exports.createCommentsMutations = createCommentsMutations;
+exports.createFaustAuthHandler = createFaustAuthHandler;
+exports.createMediaMutations = createMediaMutations;
+exports.createMenusMutations = createMenusMutations;
+exports.createPagesMutations = createPagesMutations;
+exports.createPostsMutations = createPostsMutations;
+exports.createPreviewHandler = createPreviewHandler;
+exports.createRevalidationHandler = createRevalidationHandler;
+exports.createTagsMutations = createTagsMutations;
+exports.createWPGraphQLClient = createWPGraphQLCoreClient;
+exports.createWPGraphQLCoreClient = createWPGraphQLCoreClient;
+exports.createWPGraphQLFetcher = createWPGraphQLFetcher;
+exports.createWPGraphQLMutationsClient = createWPGraphQLMutationsClient;
+exports.createWPGraphQLWooCommerceClient = createWPGraphQLWooCommerceClient;
+exports.createWPULikeClient = createWPULikeClient;
+exports.createWPULikeQueries = createWPULikeQueries;
+exports.createWooCommerceClient = createWooCommerceClient;
+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;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map