claude-plugin-wordpress-manager 1.7.2 → 1.8.0

package/servers/wp-rest-bridge/build/tools/index.js

@@ -6,6 +6,12 @@ import { userTools, userHandlers } from './users.js';
 import { pluginRepositoryTools, pluginRepositoryHandlers } from './plugin-repository.js';
 import { commentTools, commentHandlers } from './comments.js';
 import { searchTools, searchHandlers } from './search.js';
+import { wcProductTools, wcProductHandlers } from './wc-products.js';
+import { wcOrderTools, wcOrderHandlers } from './wc-orders.js';
+import { wcCustomerTools, wcCustomerHandlers } from './wc-customers.js';
+import { wcCouponTools, wcCouponHandlers } from './wc-coupons.js';
+import { wcReportTools, wcReportHandlers } from './wc-reports.js';
+import { wcSettingTools, wcSettingHandlers } from './wc-settings.js';
 // Combine all tools
 export const allTools = [
     ...unifiedContentTools, // 8 tools
@@ -15,7 +21,13 @@ export const allTools = [
     ...userTools, // 6 tools
     ...pluginRepositoryTools, // 2 tools
     ...commentTools, // 5 tools
-    ...searchTools // 1 tool
+    ...searchTools, // 1 tool
+    ...wcProductTools, // 7 tools
+    ...wcOrderTools, // 6 tools
+    ...wcCustomerTools, // 4 tools
+    ...wcCouponTools, // 4 tools
+    ...wcReportTools, // 5 tools
+    ...wcSettingTools, // 4 tools
 ];
 // Combine all handlers
 export const toolHandlers = {
@@ -26,5 +38,11 @@ export const toolHandlers = {
     ...userHandlers,
     ...pluginRepositoryHandlers,
     ...commentHandlers,
-    ...searchHandlers
+    ...searchHandlers,
+    ...wcProductHandlers,
+    ...wcOrderHandlers,
+    ...wcCustomerHandlers,
+    ...wcCouponHandlers,
+    ...wcReportHandlers,
+    ...wcSettingHandlers,
 };

package/servers/wp-rest-bridge/build/tools/wc-coupons.d.ts

@@ -0,0 +1,144 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+declare const wcListCouponsSchema: z.ZodObject<{
+    per_page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    search: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    page: number;
+    per_page: number;
+    search?: string | undefined;
+}, {
+    page?: number | undefined;
+    per_page?: number | undefined;
+    search?: string | undefined;
+}>;
+declare const wcGetCouponSchema: z.ZodObject<{
+    id: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    id: number;
+}, {
+    id: number;
+}>;
+declare const wcCreateCouponSchema: z.ZodObject<{
+    code: z.ZodString;
+    discount_type: z.ZodDefault<z.ZodOptional<z.ZodEnum<["percent", "fixed_cart", "fixed_product"]>>>;
+    amount: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    date_expires: z.ZodOptional<z.ZodString>;
+    individual_use: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    product_ids: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    usage_limit: z.ZodOptional<z.ZodNumber>;
+    usage_limit_per_user: z.ZodOptional<z.ZodNumber>;
+    minimum_amount: z.ZodOptional<z.ZodString>;
+    maximum_amount: z.ZodOptional<z.ZodString>;
+    free_shipping: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strict", z.ZodTypeAny, {
+    code: string;
+    amount: string;
+    discount_type: "percent" | "fixed_cart" | "fixed_product";
+    individual_use: boolean;
+    free_shipping: boolean;
+    description?: string | undefined;
+    date_expires?: string | undefined;
+    product_ids?: number[] | undefined;
+    usage_limit?: number | undefined;
+    usage_limit_per_user?: number | undefined;
+    minimum_amount?: string | undefined;
+    maximum_amount?: string | undefined;
+}, {
+    code: string;
+    amount: string;
+    description?: string | undefined;
+    discount_type?: "percent" | "fixed_cart" | "fixed_product" | undefined;
+    date_expires?: string | undefined;
+    individual_use?: boolean | undefined;
+    product_ids?: number[] | undefined;
+    usage_limit?: number | undefined;
+    usage_limit_per_user?: number | undefined;
+    minimum_amount?: string | undefined;
+    maximum_amount?: string | undefined;
+    free_shipping?: boolean | undefined;
+}>;
+declare const wcDeleteCouponSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    force: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strict", z.ZodTypeAny, {
+    id: number;
+    force: boolean;
+}, {
+    id: number;
+    force?: boolean | undefined;
+}>;
+export declare const wcCouponTools: Tool[];
+export declare const wcCouponHandlers: {
+    wc_list_coupons: (params: z.infer<typeof wcListCouponsSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    wc_get_coupon: (params: z.infer<typeof wcGetCouponSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    wc_create_coupon: (params: z.infer<typeof wcCreateCouponSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    wc_delete_coupon: (params: z.infer<typeof wcDeleteCouponSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+};
+export {};

package/servers/wp-rest-bridge/build/tools/wc-coupons.js

@@ -0,0 +1,92 @@
+import { makeWooCommerceRequest } from '../wordpress.js';
+import { z } from 'zod';
+const wcListCouponsSchema = z.object({
+    per_page: z.number().optional().default(10).describe("Results per page (1-100)"),
+    page: z.number().optional().default(1).describe("Page number"),
+    search: z.string().optional().describe("Search coupons by code"),
+}).strict();
+const wcGetCouponSchema = z.object({
+    id: z.number().describe("Coupon ID"),
+}).strict();
+const wcCreateCouponSchema = z.object({
+    code: z.string().describe("Coupon code (unique)"),
+    discount_type: z.enum(['percent', 'fixed_cart', 'fixed_product']).optional().default('fixed_cart').describe("Discount type"),
+    amount: z.string().describe("Discount amount (e.g. '10' for 10% or $10)"),
+    description: z.string().optional().describe("Coupon description"),
+    date_expires: z.string().optional().describe("Expiration date (ISO 8601)"),
+    individual_use: z.boolean().optional().default(false).describe("Cannot combine with other coupons"),
+    product_ids: z.array(z.number()).optional().describe("Products this coupon applies to"),
+    usage_limit: z.number().optional().describe("Total usage limit"),
+    usage_limit_per_user: z.number().optional().describe("Per-user usage limit"),
+    minimum_amount: z.string().optional().describe("Minimum order amount required"),
+    maximum_amount: z.string().optional().describe("Maximum order amount allowed"),
+    free_shipping: z.boolean().optional().default(false).describe("Grants free shipping"),
+}).strict();
+const wcDeleteCouponSchema = z.object({
+    id: z.number().describe("Coupon ID to delete"),
+    force: z.boolean().optional().default(false).describe("True to permanently delete"),
+}).strict();
+export const wcCouponTools = [
+    {
+        name: "wc_list_coupons",
+        description: "Lists WooCommerce coupons with search and pagination",
+        inputSchema: { type: "object", properties: wcListCouponsSchema.shape },
+    },
+    {
+        name: "wc_get_coupon",
+        description: "Retrieves a WooCommerce coupon by ID with usage stats",
+        inputSchema: { type: "object", properties: wcGetCouponSchema.shape },
+    },
+    {
+        name: "wc_create_coupon",
+        description: "Creates a new WooCommerce coupon with discount rules",
+        inputSchema: { type: "object", properties: wcCreateCouponSchema.shape },
+    },
+    {
+        name: "wc_delete_coupon",
+        description: "Deletes a WooCommerce coupon",
+        inputSchema: { type: "object", properties: wcDeleteCouponSchema.shape },
+    },
+];
+export const wcCouponHandlers = {
+    wc_list_coupons: async (params) => {
+        try {
+            const response = await makeWooCommerceRequest("GET", "coupons", params);
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error listing coupons: ${errorMessage}` }] } };
+        }
+    },
+    wc_get_coupon: async (params) => {
+        try {
+            const response = await makeWooCommerceRequest("GET", `coupons/${params.id}`);
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error retrieving coupon: ${errorMessage}` }] } };
+        }
+    },
+    wc_create_coupon: async (params) => {
+        try {
+            const response = await makeWooCommerceRequest("POST", "coupons", params);
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error creating coupon: ${errorMessage}` }] } };
+        }
+    },
+    wc_delete_coupon: async (params) => {
+        try {
+            const response = await makeWooCommerceRequest("DELETE", `coupons/${params.id}`, { force: params.force });
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error deleting coupon: ${errorMessage}` }] } };
+        }
+    },
+};

package/servers/wp-rest-bridge/build/tools/wc-customers.d.ts

@@ -0,0 +1,141 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+declare const wcListCustomersSchema: z.ZodObject<{
+    per_page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    search: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+    role: z.ZodDefault<z.ZodOptional<z.ZodEnum<["all", "administrator", "editor", "author", "contributor", "subscriber", "customer"]>>>;
+    orderby: z.ZodOptional<z.ZodEnum<["id", "name", "registered_date"]>>;
+    order: z.ZodDefault<z.ZodOptional<z.ZodEnum<["asc", "desc"]>>>;
+}, "strict", z.ZodTypeAny, {
+    page: number;
+    per_page: number;
+    order: "asc" | "desc";
+    role: "author" | "customer" | "all" | "administrator" | "editor" | "contributor" | "subscriber";
+    search?: string | undefined;
+    orderby?: "id" | "name" | "registered_date" | undefined;
+    email?: string | undefined;
+}, {
+    page?: number | undefined;
+    per_page?: number | undefined;
+    search?: string | undefined;
+    orderby?: "id" | "name" | "registered_date" | undefined;
+    order?: "asc" | "desc" | undefined;
+    email?: string | undefined;
+    role?: "author" | "customer" | "all" | "administrator" | "editor" | "contributor" | "subscriber" | undefined;
+}>;
+declare const wcGetCustomerSchema: z.ZodObject<{
+    id: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    id: number;
+}, {
+    id: number;
+}>;
+declare const wcCreateCustomerSchema: z.ZodObject<{
+    email: z.ZodString;
+    first_name: z.ZodOptional<z.ZodString>;
+    last_name: z.ZodOptional<z.ZodString>;
+    username: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    email: string;
+    username?: string | undefined;
+    first_name?: string | undefined;
+    last_name?: string | undefined;
+    password?: string | undefined;
+}, {
+    email: string;
+    username?: string | undefined;
+    first_name?: string | undefined;
+    last_name?: string | undefined;
+    password?: string | undefined;
+}>;
+declare const wcUpdateCustomerSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    email: z.ZodOptional<z.ZodString>;
+    first_name: z.ZodOptional<z.ZodString>;
+    last_name: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    id: number;
+    email?: string | undefined;
+    first_name?: string | undefined;
+    last_name?: string | undefined;
+}, {
+    id: number;
+    email?: string | undefined;
+    first_name?: string | undefined;
+    last_name?: string | undefined;
+}>;
+export declare const wcCustomerTools: Tool[];
+export declare const wcCustomerHandlers: {
+    wc_list_customers: (params: z.infer<typeof wcListCustomersSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    wc_get_customer: (params: z.infer<typeof wcGetCustomerSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    wc_create_customer: (params: z.infer<typeof wcCreateCustomerSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    wc_update_customer: (params: z.infer<typeof wcUpdateCustomerSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+};
+export {};

package/servers/wp-rest-bridge/build/tools/wc-customers.js

@@ -0,0 +1,92 @@
+import { makeWooCommerceRequest } from '../wordpress.js';
+import { z } from 'zod';
+const wcListCustomersSchema = z.object({
+    per_page: z.number().optional().default(10).describe("Results per page (1-100)"),
+    page: z.number().optional().default(1).describe("Page number"),
+    search: z.string().optional().describe("Search customers by keyword"),
+    email: z.string().optional().describe("Filter by exact email"),
+    role: z.enum(['all', 'administrator', 'editor', 'author', 'contributor', 'subscriber', 'customer']).optional().default('all').describe("Filter by role"),
+    orderby: z.enum(['id', 'name', 'registered_date']).optional().describe("Sort by field"),
+    order: z.enum(['asc', 'desc']).optional().default('desc').describe("Sort order"),
+}).strict();
+const wcGetCustomerSchema = z.object({
+    id: z.number().describe("Customer ID"),
+}).strict();
+const wcCreateCustomerSchema = z.object({
+    email: z.string().describe("Customer email address"),
+    first_name: z.string().optional().describe("First name"),
+    last_name: z.string().optional().describe("Last name"),
+    username: z.string().optional().describe("Username (auto-generated if omitted)"),
+    password: z.string().optional().describe("Password (auto-generated if omitted)"),
+}).strict();
+const wcUpdateCustomerSchema = z.object({
+    id: z.number().describe("Customer ID"),
+    email: z.string().optional().describe("Email address"),
+    first_name: z.string().optional().describe("First name"),
+    last_name: z.string().optional().describe("Last name"),
+}).strict();
+export const wcCustomerTools = [
+    {
+        name: "wc_list_customers",
+        description: "Lists WooCommerce customers with filtering and search",
+        inputSchema: { type: "object", properties: wcListCustomersSchema.shape },
+    },
+    {
+        name: "wc_get_customer",
+        description: "Retrieves a WooCommerce customer with order count and total spent",
+        inputSchema: { type: "object", properties: wcGetCustomerSchema.shape },
+    },
+    {
+        name: "wc_create_customer",
+        description: "Creates a new WooCommerce customer account",
+        inputSchema: { type: "object", properties: wcCreateCustomerSchema.shape },
+    },
+    {
+        name: "wc_update_customer",
+        description: "Updates a WooCommerce customer's details",
+        inputSchema: { type: "object", properties: wcUpdateCustomerSchema.shape },
+    },
+];
+export const wcCustomerHandlers = {
+    wc_list_customers: async (params) => {
+        try {
+            const response = await makeWooCommerceRequest("GET", "customers", params);
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error listing customers: ${errorMessage}` }] } };
+        }
+    },
+    wc_get_customer: async (params) => {
+        try {
+            const response = await makeWooCommerceRequest("GET", `customers/${params.id}`);
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error retrieving customer: ${errorMessage}` }] } };
+        }
+    },
+    wc_create_customer: async (params) => {
+        try {
+            const response = await makeWooCommerceRequest("POST", "customers", params);
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error creating customer: ${errorMessage}` }] } };
+        }
+    },
+    wc_update_customer: async (params) => {
+        try {
+            const { id, ...data } = params;
+            const response = await makeWooCommerceRequest("PUT", `customers/${id}`, data);
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error updating customer: ${errorMessage}` }] } };
+        }
+    },
+};

package/servers/wp-rest-bridge/build/tools/wc-orders.d.ts

@@ -0,0 +1,186 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+declare const wcListOrdersSchema: z.ZodObject<{
+    per_page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    status: z.ZodOptional<z.ZodEnum<["pending", "processing", "on-hold", "completed", "cancelled", "refunded", "failed", "trash", "any"]>>;
+    customer: z.ZodOptional<z.ZodNumber>;
+    after: z.ZodOptional<z.ZodString>;
+    before: z.ZodOptional<z.ZodString>;
+    orderby: z.ZodOptional<z.ZodEnum<["date", "id", "title", "slug"]>>;
+    order: z.ZodDefault<z.ZodOptional<z.ZodEnum<["asc", "desc"]>>>;
+}, "strict", z.ZodTypeAny, {
+    page: number;
+    per_page: number;
+    order: "asc" | "desc";
+    status?: "trash" | "pending" | "any" | "processing" | "on-hold" | "completed" | "cancelled" | "refunded" | "failed" | undefined;
+    orderby?: "slug" | "date" | "id" | "title" | undefined;
+    after?: string | undefined;
+    before?: string | undefined;
+    customer?: number | undefined;
+}, {
+    page?: number | undefined;
+    per_page?: number | undefined;
+    status?: "trash" | "pending" | "any" | "processing" | "on-hold" | "completed" | "cancelled" | "refunded" | "failed" | undefined;
+    orderby?: "slug" | "date" | "id" | "title" | undefined;
+    order?: "asc" | "desc" | undefined;
+    after?: string | undefined;
+    before?: string | undefined;
+    customer?: number | undefined;
+}>;
+declare const wcGetOrderSchema: z.ZodObject<{
+    id: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    id: number;
+}, {
+    id: number;
+}>;
+declare const wcUpdateOrderStatusSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    status: z.ZodEnum<["pending", "processing", "on-hold", "completed", "cancelled", "refunded", "failed"]>;
+}, "strict", z.ZodTypeAny, {
+    status: "pending" | "processing" | "on-hold" | "completed" | "cancelled" | "refunded" | "failed";
+    id: number;
+}, {
+    status: "pending" | "processing" | "on-hold" | "completed" | "cancelled" | "refunded" | "failed";
+    id: number;
+}>;
+declare const wcListOrderNotesSchema: z.ZodObject<{
+    order_id: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    order_id: number;
+}, {
+    order_id: number;
+}>;
+declare const wcCreateOrderNoteSchema: z.ZodObject<{
+    order_id: z.ZodNumber;
+    note: z.ZodString;
+    customer_note: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strict", z.ZodTypeAny, {
+    order_id: number;
+    note: string;
+    customer_note: boolean;
+}, {
+    order_id: number;
+    note: string;
+    customer_note?: boolean | undefined;
+}>;
+declare const wcCreateRefundSchema: z.ZodObject<{
+    order_id: z.ZodNumber;
+    amount: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    order_id: number;
+    amount: string;
+    reason?: string | undefined;
+}, {
+    order_id: number;
+    amount: string;
+    reason?: string | undefined;
+}>;
+export declare const wcOrderTools: Tool[];
+export declare const wcOrderHandlers: {
+    wc_list_orders: (params: z.infer<typeof wcListOrdersSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    wc_get_order: (params: z.infer<typeof wcGetOrderSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    wc_update_order_status: (params: z.infer<typeof wcUpdateOrderStatusSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    wc_list_order_notes: (params: z.infer<typeof wcListOrderNotesSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    wc_create_order_note: (params: z.infer<typeof wcCreateOrderNoteSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    wc_create_refund: (params: z.infer<typeof wcCreateRefundSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+};
+export {};