ebay-mcp-remote-edition 1.0.0

package/build/utils/order-management/dispute.js

@@ -0,0 +1,369 @@
+import { z } from 'zod';
+/**
+ * Zod schemas for Dispute API input validation
+ * Based on: src/api/order-management/dispute.ts
+ * OpenAPI spec: docs/sell-apps/order-management/sell_fulfillment_v1_oas3.json
+ * Types from: src/types/sell_fulfillment_v1_oas3.ts
+ */
+// Reusable schema for payment dispute ID
+const paymentDisputeIdSchema = z.string({
+    message: 'Payment dispute ID is required',
+    required_error: 'payment_dispute_id is required',
+    invalid_type_error: 'payment_dispute_id must be a string',
+    description: 'The unique identifier of the payment dispute',
+});
+// Reusable schema for evidence ID
+const evidenceIdSchema = z.string({
+    message: 'Evidence ID is required',
+    required_error: 'evidence_id is required',
+    invalid_type_error: 'evidence_id must be a string',
+    description: 'The unique identifier of the evidence file set',
+});
+// Reusable schema for file ID
+const fileIdSchema = z.string({
+    message: 'File ID is required',
+    required_error: 'file_id is required',
+    invalid_type_error: 'file_id must be a string',
+    description: 'The unique identifier of an evidential file',
+});
+// Reusable schema for limit parameter (number in API)
+const limitSchema = z
+    .number({
+    invalid_type_error: 'limit must be a number',
+    description: 'Maximum number of payment disputes to return (default: 200, max: 200)',
+})
+    .optional();
+// Reusable schema for offset parameter (number in API)
+const offsetSchema = z
+    .number({
+    invalid_type_error: 'offset must be a number',
+    description: 'Number of payment disputes to skip (zero-based index)',
+})
+    .optional();
+/**
+ * Schema for getPaymentDispute method
+ * Endpoint: GET /payment_dispute/{payment_dispute_id}
+ * Path: payment_dispute_id (required)
+ */
+export const getPaymentDisputeSchema = z.object({
+    payment_dispute_id: paymentDisputeIdSchema,
+});
+/**
+ * Schema for fetchEvidenceContent method
+ * Endpoint: GET /payment_dispute/{payment_dispute_id}/fetch_evidence_content
+ * Path: payment_dispute_id (required)
+ * Query: evidence_id (required), file_id (required)
+ */
+export const fetchEvidenceContentSchema = z.object({
+    payment_dispute_id: paymentDisputeIdSchema,
+    evidence_id: evidenceIdSchema,
+    file_id: fileIdSchema,
+});
+/**
+ * Schema for getActivities method
+ * Endpoint: GET /payment_dispute/{payment_dispute_id}/activity
+ * Path: payment_dispute_id (required)
+ */
+export const getActivitiesSchema = z.object({
+    payment_dispute_id: paymentDisputeIdSchema,
+});
+/**
+ * Schema for getPaymentDisputeSummaries method
+ * Endpoint: GET /payment_dispute_summary
+ * Query: order_id, buyer_username, open_date_from, open_date_to, payment_dispute_status, limit, offset
+ */
+export const getPaymentDisputeSummariesSchema = z.object({
+    order_id: z
+        .string({
+        invalid_type_error: 'order_id must be a string',
+        description: 'Filter by a specific order ID',
+    })
+        .optional(),
+    buyer_username: z
+        .string({
+        invalid_type_error: 'buyer_username must be a string',
+        description: "Filter by buyer's eBay username",
+    })
+        .optional(),
+    open_date_from: z
+        .string({
+        invalid_type_error: 'open_date_from must be a string',
+        description: 'Filter disputes opened on or after this date (ISO 8601 format)',
+    })
+        .optional(),
+    open_date_to: z
+        .string({
+        invalid_type_error: 'open_date_to must be a string',
+        description: 'Filter disputes opened on or before this date (ISO 8601 format)',
+    })
+        .optional(),
+    payment_dispute_status: z
+        .string({
+        invalid_type_error: 'payment_dispute_status must be a string',
+        description: 'Filter by dispute status (e.g., OPEN, ACTION_NEEDED, CLOSED)',
+    })
+        .optional(),
+    limit: limitSchema,
+    offset: offsetSchema,
+});
+/**
+ * Schema for contestPaymentDispute method
+ * Endpoint: POST /payment_dispute/{payment_dispute_id}/contest
+ * Path: payment_dispute_id (required)
+ * Body: ContestPaymentDisputeRequest (optional) - note, returnAddress, revision
+ */
+export const contestPaymentDisputeSchema = z.object({
+    payment_dispute_id: paymentDisputeIdSchema,
+    note: z
+        .string({
+        invalid_type_error: 'note must be a string',
+        description: 'Information about the dispute (max 1000 characters)',
+    })
+        .max(1000, 'Note must not exceed 1000 characters')
+        .optional(),
+    return_address: z
+        .object({
+        full_name: z
+            .string({
+            invalid_type_error: 'full_name must be a string',
+            description: 'Full name of the person at the return address',
+        })
+            .optional(),
+        primary_phone: z
+            .object({
+            phone_number: z
+                .string({
+                invalid_type_error: 'phone_number must be a string',
+                description: 'Primary phone number',
+            })
+                .optional(),
+        })
+            .optional(),
+        address_line1: z
+            .string({
+            invalid_type_error: 'address_line1 must be a string',
+            description: 'First line of the street address',
+        })
+            .optional(),
+        address_line2: z
+            .string({
+            invalid_type_error: 'address_line2 must be a string',
+            description: 'Second line of the street address',
+        })
+            .optional(),
+        city: z
+            .string({
+            invalid_type_error: 'city must be a string',
+            description: 'City',
+        })
+            .optional(),
+        state_or_province: z
+            .string({
+            invalid_type_error: 'state_or_province must be a string',
+            description: 'State or province',
+        })
+            .optional(),
+        postal_code: z
+            .string({
+            invalid_type_error: 'postal_code must be a string',
+            description: 'Postal code',
+        })
+            .optional(),
+        country_code: z
+            .string({
+            invalid_type_error: 'country_code must be a string',
+            description: 'Two-letter ISO 3166-1 alpha-2 country code',
+        })
+            .optional(),
+    })
+        .optional(),
+    revision: z
+        .number({
+        invalid_type_error: 'revision must be a number',
+        description: 'Revision number of the payment dispute (required)',
+    })
+        .optional(),
+});
+/**
+ * Schema for acceptPaymentDispute method
+ * Endpoint: POST /payment_dispute/{payment_dispute_id}/accept
+ * Path: payment_dispute_id (required)
+ * Body: AcceptPaymentDisputeRequest (optional) - returnAddress, revision
+ */
+export const acceptPaymentDisputeSchema = z.object({
+    payment_dispute_id: paymentDisputeIdSchema,
+    return_address: z
+        .object({
+        full_name: z
+            .string({
+            invalid_type_error: 'full_name must be a string',
+            description: 'Full name of the person at the return address',
+        })
+            .optional(),
+        primary_phone: z
+            .object({
+            phone_number: z
+                .string({
+                invalid_type_error: 'phone_number must be a string',
+                description: 'Primary phone number',
+            })
+                .optional(),
+        })
+            .optional(),
+        address_line1: z
+            .string({
+            invalid_type_error: 'address_line1 must be a string',
+            description: 'First line of the street address',
+        })
+            .optional(),
+        address_line2: z
+            .string({
+            invalid_type_error: 'address_line2 must be a string',
+            description: 'Second line of the street address',
+        })
+            .optional(),
+        city: z
+            .string({
+            invalid_type_error: 'city must be a string',
+            description: 'City',
+        })
+            .optional(),
+        state_or_province: z
+            .string({
+            invalid_type_error: 'state_or_province must be a string',
+            description: 'State or province',
+        })
+            .optional(),
+        postal_code: z
+            .string({
+            invalid_type_error: 'postal_code must be a string',
+            description: 'Postal code',
+        })
+            .optional(),
+        country_code: z
+            .string({
+            invalid_type_error: 'country_code must be a string',
+            description: 'Two-letter ISO 3166-1 alpha-2 country code',
+        })
+            .optional(),
+    })
+        .optional(),
+    revision: z
+        .number({
+        invalid_type_error: 'revision must be a number',
+        description: 'Revision number of the payment dispute (required)',
+    })
+        .optional(),
+});
+/**
+ * Schema for uploadEvidenceFile method
+ * Endpoint: POST /payment_dispute/{payment_dispute_id}/upload_evidence_file
+ * Path: payment_dispute_id (required)
+ * Body: ArrayBuffer (binary file data)
+ */
+export const uploadEvidenceFileSchema = z.object({
+    payment_dispute_id: paymentDisputeIdSchema,
+    file_data: z.instanceof(ArrayBuffer, {
+        message: 'File data must be an ArrayBuffer',
+    }),
+});
+/**
+ * Schema for addEvidence method
+ * Endpoint: POST /payment_dispute/{payment_dispute_id}/add_evidence
+ * Path: payment_dispute_id (required)
+ * Body: AddEvidencePaymentDisputeRequest - evidenceType, files, lineItems
+ */
+export const addEvidenceSchema = z.object({
+    payment_dispute_id: paymentDisputeIdSchema,
+    evidence_type: z
+        .string({
+        invalid_type_error: 'evidence_type must be a string',
+        description: 'Type of evidence (e.g., PROOF_OF_DELIVERY, PROOF_OF_AUTHENTICATION)',
+    })
+        .optional(),
+    files: z
+        .array(z.object({
+        file_id: z
+            .string({
+            invalid_type_error: 'file_id must be a string',
+            description: 'Unique identifier of the evidence file',
+        })
+            .optional(),
+    }), {
+        invalid_type_error: 'files must be an array',
+        description: 'Array of evidence files',
+    })
+        .optional(),
+    line_items: z
+        .array(z.object({
+        item_id: z
+            .string({
+            invalid_type_error: 'item_id must be a string',
+            description: 'eBay listing ID',
+        })
+            .optional(),
+        line_item_id: z
+            .string({
+            invalid_type_error: 'line_item_id must be a string',
+            description: 'Unique identifier of the line item',
+        })
+            .optional(),
+    }), {
+        invalid_type_error: 'line_items must be an array',
+        description: 'Array of order line items',
+    })
+        .optional(),
+});
+/**
+ * Schema for updateEvidence method
+ * Endpoint: POST /payment_dispute/{payment_dispute_id}/update_evidence
+ * Path: payment_dispute_id (required)
+ * Body: UpdateEvidencePaymentDisputeRequest - evidenceId, evidenceType, files, lineItems
+ */
+export const updateEvidenceSchema = z.object({
+    payment_dispute_id: paymentDisputeIdSchema,
+    evidence_id: z
+        .string({
+        invalid_type_error: 'evidence_id must be a string',
+        description: 'Unique identifier of the evidence set to update',
+    })
+        .optional(),
+    evidence_type: z
+        .string({
+        invalid_type_error: 'evidence_type must be a string',
+        description: 'Type of evidence (e.g., PROOF_OF_DELIVERY, PROOF_OF_AUTHENTICATION)',
+    })
+        .optional(),
+    files: z
+        .array(z.object({
+        file_id: z
+            .string({
+            invalid_type_error: 'file_id must be a string',
+            description: 'Unique identifier of the evidence file',
+        })
+            .optional(),
+    }), {
+        invalid_type_error: 'files must be an array',
+        description: 'Array of evidence files',
+    })
+        .optional(),
+    line_items: z
+        .array(z.object({
+        item_id: z
+            .string({
+            invalid_type_error: 'item_id must be a string',
+            description: 'eBay listing ID',
+        })
+            .optional(),
+        line_item_id: z
+            .string({
+            invalid_type_error: 'line_item_id must be a string',
+            description: 'Unique identifier of the line item',
+        })
+            .optional(),
+    }), {
+        invalid_type_error: 'line_items must be an array',
+        description: 'Array of order line items',
+    })
+        .optional(),
+});

package/build/utils/order-management/fulfillment.js

@@ -0,0 +1,205 @@
+import { z } from 'zod';
+/**
+ * Zod schemas for Fulfillment API input validation
+ * Based on: src/api/order-management/fulfillment.ts
+ * OpenAPI spec: docs/sell-apps/order-management/sell_fulfillment_v1_oas3.json
+ * Types from: src/types/sell_fulfillment_v1_oas3.ts
+ */
+// Reusable schema for order ID
+const orderIdSchema = z.string({
+    message: 'Order ID is required',
+    required_error: 'order_id is required',
+    invalid_type_error: 'order_id must be a string',
+    description: 'The unique identifier of the order',
+});
+// Reusable schema for fulfillment ID
+const fulfillmentIdSchema = z.string({
+    message: 'Fulfillment ID is required',
+    required_error: 'fulfillment_id is required',
+    invalid_type_error: 'fulfillment_id must be a string',
+    description: 'The unique identifier of the shipping fulfillment',
+});
+// Reusable schema for filter parameter
+const filterSchema = z
+    .string({
+    invalid_type_error: 'filter must be a string',
+    description: 'Filter criteria for orders (e.g., orderfulfillmentstatus:{NOT_STARTED|IN_PROGRESS}, creationdate:[2020-01-01T00:00:00.000Z..2020-12-31T23:59:59.999Z])',
+})
+    .optional();
+// Reusable schema for limit parameter (number in API)
+const limitSchema = z
+    .number({
+    invalid_type_error: 'limit must be a number',
+    description: 'Maximum number of orders to return (default: 50)',
+})
+    .optional();
+// Reusable schema for offset parameter (number in API)
+const offsetSchema = z
+    .number({
+    invalid_type_error: 'offset must be a number',
+    description: 'Number of orders to skip (zero-based index)',
+})
+    .optional();
+/**
+ * Schema for getOrders method
+ * Endpoint: GET /order
+ * Query: filter, limit, offset
+ */
+export const getOrdersSchema = z.object({
+    filter: filterSchema,
+    limit: limitSchema,
+    offset: offsetSchema,
+});
+/**
+ * Schema for getOrder method
+ * Endpoint: GET /order/{orderId}
+ * Path: orderId (required)
+ */
+export const getOrderSchema = z.object({
+    order_id: orderIdSchema,
+});
+/**
+ * Schema for createShippingFulfillment method
+ * Endpoint: POST /order/{orderId}/shipping_fulfillment
+ * Path: orderId (required)
+ * Body: ShippingFulfillmentDetails - lineItems, shippedDate, shippingCarrierCode, trackingNumber
+ */
+export const createShippingFulfillmentSchema = z.object({
+    order_id: orderIdSchema,
+    line_items: z
+        .array(z.object({
+        line_item_id: z
+            .string({
+            invalid_type_error: 'line_item_id must be a string',
+            description: 'Unique identifier of the line item',
+        })
+            .optional(),
+        quantity: z
+            .number({
+            invalid_type_error: 'quantity must be a number',
+            description: 'Number of units being fulfilled',
+        })
+            .optional(),
+    }), {
+        invalid_type_error: 'line_items must be an array',
+        description: 'Array of line items to fulfill (required)',
+    })
+        .optional(),
+    shipped_date: z
+        .string({
+        invalid_type_error: 'shipped_date must be a string',
+        description: 'Date/time the order was shipped (ISO 8601 format, defaults to current time)',
+    })
+        .optional(),
+    shipping_carrier_code: z
+        .string({
+        invalid_type_error: 'shipping_carrier_code must be a string',
+        description: 'Shipping carrier code (e.g., USPS, UPS, FEDEX)',
+    })
+        .optional(),
+    tracking_number: z
+        .string({
+        invalid_type_error: 'tracking_number must be a string',
+        description: 'Shipment tracking number',
+    })
+        .optional(),
+});
+/**
+ * Schema for getShippingFulfillments method
+ * Endpoint: GET /order/{orderId}/shipping_fulfillment
+ * Path: orderId (required)
+ */
+export const getShippingFulfillmentsSchema = z.object({
+    order_id: orderIdSchema,
+});
+/**
+ * Schema for getShippingFulfillment method
+ * Endpoint: GET /order/{orderId}/shipping_fulfillment/{fulfillmentId}
+ * Path: orderId (required), fulfillmentId (required)
+ */
+export const getShippingFulfillmentSchema = z.object({
+    order_id: orderIdSchema,
+    fulfillment_id: fulfillmentIdSchema,
+});
+/**
+ * Schema for issueRefund method
+ * Endpoint: POST /order/{orderId}/issue_refund
+ * Path: orderId (required)
+ * Body: IssueRefundRequest - reasonForRefund, comment, refundItems, orderLevelRefundAmount
+ */
+export const issueRefundSchema = z.object({
+    order_id: orderIdSchema,
+    reason_for_refund: z
+        .string({
+        invalid_type_error: 'reason_for_refund must be a string',
+        description: 'Reason for issuing the refund (e.g., BUYER_CANCEL, OUT_OF_STOCK)',
+    })
+        .optional(),
+    comment: z
+        .string({
+        invalid_type_error: 'comment must be a string',
+        description: 'Optional comment about the refund',
+    })
+        .optional(),
+    refund_items: z
+        .array(z.object({
+        line_item_id: z
+            .string({
+            invalid_type_error: 'line_item_id must be a string',
+            description: 'Unique identifier of the line item to refund',
+        })
+            .optional(),
+        refund_amount: z
+            .object({
+            value: z
+                .string({
+                invalid_type_error: 'value must be a string',
+                description: 'Monetary amount',
+            })
+                .optional(),
+            currency: z
+                .string({
+                invalid_type_error: 'currency must be a string',
+                description: 'Three-letter ISO 4217 currency code',
+            })
+                .optional(),
+        })
+            .optional(),
+        legacy_reference: z
+            .object({
+            legacy_item_id: z
+                .string({
+                invalid_type_error: 'legacy_item_id must be a string',
+                description: 'Legacy eBay item ID',
+            })
+                .optional(),
+            legacy_transaction_id: z
+                .string({
+                invalid_type_error: 'legacy_transaction_id must be a string',
+                description: 'Legacy transaction ID',
+            })
+                .optional(),
+        })
+            .optional(),
+    }), {
+        invalid_type_error: 'refund_items must be an array',
+        description: 'Array of line items to refund',
+    })
+        .optional(),
+    order_level_refund_amount: z
+        .object({
+        value: z
+            .string({
+            invalid_type_error: 'value must be a string',
+            description: 'Monetary amount',
+        })
+            .optional(),
+        currency: z
+            .string({
+            invalid_type_error: 'currency must be a string',
+            description: 'Three-letter ISO 4217 currency code',
+        })
+            .optional(),
+    })
+        .optional(),
+});

package/build/utils/other/compliance.js

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+/**
+ * Zod schemas for Compliance API input validation
+ * Based on: src/api/other/compliance.ts
+ * OpenAPI spec: docs/sell-apps/other-apis/sell_compliance_v1_oas3.json
+ * Types from: src/types/sell_compliance_v1_oas3.ts
+ */
+// Reusable schema for compliance_type parameter
+const complianceTypeSchema = z
+    .string({
+    invalid_type_error: 'compliance_type must be a string',
+    description: 'Compliance type(s) to filter violations (e.g., ASPECTS_ADOPTION, HTTPS, OUTSIDE_EBAY_BUYING_AND_SELLING, RETURNS_POLICY)',
+})
+    .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 (zero-based index)',
+})
+    .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 (default: 100, max: 200)',
+})
+    .optional();
+/**
+ * Schema for getListingViolations method
+ * Endpoint: GET /listing_violation
+ * Query: GetListingViolationsParams - compliance_type (required), offset, limit, listing_id, filter
+ */
+export const getListingViolationsSchema = z.object({
+    compliance_type: z.string({
+        message: 'Compliance type is required',
+        required_error: 'compliance_type is required',
+        invalid_type_error: 'compliance_type must be a string',
+        description: 'The compliance type of violations to retrieve (only one type allowed per call)',
+    }),
+    offset: offsetSchema,
+    limit: limitSchema,
+    listing_id: z
+        .string({
+        invalid_type_error: 'listing_id must be a string',
+        description: 'Filter by specific eBay listing ID (not yet supported)',
+    })
+        .optional(),
+    filter: z
+        .string({
+        invalid_type_error: 'filter must be a string',
+        description: 'Filter by compliance state (e.g., complianceState:{OUT_OF_COMPLIANCE})',
+    })
+        .optional(),
+});
+/**
+ * Schema for getListingViolationsSummary method
+ * Endpoint: GET /listing_violation_summary
+ * Query: GetListingViolationsSummaryParams - compliance_type
+ */
+export const getListingViolationsSummarySchema = z.object({
+    compliance_type: complianceTypeSchema,
+});
+/**
+ * Schema for suppressViolation method
+ * Endpoint: POST /suppress_violation
+ * Body: listing_violation_id (required)
+ */
+export const suppressViolationSchema = z.object({
+    listing_violation_id: z.string({
+        message: 'Listing violation ID is required',
+        required_error: 'listing_violation_id is required',
+        invalid_type_error: 'listing_violation_id must be a string',
+        description: 'The unique identifier of the listing violation to suppress',
+    }),
+});