ebay-mcp 1.13.2 → 1.14.0

package/build/utils/communication/message.js

@@ -1,55 +1,43 @@
-import { z } from 'zod';
+import { z } from '../../utils/effectSchema.js';
 /**
- * Zod schemas for Message API input validation
- * Based on: src/api/communication/message.ts
+ * Effect-backed schemas for Message API input validation.
  * 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)
+/** Optional positive page size accepted by Message list endpoints. */
 const limitSchema = z
-    .string({
-    invalid_type_error: 'limit must be a string',
+    .number({
+    invalid_type_error: 'limit must be a number',
     description: 'Maximum number of items to return (25-50)',
 })
+    .positive('limit must be a positive number')
     .optional();
-// Reusable schema for offset parameter (string in API)
+/** Optional zero-based page offset accepted by Message list endpoints. */
 const offsetSchema = z
-    .string({
-    invalid_type_error: 'offset must be a string',
+    .number({
+    invalid_type_error: 'offset must be a number',
     description: 'Number of items to skip',
 })
+    .min(0, 'offset must be a non-negative number')
     .optional();
-/**
- * Schema for bulkUpdateConversation method
- * Endpoint: POST /bulk_update_conversation
- * Body: BulkUpdateConversationsRequest - conversations array
- */
+/** Schema for bulkUpdateConversation input. */
 export const bulkUpdateConversationSchema = z.object({
     conversations: z
         .array(z.object({
-        conversation_id: z
+        conversationId: z
             .string({
-            invalid_type_error: 'conversation_id must be a string',
+            invalid_type_error: 'conversationId must be a string',
             description: 'The unique identifier of the conversation',
         })
             .optional(),
-        conversation_status: z
+        conversationStatus: z
             .string({
-            invalid_type_error: 'conversation_status must be a string',
+            invalid_type_error: 'conversationStatus must be a string',
             description: 'The updated status: ACTIVE, ARCHIVE, DELETE, READ, UNREAD',
         })
             .optional(),
-        conversation_type: z
+        conversationType: z
             .string({
-            invalid_type_error: 'conversation_type must be a string',
+            invalid_type_error: 'conversationType must be a string',
             description: 'The existing type: FROM_MEMBERS or FROM_EBAY (required but cannot be updated)',
         })
             .optional(),
@@ -59,147 +47,134 @@ export const bulkUpdateConversationSchema = z.object({
     })
         .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
- */
+/** Schema for getConversations input. */
 export const getConversationsSchema = z.object({
-    conversation_type: z.string({
+    conversationType: z.string({
         message: 'Conversation type is required',
-        required_error: 'conversation_type is required',
-        invalid_type_error: 'conversation_type must be a string',
+        required_error: 'conversationType is required',
+        invalid_type_error: 'conversationType must be a string',
         description: 'Type of conversation: FROM_EBAY or FROM_MEMBERS',
     }),
-    conversation_status: z
+    conversationStatus: z
         .string({
-        invalid_type_error: 'conversation_status must be a string',
+        invalid_type_error: 'conversationStatus must be a string',
         description: 'Filter by status: ACTIVE, ARCHIVE, DELETE, READ, UNREAD',
     })
         .optional(),
-    end_time: z
+    endTime: z
         .string({
-        invalid_type_error: 'end_time must be a string',
+        invalid_type_error: 'endTime must be a string',
         description: 'End time for retrieving conversations (ISO 8601 format)',
     })
         .optional(),
     limit: limitSchema,
     offset: offsetSchema,
-    other_party_username: z
+    otherPartyUsername: z
         .string({
-        invalid_type_error: 'other_party_username must be a string',
+        invalid_type_error: 'otherPartyUsername must be a string',
         description: 'Filter by specific eBay user',
     })
         .optional(),
-    reference_id: z
+    referenceId: z
         .string({
-        invalid_type_error: 'reference_id must be a string',
+        invalid_type_error: 'referenceId must be a string',
         description: 'Filter by reference ID (e.g., listing ID)',
     })
         .optional(),
-    reference_type: z
+    referenceType: z
         .string({
-        invalid_type_error: 'reference_type must be a string',
+        invalid_type_error: 'referenceType must be a string',
         description: 'Reference type (currently only LISTING is supported)',
     })
         .optional(),
-    start_time: z
+    startTime: z
         .string({
-        invalid_type_error: 'start_time must be a string',
+        invalid_type_error: 'startTime 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
- */
+/** Schema for getConversation input. */
 export const getConversationSchema = z.object({
-    conversation_id: z.string({
+    conversationId: z.string({
         message: 'Conversation ID is required',
-        required_error: 'conversation_id is required',
-        invalid_type_error: 'conversation_id must be a string',
+        required_error: 'conversationId is required',
+        invalid_type_error: 'conversationId must be a string',
         description: 'The unique identifier for the conversation',
     }),
-    conversation_type: z.string({
+    conversationType: z.string({
         message: 'Conversation type is required',
-        required_error: 'conversation_type is required',
-        invalid_type_error: 'conversation_type must be a string',
+        required_error: 'conversationType is required',
+        invalid_type_error: 'conversationType 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
- */
+/** Schema for sendMessage input. */
 export const sendMessageSchema = z.object({
-    conversation_id: z
+    conversationId: z
         .string({
-        invalid_type_error: 'conversation_id must be a string',
+        invalid_type_error: 'conversationId must be a string',
         description: 'ID of existing conversation (required if sending in existing conversation)',
     })
         .optional(),
-    email_copy_to_sender: z
+    emailCopyToSender: z
         .boolean({
-        invalid_type_error: 'email_copy_to_sender must be a boolean',
+        invalid_type_error: 'emailCopyToSender must be a boolean',
         description: 'Whether to email a copy to the sender',
     })
         .optional(),
-    message_media: z
+    messageMedia: z
         .array(z.object({
-        media_name: z
+        mediaName: z
             .string({
-            invalid_type_error: 'media_name must be a string',
+            invalid_type_error: 'mediaName must be a string',
             description: 'Name of the media',
         })
             .optional(),
-        media_type: z
+        mediaType: z
             .string({
-            invalid_type_error: 'media_type must be a string',
+            invalid_type_error: 'mediaType must be a string',
             description: 'Type of media: IMAGE, PDF, DOC, TXT',
         })
             .optional(),
-        media_url: z
+        mediaUrl: z
             .string({
-            invalid_type_error: 'media_url must be a string',
+            invalid_type_error: 'mediaUrl must be a string',
             description: 'HTTPS URL of the self-hosted media',
         })
             .optional(),
     }), {
-        invalid_type_error: 'message_media must be an array',
+        invalid_type_error: 'messageMedia must be an array',
         description: 'Array of up to 5 media attachments',
     })
         .max(5, 'Maximum 5 media attachments allowed')
         .optional(),
-    message_text: z
+    messageText: z
         .string({
-        invalid_type_error: 'message_text must be a string',
+        invalid_type_error: 'messageText must be a string',
         description: 'The text of the message (max 2000 characters)',
     })
-        .max(2000, 'message_text must be 2000 characters or less')
+        .max(2000, 'messageText must be 2000 characters or less')
         .optional(),
-    other_party_username: z
+    otherPartyUsername: z
         .string({
-        invalid_type_error: 'other_party_username must be a string',
+        invalid_type_error: 'otherPartyUsername must be a string',
         description: 'eBay username to send message to (required for new conversations)',
     })
         .optional(),
     reference: z
         .object({
-        reference_id: z
+        referenceId: z
             .string({
-            invalid_type_error: 'reference_id must be a string',
+            invalid_type_error: 'referenceId must be a string',
             description: 'The reference ID (e.g., item ID for LISTING)',
         })
             .optional(),
-        reference_type: z
+        referenceType: z
             .string({
-            invalid_type_error: 'reference_type must be a string',
+            invalid_type_error: 'referenceType must be a string',
             description: 'The reference type (currently only LISTING is supported)',
         })
             .optional(),
@@ -209,27 +184,23 @@ export const sendMessageSchema = z.object({
     })
         .optional(),
 });
-/**
- * Schema for updateConversation method
- * Endpoint: POST /update_conversation
- * Body: UpdateConversationRequest - conversationId, conversationStatus, conversationType, read
- */
+/** Schema for updateConversation input. */
 export const updateConversationSchema = z.object({
-    conversation_id: z
+    conversationId: z
         .string({
-        invalid_type_error: 'conversation_id must be a string',
+        invalid_type_error: 'conversationId must be a string',
         description: 'The unique identifier of the conversation',
     })
         .optional(),
-    conversation_status: z
+    conversationStatus: z
         .string({
-        invalid_type_error: 'conversation_status must be a string',
+        invalid_type_error: 'conversationStatus must be a string',
         description: 'The updated status: ACTIVE, ARCHIVE, DELETE',
     })
         .optional(),
-    conversation_type: z
+    conversationType: z
         .string({
-        invalid_type_error: 'conversation_type must be a string',
+        invalid_type_error: 'conversationType must be a string',
         description: 'The existing type: FROM_MEMBERS or FROM_EBAY (required but cannot be updated)',
     })
         .optional(),

package/build/utils/communication/negotiation.js

@@ -1,61 +1,49 @@
-import { z } from 'zod';
+import { z } from '../../utils/effectSchema.js';
 /**
- * Zod schemas for Negotiation API input validation
- * Based on: src/api/communication/negotiation.ts
+ * Effect-backed schemas for Negotiation API input validation.
  * 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)
+/** Optional positive page size accepted by Negotiation list endpoints. */
 const limitSchema = z
-    .string({
-    invalid_type_error: 'limit must be a string',
+    .number({
+    invalid_type_error: 'limit must be a number',
     description: 'Maximum number of items to return (1-200)',
 })
+    .positive('limit must be a positive number')
     .optional();
-// Reusable schema for offset parameter (string in API)
+/** Optional zero-based page offset accepted by Negotiation list endpoints. */
 const offsetSchema = z
-    .string({
-    invalid_type_error: 'offset must be a string',
+    .number({
+    invalid_type_error: 'offset must be a number',
     description: 'Number of items to skip',
 })
+    .min(0, 'offset must be a non-negative number')
     .optional();
-/**
- * Schema for findEligibleItems method
- * Endpoint: GET /find_eligible_items
- * Query Params: FindEligibleItemsParams - limit, offset
- * Headers: X-EBAY-C-MARKETPLACE-ID (required)
- */
+/** Schema for findEligibleItems input. */
 export const findEligibleItemsSchema = z.object({
     limit: limitSchema,
     offset: offsetSchema,
-    marketplace_id: z
+    marketplaceId: z
         .string({
-        invalid_type_error: 'marketplace_id must be a string',
+        invalid_type_error: 'marketplaceId 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)
- */
+/** Schema for sendOfferToInterestedBuyers input. */
 export const sendOfferToInterestedBuyersSchema = z.object({
-    allow_counter_offer: z
+    allowCounterOffer: z
         .boolean({
-        invalid_type_error: 'allow_counter_offer must be a boolean',
+        invalid_type_error: 'allowCounterOffer must be a boolean',
         description: 'Whether to allow counter-offers (currently must be false)',
     })
         .optional(),
+    marketplaceId: z
+        .string({
+        invalid_type_error: 'marketplaceId must be a string',
+        description: 'The eBay marketplace ID (X-EBAY-C-MARKETPLACE-ID header)',
+    })
+        .optional(),
     message: z
         .string({
         invalid_type_error: 'message must be a string',
@@ -63,7 +51,7 @@ export const sendOfferToInterestedBuyersSchema = z.object({
     })
         .max(2000, 'message must be 2000 characters or less')
         .optional(),
-    offer_duration: z
+    offerDuration: z
         .object({
         unit: z
             .string({
@@ -81,21 +69,21 @@ export const sendOfferToInterestedBuyersSchema = z.object({
         })
             .optional(),
     }, {
-        invalid_type_error: 'offer_duration must be an object',
+        invalid_type_error: 'offerDuration must be an object',
         description: 'Duration the offer is valid (default: 2 days)',
     })
         .optional(),
-    offered_items: z
+    offeredItems: z
         .array(z.object({
-        discount_percentage: z
+        discountPercentage: z
             .string({
-            invalid_type_error: 'discount_percentage must be a string',
+            invalid_type_error: 'discountPercentage must be a string',
             description: 'Percentage discount (minimum 5)',
         })
             .optional(),
-        listing_id: z
+        listingId: z
             .string({
-            invalid_type_error: 'listing_id must be a string',
+            invalid_type_error: 'listingId must be a string',
             description: 'The unique eBay listing ID',
         })
             .optional(),
@@ -128,23 +116,8 @@ export const sendOfferToInterestedBuyersSchema = z.object({
         })
             .optional(),
     }), {
-        invalid_type_error: 'offered_items must be an array',
+        invalid_type_error: 'offeredItems 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,
 });