ebay-mcp 1.4.3

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.d.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+/**
+ * Schema for getListingViolations method
+ * Endpoint: GET /listing_violation
+ * Query: GetListingViolationsParams - compliance_type (required), offset, limit, listing_id, filter
+ */
+export declare const getListingViolationsSchema: z.ZodObject<{
+    compliance_type: z.ZodString;
+    offset: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodString>;
+    listing_id: z.ZodOptional<z.ZodString>;
+    filter: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    compliance_type: string;
+    filter?: string | undefined;
+    limit?: string | undefined;
+    offset?: string | undefined;
+    listing_id?: string | undefined;
+}, {
+    compliance_type: string;
+    filter?: string | undefined;
+    limit?: string | undefined;
+    offset?: string | undefined;
+    listing_id?: string | undefined;
+}>;
+/**
+ * Schema for getListingViolationsSummary method
+ * Endpoint: GET /listing_violation_summary
+ * Query: GetListingViolationsSummaryParams - compliance_type
+ */
+export declare const getListingViolationsSummarySchema: z.ZodObject<{
+    compliance_type: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    compliance_type?: string | undefined;
+}, {
+    compliance_type?: string | undefined;
+}>;
+/**
+ * Schema for suppressViolation method
+ * Endpoint: POST /suppress_violation
+ * Body: listing_violation_id (required)
+ */
+export declare const suppressViolationSchema: z.ZodObject<{
+    listing_violation_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    listing_violation_id: string;
+}, {
+    listing_violation_id: string;
+}>;

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',
+    }),
+});

package/build/utils/other/edelivery.d.ts

@@ -0,0 +1,310 @@
+import { z } from 'zod';
+/**
+ * Schema for createShippingQuote method
+ * Endpoint: POST /shipping_quote
+ * Body: ShippingQuoteRequest - complex object with shipping details
+ */
+export declare const createShippingQuoteSchema: z.ZodObject<{
+    shipping_quote_request: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    shipping_quote_request: Record<string, unknown>;
+}, {
+    shipping_quote_request: Record<string, unknown>;
+}>;
+/**
+ * Schema for getShippingQuote method
+ * Endpoint: GET /shipping_quote/{shipping_quote_id}
+ * Path: shipping_quote_id (required)
+ */
+export declare const getShippingQuoteSchema: z.ZodObject<{
+    shipping_quote_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    shipping_quote_id: string;
+}, {
+    shipping_quote_id: string;
+}>;
+/**
+ * Schema for getActualCosts method
+ * Endpoint: GET /actual_costs
+ */
+export declare const getActualCostsSchema: z.ZodObject<{
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    params?: Record<string, string> | undefined;
+}, {
+    params?: Record<string, string> | undefined;
+}>;
+/**
+ * Schema for getAddressPreferences method
+ * Endpoint: GET /address_preference
+ */
+export declare const getAddressPreferencesSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+/**
+ * Schema for createAddressPreference method
+ * Endpoint: POST /address_preference
+ */
+export declare const createAddressPreferenceSchema: z.ZodObject<{
+    address_preference: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    address_preference: Record<string, unknown>;
+}, {
+    address_preference: Record<string, unknown>;
+}>;
+/**
+ * Schema for getConsignPreferences method
+ * Endpoint: GET /consign_preference
+ */
+export declare const getConsignPreferencesSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+/**
+ * Schema for createConsignPreference method
+ * Endpoint: POST /consign_preference
+ */
+export declare const createConsignPreferenceSchema: z.ZodObject<{
+    consign_preference: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    consign_preference: Record<string, unknown>;
+}, {
+    consign_preference: Record<string, unknown>;
+}>;
+/**
+ * Schema for getAgents method
+ * Endpoint: GET /agents
+ */
+export declare const getAgentsSchema: z.ZodObject<{
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    params?: Record<string, string> | undefined;
+}, {
+    params?: Record<string, string> | undefined;
+}>;
+/**
+ * Schema for getBatteryQualifications method
+ * Endpoint: GET /battery_qualifications
+ */
+export declare const getBatteryQualificationsSchema: z.ZodObject<{
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    params?: Record<string, string> | undefined;
+}, {
+    params?: Record<string, string> | undefined;
+}>;
+/**
+ * Schema for getDropoffSites method
+ * Endpoint: GET /dropoff_sites
+ */
+export declare const getDropoffSitesSchema: z.ZodObject<{
+    params: z.ZodRecord<z.ZodString, z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    params: Record<string, string>;
+}, {
+    params: Record<string, string>;
+}>;
+/**
+ * Schema for getShippingServices method
+ * Endpoint: GET /services
+ */
+export declare const getShippingServicesSchema: z.ZodObject<{
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    params?: Record<string, string> | undefined;
+}, {
+    params?: Record<string, string> | undefined;
+}>;
+/**
+ * Schema for createBundle method
+ * Endpoint: POST /bundle
+ */
+export declare const createBundleSchema: z.ZodObject<{
+    bundle_request: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    bundle_request: Record<string, unknown>;
+}, {
+    bundle_request: Record<string, unknown>;
+}>;
+/**
+ * Schema for getBundle method
+ * Endpoint: GET /bundle/{bundle_id}
+ */
+export declare const getBundleSchema: z.ZodObject<{
+    bundle_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    bundle_id: string;
+}, {
+    bundle_id: string;
+}>;
+/**
+ * Schema for cancelBundle method
+ * Endpoint: POST /bundle/{bundle_id}/cancel
+ */
+export declare const cancelBundleSchema: z.ZodObject<{
+    bundle_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    bundle_id: string;
+}, {
+    bundle_id: string;
+}>;
+/**
+ * Schema for getBundleLabel method
+ * Endpoint: GET /bundle/{bundle_id}/label
+ */
+export declare const getBundleLabelSchema: z.ZodObject<{
+    bundle_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    bundle_id: string;
+}, {
+    bundle_id: string;
+}>;
+/**
+ * Schema for createPackage method
+ * Endpoint: POST /package
+ */
+export declare const createPackageSchema: z.ZodObject<{
+    package_request: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    package_request: Record<string, unknown>;
+}, {
+    package_request: Record<string, unknown>;
+}>;
+/**
+ * Schema for getPackage method
+ * Endpoint: GET /package/{package_id}
+ */
+export declare const getPackageSchema: z.ZodObject<{
+    package_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    package_id: string;
+}, {
+    package_id: string;
+}>;
+/**
+ * Schema for deletePackage method
+ * Endpoint: DELETE /package/{package_id}
+ */
+export declare const deletePackageSchema: z.ZodObject<{
+    package_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    package_id: string;
+}, {
+    package_id: string;
+}>;
+/**
+ * Schema for getPackageByOrderLineItem method
+ * Endpoint: GET /package/{order_line_item_id}/item
+ */
+export declare const getPackageByOrderLineItemSchema: z.ZodObject<{
+    order_line_item_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    order_line_item_id: string;
+}, {
+    order_line_item_id: string;
+}>;
+/**
+ * Schema for cancelPackage method
+ * Endpoint: POST /package/{package_id}/cancel
+ */
+export declare const cancelPackageSchema: z.ZodObject<{
+    package_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    package_id: string;
+}, {
+    package_id: string;
+}>;
+/**
+ * Schema for clonePackage method
+ * Endpoint: POST /package/{package_id}/clone
+ */
+export declare const clonePackageSchema: z.ZodObject<{
+    package_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    package_id: string;
+}, {
+    package_id: string;
+}>;
+/**
+ * Schema for confirmPackage method
+ * Endpoint: POST /package/{package_id}/confirm
+ */
+export declare const confirmPackageSchema: z.ZodObject<{
+    package_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    package_id: string;
+}, {
+    package_id: string;
+}>;
+/**
+ * Schema for bulkCancelPackages method
+ * Endpoint: POST /package/bulk_cancel_packages
+ */
+export declare const bulkCancelPackagesSchema: z.ZodObject<{
+    bulk_cancel_request: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    bulk_cancel_request: Record<string, unknown>;
+}, {
+    bulk_cancel_request: Record<string, unknown>;
+}>;
+/**
+ * Schema for bulkConfirmPackages method
+ * Endpoint: POST /package/bulk_confirm_packages
+ */
+export declare const bulkConfirmPackagesSchema: z.ZodObject<{
+    bulk_confirm_request: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    bulk_confirm_request: Record<string, unknown>;
+}, {
+    bulk_confirm_request: Record<string, unknown>;
+}>;
+/**
+ * Schema for bulkDeletePackages method
+ * Endpoint: POST /package/bulk_delete_packages
+ */
+export declare const bulkDeletePackagesSchema: z.ZodObject<{
+    bulk_delete_request: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    bulk_delete_request: Record<string, unknown>;
+}, {
+    bulk_delete_request: Record<string, unknown>;
+}>;
+/**
+ * Schema for getLabels method
+ * Endpoint: GET /labels
+ */
+export declare const getLabelsSchema: z.ZodObject<{
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    params?: Record<string, string> | undefined;
+}, {
+    params?: Record<string, string> | undefined;
+}>;
+/**
+ * Schema for getHandoverSheet method
+ * Endpoint: GET /handover_sheet
+ */
+export declare const getHandoverSheetSchema: z.ZodObject<{
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    params?: Record<string, string> | undefined;
+}, {
+    params?: Record<string, string> | undefined;
+}>;
+/**
+ * Schema for getTracking method
+ * Endpoint: GET /tracking
+ */
+export declare const getTrackingSchema: z.ZodObject<{
+    params: z.ZodRecord<z.ZodString, z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    params: Record<string, string>;
+}, {
+    params: Record<string, string>;
+}>;
+/**
+ * Schema for createComplaint method
+ * Endpoint: POST /complaint
+ */
+export declare const createComplaintSchema: z.ZodObject<{
+    complaint_request: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    complaint_request: Record<string, unknown>;
+}, {
+    complaint_request: Record<string, unknown>;
+}>;