ebay-mcp-remote-edition 1.0.0

package/build/api/communication/feedback.js

@@ -0,0 +1,119 @@
+/**
+ * Feedback API - Manage buyer and seller feedback
+ * Based on: docs/sell-apps/communication/commerce_feedback_v1_beta_oas3.json
+ */
+export class FeedbackApi {
+    client;
+    basePath = '/commerce/feedback/v1';
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get items awaiting feedback
+     * Endpoint: GET /awaiting_feedback
+     * @throws Error if the request fails
+     */
+    async getAwaitingFeedback(filter, limit, offset) {
+        const params = {};
+        if (filter !== undefined) {
+            if (typeof filter !== 'string') {
+                throw new Error('filter must be a string when provided');
+            }
+            params.filter = filter;
+        }
+        if (limit !== undefined) {
+            if (typeof limit !== 'number' || limit < 1) {
+                throw new Error('limit must be a positive number when provided');
+            }
+            params.limit = limit;
+        }
+        if (offset !== undefined) {
+            if (typeof offset !== 'number' || offset < 0) {
+                throw new Error('offset must be a non-negative number when provided');
+            }
+            params.offset = offset;
+        }
+        try {
+            return await this.client.get(`${this.basePath}/awaiting_feedback`, params);
+        }
+        catch (error) {
+            throw new Error(`Failed to get awaiting feedback: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Get feedback for a transaction
+     * Endpoint: GET /feedback
+     * @throws Error if required parameters are missing or invalid
+     */
+    async getFeedback(transactionId) {
+        if (!transactionId || typeof transactionId !== 'string') {
+            throw new Error('transactionId is required and must be a string');
+        }
+        try {
+            return await this.client.get(`${this.basePath}/feedback`, {
+                transaction_id: transactionId,
+            });
+        }
+        catch (error) {
+            throw new Error(`Failed to get feedback: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Get feedback rating summary
+     * Endpoint: GET /feedback_rating_summary
+     * @throws Error if the request fails
+     */
+    async getFeedbackRatingSummary() {
+        try {
+            return await this.client.get(`${this.basePath}/feedback_rating_summary`);
+        }
+        catch (error) {
+            throw new Error(`Failed to get feedback rating summary: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Leave feedback for a buyer
+     * Endpoint: POST /feedback
+     * @throws Error if required parameters are missing or invalid
+     */
+    async leaveFeedbackForBuyer(feedbackData) {
+        if (!feedbackData || typeof feedbackData !== 'object') {
+            throw new Error('feedbackData is required and must be an object');
+        }
+        try {
+            return await this.client.post(`${this.basePath}/feedback`, feedbackData);
+        }
+        catch (error) {
+            throw new Error(`Failed to leave feedback: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Respond to feedback
+     * Endpoint: POST /respond_to_feedback
+     * @throws Error if required parameters are missing or invalid
+     */
+    async respondToFeedback(feedbackId, responseText) {
+        if (!feedbackId || typeof feedbackId !== 'string') {
+            throw new Error('feedbackId is required and must be a string');
+        }
+        if (!responseText || typeof responseText !== 'string') {
+            throw new Error('responseText is required and must be a string');
+        }
+        try {
+            return await this.client.post(`${this.basePath}/respond_to_feedback`, {
+                feedback_id: feedbackId,
+                response_text: responseText,
+            });
+        }
+        catch (error) {
+            throw new Error(`Failed to respond to feedback: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Get feedback summary
+     * @deprecated Use getFeedbackRatingSummary() instead
+     */
+    async getFeedbackSummary() {
+        return await this.getFeedbackRatingSummary();
+    }
+}

package/build/api/communication/message.js

@@ -0,0 +1,131 @@
+/**
+ * Message API - Buyer-seller messaging
+ * Based on: docs/sell-apps/communication/commerce_message_v1_oas3.json
+ */
+export class MessageApi {
+    client;
+    basePath = '/commerce/message/v1';
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Bulk update conversation
+     * Endpoint: POST /bulk_update_conversation
+     * @throws Error if required parameters are missing or invalid
+     */
+    async bulkUpdateConversation(updateData) {
+        if (!updateData || typeof updateData !== 'object') {
+            throw new Error('updateData is required and must be an object');
+        }
+        try {
+            return await this.client.post(`${this.basePath}/bulk_update_conversation`, updateData);
+        }
+        catch (error) {
+            throw new Error(`Failed to bulk update conversation: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Get conversations
+     * Endpoint: GET /conversation
+     * @throws Error if the request fails
+     */
+    async getConversations(filter, limit, offset) {
+        const params = {};
+        if (filter !== undefined) {
+            if (typeof filter !== 'string') {
+                throw new Error('filter must be a string when provided');
+            }
+            params.filter = filter;
+        }
+        if (limit !== undefined) {
+            if (typeof limit !== 'number' || limit < 1) {
+                throw new Error('limit must be a positive number when provided');
+            }
+            params.limit = limit;
+        }
+        if (offset !== undefined) {
+            if (typeof offset !== 'number' || offset < 0) {
+                throw new Error('offset must be a non-negative number when provided');
+            }
+            params.offset = offset;
+        }
+        try {
+            return await this.client.get(`${this.basePath}/conversation`, params);
+        }
+        catch (error) {
+            throw new Error(`Failed to get conversations: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Get a specific conversation
+     * Endpoint: GET /conversation/{conversation_id}
+     * @throws Error if required parameters are missing or invalid
+     */
+    async getConversation(conversationId) {
+        if (!conversationId || typeof conversationId !== 'string') {
+            throw new Error('conversationId is required and must be a string');
+        }
+        try {
+            return await this.client.get(`${this.basePath}/conversation/${conversationId}`);
+        }
+        catch (error) {
+            throw new Error(`Failed to get conversation: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Send a message
+     * Endpoint: POST /send_message
+     * @throws Error if required parameters are missing or invalid
+     */
+    async sendMessage(messageData) {
+        if (!messageData || typeof messageData !== 'object') {
+            throw new Error('messageData is required and must be an object');
+        }
+        try {
+            return await this.client.post(`${this.basePath}/send_message`, messageData);
+        }
+        catch (error) {
+            throw new Error(`Failed to send message: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Update a conversation
+     * Endpoint: POST /update_conversation
+     * @throws Error if required parameters are missing or invalid
+     */
+    async updateConversation(updateData) {
+        if (!updateData || typeof updateData !== 'object') {
+            throw new Error('updateData is required and must be an object');
+        }
+        try {
+            return await this.client.post(`${this.basePath}/update_conversation`, updateData);
+        }
+        catch (error) {
+            throw new Error(`Failed to update conversation: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Search for messages
+     * @deprecated Use getConversations() instead
+     */
+    async searchMessages(filter, limit, offset) {
+        return await this.getConversations(filter, limit, offset);
+    }
+    /**
+     * Get a specific message
+     * @deprecated Use getConversation() instead
+     */
+    async getMessage(messageId) {
+        return await this.getConversation(messageId);
+    }
+    /**
+     * Reply to a message
+     * @deprecated Use sendMessage() instead
+     */
+    async replyToMessage(messageId, messageContent) {
+        return await this.sendMessage({
+            conversation_id: messageId,
+            message_content: messageContent,
+        });
+    }
+}

package/build/api/communication/negotiation.js

@@ -0,0 +1,97 @@
+/**
+ * Negotiation API - Buyer-seller negotiations and offers
+ * Based on: docs/sell-apps/communication/sell_negotiation_v1_oas3.json
+ */
+export class NegotiationApi {
+    client;
+    basePath = '/sell/negotiation/v1';
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Find eligible items for a seller-initiated offer
+     * Endpoint: GET /find_eligible_items
+     * @throws Error if the request fails
+     */
+    async findEligibleItems(filter, limit, offset) {
+        const params = {};
+        if (filter !== undefined) {
+            if (typeof filter !== 'string') {
+                throw new Error('filter must be a string when provided');
+            }
+            params.filter = filter;
+        }
+        if (limit !== undefined) {
+            if (typeof limit !== 'number' || limit < 1) {
+                throw new Error('limit must be a positive number when provided');
+            }
+            params.limit = limit;
+        }
+        if (offset !== undefined) {
+            if (typeof offset !== 'number' || offset < 0) {
+                throw new Error('offset must be a non-negative number when provided');
+            }
+            params.offset = offset;
+        }
+        try {
+            return await this.client.get(`${this.basePath}/find_eligible_items`, params);
+        }
+        catch (error) {
+            throw new Error(`Failed to find eligible items: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Send offer to interested buyers
+     * Endpoint: POST /send_offer_to_interested_buyers
+     * @throws Error if required parameters are missing or invalid
+     */
+    async sendOfferToInterestedBuyers(offerData) {
+        if (!offerData || typeof offerData !== 'object') {
+            throw new Error('offerData is required and must be an object');
+        }
+        try {
+            return await this.client.post(`${this.basePath}/send_offer_to_interested_buyers`, offerData);
+        }
+        catch (error) {
+            throw new Error(`Failed to send offer to interested buyers: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Get offers to buyers (Best Offers)
+     * @deprecated This method does not match any endpoint in the OpenAPI spec
+     */
+    async getOffersToBuyers(filter, limit, offset) {
+        const params = {};
+        if (filter)
+            params.filter = filter;
+        if (limit)
+            params.limit = limit;
+        if (offset)
+            params.offset = offset;
+        return await this.client.get(`${this.basePath}/offer`, params);
+    }
+    /**
+     * Get offers for listing (alias for getOffersToBuyers)
+     * Endpoint: GET /offer
+     * @throws Error if the request fails
+     */
+    async getOffersForListing(filter, limit, offset) {
+        return await this.getOffersToBuyers(filter, limit, offset);
+    }
+    /**
+     * Get a specific offer
+     * Endpoint: GET /offer/{offerId}
+     * @throws Error if required parameters are missing or invalid
+     */
+    async getOffer(offerId) {
+        if (!offerId || typeof offerId !== 'string') {
+            throw new Error('offerId is required and must be a string');
+        }
+        try {
+            return await this.client.get(`${this.basePath}/offer/${offerId}`);
+        }
+        catch (error) {
+            throw new Error(`Failed to get offer: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+}