@szymonpiatek/nextwordpress 0.0.3 → 0.0.5

package/dist/index.cjs

@@ -87,20 +87,261 @@ function createFetcher(config) {
       return empty;
     }
   }
-  async function wpMutate(path, body, method = "POST") {
+  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;
+    }
     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-Type": "application/json",
-        "User-Agent": USER_AGENT
+        "Content-Disposition": `attachment; filename="${filename}"`,
+        "Content-Type": mimeType,
+        "User-Agent": USER_AGENT,
+        "Authorization": authToken
       },
-      body: JSON.stringify(body),
+      body: file,
       cache: "no-store"
     });
     return await res.json();
   }
-  return { wpFetch, wpFetchGraceful, wpFetchPaginated, wpFetchPaginatedGraceful, wpMutate };
+  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/v2/posts", input, "POST", authToken);
+  }
+  async function updatePost(id, input, authToken) {
+    return wpMutate(`/wp/v2/posts/${id}`, input, "PATCH", authToken);
+  }
+  async function deletePost(id, authToken, force = false) {
+    return wpMutate(
+      `/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/v2/comments", input, "POST", authToken);
+  }
+  async function updateComment(id, input, authToken) {
+    return wpMutate(`/wp/v2/comments/${id}`, input, "PATCH", authToken);
+  }
+  async function deleteComment(id, authToken, force = false) {
+    return wpMutate(
+      `/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/v2/pages", input, "POST", authToken);
+  }
+  async function updatePage(id, input, authToken) {
+    return wpMutate(`/wp/v2/pages/${id}`, input, "PATCH", authToken);
+  }
+  async function deletePage(id, authToken, force = false) {
+    return wpMutate(
+      `/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/v2/categories", input, "POST", authToken);
+  }
+  async function updateCategory(id, input, authToken) {
+    return wpMutate(`/wp/v2/categories/${id}`, input, "PATCH", authToken);
+  }
+  async function deleteCategory(id, authToken, force = false) {
+    return wpMutate(
+      `/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/v2/tags", input, "POST", authToken);
+  }
+  async function updateTag(id, input, authToken) {
+    return wpMutate(`/wp/v2/tags/${id}`, input, "PATCH", authToken);
+  }
+  async function deleteTag(id, authToken, force = false) {
+    return wpMutate(
+      `/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/v2/users", input, "POST", authToken);
+  }
+  async function updateAuthor(id, input, authToken) {
+    return wpMutate(`/wp/v2/users/${id}`, input, "PATCH", authToken);
+  }
+  async function deleteAuthor(id, authToken, reassign) {
+    return wpMutate(
+      `/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/v2/menus", input, "POST", authToken);
+  }
+  async function updateMenu(id, input, authToken) {
+    return wpMutate(`/wp/v2/menus/${id}`, input, "PATCH", authToken);
+  }
+  async function deleteMenu(id, authToken) {
+    return wpMutate(
+      `/wp/v2/menus/${id}`,
+      {},
+      "DELETE",
+      authToken
+    );
+  }
+  async function createMenuItem(input, authToken) {
+    return wpMutate("/wp/v2/menu-items", input, "POST", authToken);
+  }
+  async function updateMenuItem(id, input, authToken) {
+    return wpMutate(`/wp/v2/menu-items/${id}`, input, "PATCH", authToken);
+  }
+  async function deleteMenuItem(id, authToken, force = false) {
+    return wpMutate(
+      `/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/v2/media",
+      input.file,
+      input.filename,
+      input.mimeType,
+      authToken
+    );
+    if (input.title || input.caption || input.alt_text) {
+      return wpMutate(
+        `/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/v2/media/${id}`, input, "PATCH", authToken);
+  }
+  async function deleteMedia(id, authToken, force = true) {
+    return wpMutate(
+      `/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
@@ -678,6 +919,25 @@ function createProductsQueries(fetcher) {
   };
 }
 
+// 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;
@@ -727,6 +987,29 @@ function createCategoriesQueries2(fetcher) {
   };
 }
 
+// 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;
@@ -760,6 +1043,25 @@ function createTagsQueries2(fetcher) {
   };
 }
 
+// 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;
@@ -784,11 +1086,19 @@ function createOrdersQueries(fetcher) {
       ["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
+    getOrdersByCustomer,
+    deleteOrder
   };
 }
 
@@ -822,9 +1132,28 @@ function createCouponsQueries(fetcher) {
   };
 }
 
+// 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 } = fetcher;
+  const { wcFetch, wcFetchGraceful, wcMutate } = fetcher;
   async function getCustomerById(id) {
     return wcFetch(`/wp-json/wc/v3/customers/${id}`, void 0, [
       "woocommerce",
@@ -862,11 +1191,23 @@ function createCustomersQueries(fetcher) {
       { 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
+    createCustomer,
+    updateCustomer,
+    deleteCustomer
   };
 }
 
@@ -875,10 +1216,14 @@ function createWooCommerceClient(config) {
   const fetcher = createWooCommerceFetcher(config);
   return {
     ...createProductsQueries(fetcher),
+    ...createProductsMutations(fetcher),
     ...createCategoriesQueries2(fetcher),
+    ...createCategoriesMutations2(fetcher),
     ...createTagsQueries2(fetcher),
+    ...createTagsMutations2(fetcher),
     ...createOrdersQueries(fetcher),
     ...createCouponsQueries(fetcher),
+    ...createCouponsMutations(fetcher),
     ...createCustomersQueries(fetcher)
   };
 }
@@ -938,7 +1283,42 @@ function createWPGraphQLFetcher(config) {
       return fallback;
     }
   }
-  return { gqlFetch, gqlFetchGraceful };
+  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(
+        `WPGraphQL mutation failed: ${response.statusText}`,
+        response.status,
+        url
+      );
+    }
+    const parsed = await response.json();
+    if (parsed.errors && parsed.errors.length > 0) {
+      throw new WPGraphQLError(
+        parsed.errors[0].message,
+        200,
+        url,
+        parsed.errors
+      );
+    }
+    if (parsed.data === void 0) {
+      throw new WPGraphQLError("No data returned from WPGraphQL mutation", 200, url);
+    }
+    return parsed.data;
+  }
+  return { gqlFetch, gqlFetchGraceful, gqlMutate };
 }
 
 // src/integrations/wpGraphQL/core/posts/queries.ts
@@ -1546,6 +1926,518 @@ function createCommentsQueries2(fetcher) {
   };
 }
 
+// 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);
@@ -1556,7 +2448,8 @@ function createWPGraphQLCoreClient(config) {
     ...createTagsQueries3(fetcher),
     ...createAuthorsQueries2(fetcher),
     ...createMenusQueries2(fetcher),
-    ...createCommentsQueries2(fetcher)
+    ...createCommentsQueries2(fetcher),
+    ...createMediaQueries2(fetcher)
   };
 }
 
@@ -1725,7 +2618,7 @@ function buildPostsWithACFQuery(fieldGroupName, fields) {
 }
 
 // src/integrations/wpGraphQL/woocommerce/products/queries.ts
-var DEFAULT_FIRST6 = 10;
+var DEFAULT_FIRST7 = 10;
 var BATCH_FIRST3 = 100;
 var PRODUCT_FIELDS = `
   id
@@ -1803,7 +2696,7 @@ var GQL_GET_ALL_PRODUCT_SLUGS = `
 `;
 function createProductsQueries2(fetcher) {
   const { gqlFetch, gqlFetchGraceful } = fetcher;
-  async function getProducts(first = DEFAULT_FIRST6, after, filter) {
+  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;
@@ -1839,11 +2732,11 @@ function createProductsQueries2(fetcher) {
     );
     return data.product;
   }
-  async function getFeaturedProducts(first = DEFAULT_FIRST6) {
+  async function getFeaturedProducts(first = DEFAULT_FIRST7) {
     const connection = await getProducts(first, void 0, { featured: true });
     return connection.nodes;
   }
-  async function getOnSaleProducts(first = DEFAULT_FIRST6) {
+  async function getOnSaleProducts(first = DEFAULT_FIRST7) {
     const connection = await getProducts(first, void 0, { onSale: true });
     return connection.nodes;
   }
@@ -1875,7 +2768,7 @@ function createProductsQueries2(fetcher) {
 }
 
 // src/integrations/wpGraphQL/woocommerce/orders/queries.ts
-var DEFAULT_FIRST7 = 10;
+var DEFAULT_FIRST8 = 10;
 var ADDRESS_FIELDS = `
   firstName lastName address1 address2 city postcode country email phone
 `;
@@ -1928,7 +2821,7 @@ function createOrdersQueries2(fetcher) {
     );
     return data.order;
   }
-  async function getMyOrders(first = DEFAULT_FIRST7, after) {
+  async function getMyOrders(first = DEFAULT_FIRST8, after) {
     const data = await gqlFetchGraceful(
       GQL_GET_MY_ORDERS,
       { orders: { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } } },
@@ -1987,18 +2880,211 @@ function createCustomersQueries2(fetcher) {
   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)
+    ...createCustomersQueries2(fetcher),
+    ...createCategoriesQueries4(fetcher),
+    ...createTagsQueries4(fetcher),
+    ...createCouponsQueries2(fetcher)
   };
 }
 
 // src/integrations/wpGraphQL/cpt/queries.ts
-var DEFAULT_FIRST8 = 10;
+var DEFAULT_FIRST12 = 10;
 var BATCH_FIRST4 = 100;
 var BASE_CPT_FIELDS = `
   id databaseId slug title date modified status uri
@@ -2027,7 +3113,7 @@ function createCPTQueries(fetcher, typeName, singularTypeName, extraFields) {
       }
     }
   `;
-  async function getItems(first = DEFAULT_FIRST8, after) {
+  async function getItems(first = DEFAULT_FIRST12, after) {
     const data = await gqlFetchGraceful(
       GQL_GET_ITEMS,
       { [typeName]: { nodes: [], pageInfo: { hasNextPage: false, hasPreviousPage: false } } },
@@ -2067,22 +3153,218 @@ function createCPTQueries(fetcher, typeName, singularTypeName, extraFields) {
   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(message, status) {
+    super(message);
+    __publicField(this, "status", status);
+    this.name = "AuthenticationError";
+  }
+};
+
+// src/auth/jwt.ts
+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) {
+    throw new AuthenticationError(
+      `JWT authentication failed: ${response.statusText}`,
+      response.status
+    );
+  }
+  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.WPGraphQLError = WPGraphQLError;
+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.createWooCommerceClient = createWooCommerceClient;
 exports.createWooCommerceFetcher = createWooCommerceFetcher;
 exports.createWordPressClient = createWordPressClient;
+exports.createWordPressMutationsClient = createWordPressMutationsClient;
 exports.createYoastQueries = createYoastQueries;
 exports.extractOmnibusData = extractOmnibusData;
 exports.resolveBaseUrl = resolveBaseUrl;
+exports.validateJwtToken = validateJwtToken;
 exports.withOmnibus = withOmnibus;
 exports.withOmnibusVariation = withOmnibusVariation;
 //# sourceMappingURL=index.cjs.map