ebay-mcp 1.4.3

package/build/utils/communication/message.js

@@ -0,0 +1,242 @@
+import { z } from 'zod';
+/**
+ * Zod schemas for Message API input validation
+ * Based on: src/api/communication/message.ts
+ * OpenAPI spec: docs/sell-apps/communication/commerce_message_v1_oas3.json
+ * Types from: src/types/commerce_message_v1_oas3.ts
+ */
+// Reusable schema for filter parameter
+const _filterSchema = z
+    .string({
+    message: 'Filter must be a string',
+    invalid_type_error: 'filter must be a string',
+    description: 'Filter criteria for the query',
+})
+    .optional();
+// Reusable schema for limit parameter (string in API)
+const limitSchema = z
+    .string({
+    invalid_type_error: 'limit must be a string',
+    description: 'Maximum number of items to return (25-50)',
+})
+    .optional();
+// Reusable schema for offset parameter (string in API)
+const offsetSchema = z
+    .string({
+    invalid_type_error: 'offset must be a string',
+    description: 'Number of items to skip',
+})
+    .optional();
+/**
+ * Schema for bulkUpdateConversation method
+ * Endpoint: POST /bulk_update_conversation
+ * Body: BulkUpdateConversationsRequest - conversations array
+ */
+export const bulkUpdateConversationSchema = z.object({
+    conversations: z
+        .array(z.object({
+        conversation_id: z
+            .string({
+            invalid_type_error: 'conversation_id must be a string',
+            description: 'The unique identifier of the conversation',
+        })
+            .optional(),
+        conversation_status: z
+            .string({
+            invalid_type_error: 'conversation_status must be a string',
+            description: 'The updated status: ACTIVE, ARCHIVE, DELETE, READ, UNREAD',
+        })
+            .optional(),
+        conversation_type: z
+            .string({
+            invalid_type_error: 'conversation_type must be a string',
+            description: 'The existing type: FROM_MEMBERS or FROM_EBAY (required but cannot be updated)',
+        })
+            .optional(),
+    }), {
+        invalid_type_error: 'conversations must be an array',
+        description: 'Array of conversations to update',
+    })
+        .optional(),
+});
+/**
+ * Schema for getConversations method
+ * Endpoint: GET /conversation
+ * Params: GetConversationsParams - conversation_type (required), conversation_status, end_time, limit, offset, other_party_username, reference_id, reference_type, start_time
+ */
+export const getConversationsSchema = z.object({
+    conversation_type: z.string({
+        message: 'Conversation type is required',
+        required_error: 'conversation_type is required',
+        invalid_type_error: 'conversation_type must be a string',
+        description: 'Type of conversation: FROM_EBAY or FROM_MEMBERS',
+    }),
+    conversation_status: z
+        .string({
+        invalid_type_error: 'conversation_status must be a string',
+        description: 'Filter by status: ACTIVE, ARCHIVE, DELETE, READ, UNREAD',
+    })
+        .optional(),
+    end_time: z
+        .string({
+        invalid_type_error: 'end_time must be a string',
+        description: 'End time for retrieving conversations (ISO 8601 format)',
+    })
+        .optional(),
+    limit: limitSchema,
+    offset: offsetSchema,
+    other_party_username: z
+        .string({
+        invalid_type_error: 'other_party_username must be a string',
+        description: 'Filter by specific eBay user',
+    })
+        .optional(),
+    reference_id: z
+        .string({
+        invalid_type_error: 'reference_id must be a string',
+        description: 'Filter by reference ID (e.g., listing ID)',
+    })
+        .optional(),
+    reference_type: z
+        .string({
+        invalid_type_error: 'reference_type must be a string',
+        description: 'Reference type (currently only LISTING is supported)',
+    })
+        .optional(),
+    start_time: z
+        .string({
+        invalid_type_error: 'start_time must be a string',
+        description: 'Start time for retrieving conversations (ISO 8601 format)',
+    })
+        .optional(),
+});
+/**
+ * Schema for getConversation method
+ * Endpoint: GET /conversation/{conversation_id}
+ * Path: conversation_id (required)
+ * Query: conversation_type (required), limit, offset
+ */
+export const getConversationSchema = z.object({
+    conversation_id: z.string({
+        message: 'Conversation ID is required',
+        required_error: 'conversation_id is required',
+        invalid_type_error: 'conversation_id must be a string',
+        description: 'The unique identifier for the conversation',
+    }),
+    conversation_type: z.string({
+        message: 'Conversation type is required',
+        required_error: 'conversation_type is required',
+        invalid_type_error: 'conversation_type must be a string',
+        description: 'Type of conversation: FROM_EBAY or FROM_MEMBERS',
+    }),
+    limit: limitSchema,
+    offset: offsetSchema,
+});
+/**
+ * Schema for sendMessage method
+ * Endpoint: POST /send_message
+ * Body: SendMessageRequest - conversationId, emailCopyToSender, messageMedia, messageText, otherPartyUsername, reference
+ */
+export const sendMessageSchema = z.object({
+    conversation_id: z
+        .string({
+        invalid_type_error: 'conversation_id must be a string',
+        description: 'ID of existing conversation (required if sending in existing conversation)',
+    })
+        .optional(),
+    email_copy_to_sender: z
+        .boolean({
+        invalid_type_error: 'email_copy_to_sender must be a boolean',
+        description: 'Whether to email a copy to the sender',
+    })
+        .optional(),
+    message_media: z
+        .array(z.object({
+        media_name: z
+            .string({
+            invalid_type_error: 'media_name must be a string',
+            description: 'Name of the media',
+        })
+            .optional(),
+        media_type: z
+            .string({
+            invalid_type_error: 'media_type must be a string',
+            description: 'Type of media: IMAGE, PDF, DOC, TXT',
+        })
+            .optional(),
+        media_url: z
+            .string({
+            invalid_type_error: 'media_url must be a string',
+            description: 'HTTPS URL of the self-hosted media',
+        })
+            .optional(),
+    }), {
+        invalid_type_error: 'message_media must be an array',
+        description: 'Array of up to 5 media attachments',
+    })
+        .max(5, 'Maximum 5 media attachments allowed')
+        .optional(),
+    message_text: z
+        .string({
+        invalid_type_error: 'message_text must be a string',
+        description: 'The text of the message (max 2000 characters)',
+    })
+        .max(2000, 'message_text must be 2000 characters or less')
+        .optional(),
+    other_party_username: z
+        .string({
+        invalid_type_error: 'other_party_username must be a string',
+        description: 'eBay username to send message to (required for new conversations)',
+    })
+        .optional(),
+    reference: z
+        .object({
+        reference_id: z
+            .string({
+            invalid_type_error: 'reference_id must be a string',
+            description: 'The reference ID (e.g., item ID for LISTING)',
+        })
+            .optional(),
+        reference_type: z
+            .string({
+            invalid_type_error: 'reference_type must be a string',
+            description: 'The reference type (currently only LISTING is supported)',
+        })
+            .optional(),
+    }, {
+        invalid_type_error: 'reference must be an object',
+        description: 'Reference to associate with the conversation',
+    })
+        .optional(),
+});
+/**
+ * Schema for updateConversation method
+ * Endpoint: POST /update_conversation
+ * Body: UpdateConversationRequest - conversationId, conversationStatus, conversationType, read
+ */
+export const updateConversationSchema = z.object({
+    conversation_id: z
+        .string({
+        invalid_type_error: 'conversation_id must be a string',
+        description: 'The unique identifier of the conversation',
+    })
+        .optional(),
+    conversation_status: z
+        .string({
+        invalid_type_error: 'conversation_status must be a string',
+        description: 'The updated status: ACTIVE, ARCHIVE, DELETE',
+    })
+        .optional(),
+    conversation_type: z
+        .string({
+        invalid_type_error: 'conversation_type must be a string',
+        description: 'The existing type: FROM_MEMBERS or FROM_EBAY (required but cannot be updated)',
+    })
+        .optional(),
+    read: z
+        .boolean({
+        invalid_type_error: 'read must be a boolean',
+        description: 'The read status to set (true = read, false = unread)',
+    })
+        .optional(),
+});

package/build/utils/communication/negotiation.d.ts

@@ -0,0 +1,123 @@
+import { z } from 'zod';
+/**
+ * Schema for findEligibleItems method
+ * Endpoint: GET /find_eligible_items
+ * Query Params: FindEligibleItemsParams - limit, offset
+ * Headers: X-EBAY-C-MARKETPLACE-ID (required)
+ */
+export declare const findEligibleItemsSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodString>;
+    offset: z.ZodOptional<z.ZodString>;
+    marketplace_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    marketplace_id?: string | undefined;
+    limit?: string | undefined;
+    offset?: string | undefined;
+}, {
+    marketplace_id?: string | undefined;
+    limit?: string | undefined;
+    offset?: string | undefined;
+}>;
+/**
+ * Schema for sendOfferToInterestedBuyers method
+ * Endpoint: POST /send_offer_to_interested_buyers
+ * Body: CreateOffersRequest - allowCounterOffer, message, offerDuration, offeredItems
+ * Headers: X-EBAY-C-MARKETPLACE-ID (required)
+ */
+export declare const sendOfferToInterestedBuyersSchema: z.ZodObject<{
+    allow_counter_offer: z.ZodOptional<z.ZodBoolean>;
+    message: z.ZodOptional<z.ZodString>;
+    offer_duration: z.ZodOptional<z.ZodObject<{
+        unit: z.ZodOptional<z.ZodString>;
+        value: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        value?: number | undefined;
+        unit?: string | undefined;
+    }, {
+        value?: number | undefined;
+        unit?: string | undefined;
+    }>>;
+    offered_items: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        discount_percentage: z.ZodOptional<z.ZodString>;
+        listing_id: z.ZodOptional<z.ZodString>;
+        price: z.ZodOptional<z.ZodObject<{
+            currency: z.ZodOptional<z.ZodString>;
+            value: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            value?: string | undefined;
+            currency?: string | undefined;
+        }, {
+            value?: string | undefined;
+            currency?: string | undefined;
+        }>>;
+        quantity: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        listing_id?: string | undefined;
+        quantity?: number | undefined;
+        price?: {
+            value?: string | undefined;
+            currency?: string | undefined;
+        } | undefined;
+        discount_percentage?: string | undefined;
+    }, {
+        listing_id?: string | undefined;
+        quantity?: number | undefined;
+        price?: {
+            value?: string | undefined;
+            currency?: string | undefined;
+        } | undefined;
+        discount_percentage?: string | undefined;
+    }>, "many">>;
+    marketplace_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message?: string | undefined;
+    marketplace_id?: string | undefined;
+    allow_counter_offer?: boolean | undefined;
+    offer_duration?: {
+        value?: number | undefined;
+        unit?: string | undefined;
+    } | undefined;
+    offered_items?: {
+        listing_id?: string | undefined;
+        quantity?: number | undefined;
+        price?: {
+            value?: string | undefined;
+            currency?: string | undefined;
+        } | undefined;
+        discount_percentage?: string | undefined;
+    }[] | undefined;
+}, {
+    message?: string | undefined;
+    marketplace_id?: string | undefined;
+    allow_counter_offer?: boolean | undefined;
+    offer_duration?: {
+        value?: number | undefined;
+        unit?: string | undefined;
+    } | undefined;
+    offered_items?: {
+        listing_id?: string | undefined;
+        quantity?: number | undefined;
+        price?: {
+            value?: string | undefined;
+            currency?: string | undefined;
+        } | undefined;
+        discount_percentage?: string | undefined;
+    }[] | undefined;
+}>;
+/**
+ * Schema for getOffersToBuyers method (deprecated)
+ * Note: This method does not match any endpoint in the OpenAPI spec
+ */
+export declare const getOffersToBuyersSchema: z.ZodObject<{
+    filter: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodString>;
+    offset: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    filter?: string | undefined;
+    limit?: string | undefined;
+    offset?: string | undefined;
+}, {
+    filter?: string | undefined;
+    limit?: string | undefined;
+    offset?: string | undefined;
+}>;

package/build/utils/communication/negotiation.js

@@ -0,0 +1,150 @@
+import { z } from 'zod';
+/**
+ * Zod schemas for Negotiation API input validation
+ * Based on: src/api/communication/negotiation.ts
+ * OpenAPI spec: docs/sell-apps/communication/sell_negotiation_v1_oas3.json
+ * Types from: src/types/sell_negotiation_v1_oas3.ts
+ */
+// Reusable schema for filter parameter
+const filterSchema = z
+    .string({
+    message: 'Filter must be a string',
+    invalid_type_error: 'filter must be a string',
+    description: 'Filter criteria for the query',
+})
+    .optional();
+// Reusable schema for limit parameter (string in API)
+const limitSchema = z
+    .string({
+    invalid_type_error: 'limit must be a string',
+    description: 'Maximum number of items to return (1-200)',
+})
+    .optional();
+// Reusable schema for offset parameter (string in API)
+const offsetSchema = z
+    .string({
+    invalid_type_error: 'offset must be a string',
+    description: 'Number of items to skip',
+})
+    .optional();
+/**
+ * Schema for findEligibleItems method
+ * Endpoint: GET /find_eligible_items
+ * Query Params: FindEligibleItemsParams - limit, offset
+ * Headers: X-EBAY-C-MARKETPLACE-ID (required)
+ */
+export const findEligibleItemsSchema = z.object({
+    limit: limitSchema,
+    offset: offsetSchema,
+    marketplace_id: z
+        .string({
+        invalid_type_error: 'marketplace_id must be a string',
+        description: 'The eBay marketplace ID (X-EBAY-C-MARKETPLACE-ID header)',
+    })
+        .optional(),
+});
+/**
+ * Schema for sendOfferToInterestedBuyers method
+ * Endpoint: POST /send_offer_to_interested_buyers
+ * Body: CreateOffersRequest - allowCounterOffer, message, offerDuration, offeredItems
+ * Headers: X-EBAY-C-MARKETPLACE-ID (required)
+ */
+export const sendOfferToInterestedBuyersSchema = z.object({
+    allow_counter_offer: z
+        .boolean({
+        invalid_type_error: 'allow_counter_offer must be a boolean',
+        description: 'Whether to allow counter-offers (currently must be false)',
+    })
+        .optional(),
+    message: z
+        .string({
+        invalid_type_error: 'message must be a string',
+        description: 'Seller-defined message to buyers (max 2000 characters)',
+    })
+        .max(2000, 'message must be 2000 characters or less')
+        .optional(),
+    offer_duration: z
+        .object({
+        unit: z
+            .string({
+            invalid_type_error: 'unit must be a string',
+            description: 'Time unit (currently must be DAY)',
+        })
+            .optional(),
+        value: z
+            .number({
+            invalid_type_error: 'value must be a number',
+            description: 'Duration value (currently must be 2)',
+        })
+            .int({
+            message: 'value must be an integer',
+        })
+            .optional(),
+    }, {
+        invalid_type_error: 'offer_duration must be an object',
+        description: 'Duration the offer is valid (default: 2 days)',
+    })
+        .optional(),
+    offered_items: z
+        .array(z.object({
+        discount_percentage: z
+            .string({
+            invalid_type_error: 'discount_percentage must be a string',
+            description: 'Percentage discount (minimum 5)',
+        })
+            .optional(),
+        listing_id: z
+            .string({
+            invalid_type_error: 'listing_id must be a string',
+            description: 'The unique eBay listing ID',
+        })
+            .optional(),
+        price: z
+            .object({
+            currency: z
+                .string({
+                invalid_type_error: 'currency must be a string',
+                description: '3-letter ISO 4217 currency code',
+            })
+                .optional(),
+            value: z
+                .string({
+                invalid_type_error: 'value must be a string',
+                description: 'The monetary amount',
+            })
+                .optional(),
+        }, {
+            invalid_type_error: 'price must be an object',
+            description: 'The discounted price',
+        })
+            .optional(),
+        quantity: z
+            .number({
+            invalid_type_error: 'quantity must be a number',
+            description: 'Number of items (all-or-nothing offer)',
+        })
+            .int({
+            message: 'quantity must be an integer',
+        })
+            .optional(),
+    }), {
+        invalid_type_error: 'offered_items must be an array',
+        description: 'Array of items to offer (currently limited to one item)',
+    })
+        .optional(),
+    marketplace_id: z
+        .string({
+        invalid_type_error: 'marketplace_id must be a string',
+        description: 'The eBay marketplace ID (X-EBAY-C-MARKETPLACE-ID header)',
+    })
+        .optional(),
+});
+/**
+ * Schema for getOffersToBuyers method (deprecated)
+ * Note: This method does not match any endpoint in the OpenAPI spec
+ */
+export const getOffersToBuyersSchema = z.object({
+    filter: filterSchema,
+    limit: limitSchema,
+    offset: offsetSchema,
+});