ebay-mcp 1.4.3

package/build/api/marketing-and-promotions/marketing.js

@@ -0,0 +1,565 @@
+/**
+ * Marketing API - Marketing campaigns and promotions
+ * Based on: docs/sell-apps/marketing-and-promotions/sell_marketing_v1_oas3.json
+ */
+export class MarketingApi {
+    client;
+    basePath = '/sell/marketing/v1';
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get campaigns
+     */
+    async getCampaigns(campaignStatus, marketplaceId, limit) {
+        const params = {};
+        if (campaignStatus)
+            params.campaign_status = campaignStatus;
+        if (marketplaceId)
+            params.marketplace_id = marketplaceId;
+        if (limit)
+            params.limit = limit;
+        return await this.client.get(`${this.basePath}/ad_campaign`, params);
+    }
+    /**
+     * Get a specific campaign
+     */
+    async getCampaign(campaignId) {
+        return await this.client.get(`${this.basePath}/ad_campaign/${campaignId}`);
+    }
+    /**
+     * Create a campaign
+     */
+    async createCampaign(campaign) {
+        return await this.client.post(`${this.basePath}/ad_campaign`, campaign);
+    }
+    /**
+     * Get promotions
+     */
+    async getPromotions(marketplaceId, limit) {
+        const params = {};
+        if (marketplaceId)
+            params.marketplace_id = marketplaceId;
+        if (limit)
+            params.limit = limit;
+        return await this.client.get(`${this.basePath}/promotion`, params);
+    }
+    /**
+     * Create a promotion (item promotion)
+     */
+    async createPromotion(promotion) {
+        return await this.client.post(`${this.basePath}/item_promotion`, promotion);
+    }
+    /**
+     * Get ads for a campaign
+     */
+    async getAds(campaignId, adGroupIds, adStatus, limit, listingIds, offset) {
+        const params = {};
+        if (adGroupIds)
+            params.ad_group_ids = adGroupIds;
+        if (adStatus)
+            params.ad_status = adStatus;
+        if (limit)
+            params.limit = limit;
+        if (listingIds)
+            params.listing_ids = listingIds;
+        if (offset)
+            params.offset = offset;
+        return await this.client.get(`${this.basePath}/ad_campaign/${campaignId}/ad`, params);
+    }
+    /**
+     * Create an ad for a campaign
+     */
+    async createAd(campaignId, ad) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/ad`, ad);
+    }
+    /**
+     * Create ads by inventory reference for a campaign
+     */
+    async createAdsByInventoryReference(campaignId, ads) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/create_ads_by_inventory_reference`, ads);
+    }
+    /**
+     * Get a specific ad for a campaign
+     */
+    async getAd(campaignId, adId) {
+        return await this.client.get(`${this.basePath}/ad_campaign/${campaignId}/ad/${adId}`);
+    }
+    /**
+     * Delete a specific ad from a campaign
+     */
+    async deleteAd(campaignId, adId) {
+        return await this.client.delete(`${this.basePath}/ad_campaign/${campaignId}/ad/${adId}`);
+    }
+    /**
+     * Clone an ad for a campaign
+     */
+    async cloneAd(campaignId, adId, ad) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/ad/${adId}/clone`, ad);
+    }
+    /**
+     * Get ads by inventory reference for a campaign
+     */
+    async getAdsByInventoryReference(campaignId, inventoryReferenceId, inventoryReferenceType) {
+        const params = {
+            inventory_reference_id: inventoryReferenceId,
+            inventory_reference_type: inventoryReferenceType,
+        };
+        return await this.client.get(`${this.basePath}/ad_campaign/${campaignId}/get_ads_by_inventory_reference`, params);
+    }
+    /**
+     * Get ads by listing ID for a campaign
+     */
+    async getAdsByListingId(campaignId, listingId) {
+        const params = {
+            listing_id: listingId,
+        };
+        return await this.client.get(`${this.basePath}/ad_campaign/${campaignId}/get_ads_by_listing_id`, params);
+    }
+    /**
+     * Update the bid for an ad in a campaign
+     */
+    async updateBid(campaignId, adId, bid) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/ad/${adId}/update_bid`, bid);
+    }
+    /**
+     * Clone a campaign
+     */
+    async cloneCampaign(campaignId, campaign) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/clone`, campaign);
+    }
+    /**
+     * End a campaign
+     */
+    async endCampaign(campaignId) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/end`, {});
+    }
+    /**
+     * Get campaign by name
+     */
+    async getCampaignByName(campaignName) {
+        const params = {
+            campaign_name: campaignName,
+        };
+        return await this.client.get(`${this.basePath}/ad_campaign/get_campaign_by_name`, params);
+    }
+    /**
+     * Bulk create ads by inventory reference
+     */
+    async bulkCreateAdsByInventoryReference(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/bulk_create_ads_by_inventory_reference`, body);
+    }
+    /**
+     * Bulk create ads by listing id
+     */
+    async bulkCreateAdsByListingId(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/bulk_create_ads_by_listing_id`, body);
+    }
+    /**
+     * Bulk delete ads by inventory reference
+     */
+    async bulkDeleteAdsByInventoryReference(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/bulk_delete_ads_by_inventory_reference`, body);
+    }
+    /**
+     * Bulk delete ads by listing id
+     */
+    async bulkDeleteAdsByListingId(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/bulk_delete_ads_by_listing_id`, body);
+    }
+    /**
+     * Bulk update ads bid by inventory reference
+     */
+    async bulkUpdateAdsBidByInventoryReference(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/bulk_update_ads_bid_by_inventory_reference`, body);
+    }
+    /**
+     * Bulk update ads bid by listing id
+     */
+    async bulkUpdateAdsBidByListingId(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/bulk_update_ads_bid_by_listing_id`, body);
+    }
+    /**
+     * Bulk update ads status
+     */
+    async bulkUpdateAdsStatus(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/bulk_update_ads_status`, body);
+    }
+    /**
+     * Bulk update ads status by listing id
+     */
+    async bulkUpdateAdsStatusByListingId(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/bulk_update_ads_status_by_listing_id`, body);
+    }
+    /**
+     * Pause a campaign
+     */
+    async pauseCampaign(campaignId) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/pause`, {});
+    }
+    /**
+     * Resume a campaign
+     */
+    async resumeCampaign(campaignId) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/resume`, {});
+    }
+    /**
+     * Update campaign identification
+     */
+    async updateCampaignIdentification(campaignId, body) {
+        return await this.client.put(`${this.basePath}/ad_campaign/${campaignId}/update_campaign_identification`, body);
+    }
+    /**
+     * Create an ad group
+     */
+    async createAdGroup(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/ad_group`, body);
+    }
+    /**
+     * Clone an ad group
+     */
+    async cloneAdGroup(campaignId, adGroupId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}/clone`, body);
+    }
+    /**
+     * Get ad groups
+     */
+    async getAdGroups(campaignId, adGroupStatus, limit, offset) {
+        const params = {};
+        if (adGroupStatus)
+            params.ad_group_status = adGroupStatus;
+        if (limit)
+            params.limit = limit;
+        if (offset)
+            params.offset = offset;
+        return await this.client.get(`${this.basePath}/ad_campaign/${campaignId}/ad_group`, params);
+    }
+    /**
+     * Get an ad group
+     */
+    async getAdGroup(campaignId, adGroupId) {
+        return await this.client.get(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}`);
+    }
+    /**
+     * Suggest bids for an ad group
+     */
+    async suggestBids(campaignId, adGroupId) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}/suggest_bids`, {});
+    }
+    /**
+     * Update ad group bids
+     */
+    async updateAdGroupBids(campaignId, adGroupId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}/update_ad_group_bids`, body);
+    }
+    /**
+     * Update ad group keywords
+     */
+    async updateAdGroupKeywords(campaignId, adGroupId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}/update_ad_group_keywords`, body);
+    }
+    /**
+     * Suggest keywords
+     */
+    async suggestKeywords(campaignId, adGroupId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}/suggest_keywords`, body);
+    }
+    /**
+     * Get keywords
+     */
+    async getKeywords(campaignId, adGroupId, keywordStatus, limit, offset) {
+        const params = {};
+        if (keywordStatus)
+            params.keyword_status = keywordStatus;
+        if (limit)
+            params.limit = limit;
+        if (offset)
+            params.offset = offset;
+        return await this.client.get(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}/keyword`, params);
+    }
+    /**
+     * Bulk create keywords
+     */
+    async bulkCreateKeywords(campaignId, adGroupId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}/bulk_create_keywords`, body);
+    }
+    /**
+     * Bulk delete keywords
+     */
+    async bulkDeleteKeywords(campaignId, adGroupId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}/bulk_delete_keywords`, body);
+    }
+    /**
+     * Bulk update keyword bids
+     */
+    async bulkUpdateKeywordBids(campaignId, adGroupId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}/bulk_update_keyword_bids`, body);
+    }
+    /**
+     * Create a keyword
+     */
+    async createKeyword(campaignId, adGroupId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}/create_keyword`, body);
+    }
+    /**
+     * Get a keyword
+     */
+    async getKeyword(campaignId, adGroupId, keywordId) {
+        return await this.client.get(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}/keyword/${keywordId}`);
+    }
+    /**
+     * Delete a keyword
+     */
+    async deleteKeyword(campaignId, adGroupId, keywordId) {
+        return await this.client.delete(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}/keyword/${keywordId}`);
+    }
+    /**
+     * Update a keyword's bid
+     */
+    async updateKeywordBid(campaignId, adGroupId, keywordId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/ad_group/${adGroupId}/keyword/${keywordId}/update_bid`, body);
+    }
+    /**
+     * Get ad report
+     */
+    async getAdReport(dimension, metric, startDate, endDate, sort, listingIds, marketplaceId) {
+        const params = {
+            dimension,
+            metric,
+            start_date: startDate,
+            end_date: endDate,
+        };
+        if (sort)
+            params.sort = sort;
+        if (listingIds)
+            params.listing_ids = listingIds;
+        if (marketplaceId)
+            params.marketplace_id = marketplaceId;
+        return await this.client.get(`${this.basePath}/ad_report`, params);
+    }
+    /**
+     * Get ad report metadata
+     */
+    async getAdReportMetadata() {
+        return await this.client.get(`${this.basePath}/ad_report_metadata`);
+    }
+    /**
+     * Get ad report metadata for a report type
+     */
+    async getAdReportMetadataForReportType(reportType) {
+        return await this.client.get(`${this.basePath}/ad_report_metadata/${reportType}`);
+    }
+    /**
+     * Create a report task
+     */
+    async createReportTask(body) {
+        return await this.client.post(`${this.basePath}/ad_report_task`, body);
+    }
+    /**
+     * Get report tasks
+     */
+    async getReportTasks(reportTaskStatuses, limit, offset) {
+        const params = {};
+        if (reportTaskStatuses)
+            params.report_task_statuses = reportTaskStatuses;
+        if (limit)
+            params.limit = limit;
+        if (offset)
+            params.offset = offset;
+        return await this.client.get(`${this.basePath}/ad_report_task`, params);
+    }
+    /**
+     * Get a report task
+     */
+    async getReportTask(reportTaskId) {
+        return await this.client.get(`${this.basePath}/ad_report_task/${reportTaskId}`);
+    }
+    /**
+     * Get an item promotion
+     */
+    async getItemPromotion(promotionId) {
+        return await this.client.get(`${this.basePath}/item_promotion/${promotionId}`);
+    }
+    /**
+     * Delete an item promotion
+     */
+    async deleteItemPromotion(promotionId) {
+        return await this.client.delete(`${this.basePath}/item_promotion/${promotionId}`);
+    }
+    /**
+     * Pause an item promotion
+     */
+    async pauseItemPromotion(promotionId) {
+        return await this.client.post(`${this.basePath}/item_promotion/${promotionId}/pause`, {});
+    }
+    /**
+     * Resume an item promotion
+     */
+    async resumeItemPromotion(promotionId) {
+        return await this.client.post(`${this.basePath}/item_promotion/${promotionId}/resume`, {});
+    }
+    /**
+     * Update an item promotion
+     */
+    async updateItemPromotion(promotionId, body) {
+        return await this.client.put(`${this.basePath}/item_promotion/${promotionId}`, body);
+    }
+    /**
+     * Get a promotion report
+     */
+    async getPromotionReport(marketplaceId, promotionStatus, limit, offset) {
+        const params = {
+            marketplace_id: marketplaceId,
+        };
+        if (promotionStatus)
+            params.promotion_status = promotionStatus;
+        if (limit)
+            params.limit = limit;
+        if (offset)
+            params.offset = offset;
+        return await this.client.get(`${this.basePath}/promotion_report`, params);
+    }
+    /**
+     * Get a promotion summary report
+     */
+    async getPromotionSummaryReport(marketplaceId) {
+        const params = { marketplace_id: marketplaceId };
+        return await this.client.get(`${this.basePath}/promotion_summary_report`, params);
+    }
+    /**
+     * Get promotion summary (alias for getPromotionSummaryReport)
+     */
+    async getPromotionSummary(marketplaceId) {
+        return this.getPromotionSummaryReport(marketplaceId);
+    }
+    /**
+     * Get promotion reports (alias for getPromotionReport)
+     */
+    async getPromotionReports(marketplaceId, promotionStatus, limit, offset) {
+        return this.getPromotionReport(marketplaceId, promotionStatus, limit, offset);
+    }
+    /**
+     * Get targeting for a campaign
+     */
+    async getTargeting(campaignId) {
+        return await this.client.get(`${this.basePath}/ad_campaign/${campaignId}/targeting`);
+    }
+    /**
+     * Create targeting for a campaign
+     */
+    async createTargeting(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/targeting`, body);
+    }
+    /**
+     * Update targeting for a campaign
+     */
+    async updateTargeting(campaignId, body) {
+        return await this.client.put(`${this.basePath}/ad_campaign/${campaignId}/targeting`, body);
+    }
+    /**
+     * Get negative keywords for a campaign
+     */
+    async getNegativeKeywords(campaignId, limit, offset) {
+        const params = {};
+        if (limit)
+            params.limit = limit;
+        if (offset)
+            params.offset = offset;
+        return await this.client.get(`${this.basePath}/ad_campaign/${campaignId}/negative_keyword`, params);
+    }
+    /**
+     * Create a negative keyword for a campaign
+     */
+    async createNegativeKeyword(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/negative_keyword`, body);
+    }
+    /**
+     * Bulk create negative keywords for a campaign
+     */
+    async bulkCreateNegativeKeywords(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/bulk_create_negative_keywords`, body);
+    }
+    /**
+     * Bulk delete negative keywords for a campaign
+     */
+    async bulkDeleteNegativeKeywords(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/bulk_delete_negative_keywords`, body);
+    }
+    /**
+     * Bulk update negative keywords for a campaign
+     */
+    async bulkUpdateNegativeKeywords(campaignId, body) {
+        return await this.client.post(`${this.basePath}/ad_campaign/${campaignId}/bulk_update_negative_keywords`, body);
+    }
+    /**
+     * Get a negative keyword for a campaign
+     */
+    async getNegativeKeyword(campaignId, negativeKeywordId) {
+        return await this.client.get(`${this.basePath}/ad_campaign/${campaignId}/negative_keyword/${negativeKeywordId}`);
+    }
+    /**
+     * Delete a negative keyword for a campaign
+     */
+    async deleteNegativeKeyword(campaignId, negativeKeywordId) {
+        return await this.client.delete(`${this.basePath}/ad_campaign/${campaignId}/negative_keyword/${negativeKeywordId}`);
+    }
+    /**
+     * Update a negative keyword for a campaign
+     */
+    async updateNegativeKeyword(campaignId, negativeKeywordId, body) {
+        return await this.client.put(`${this.basePath}/ad_campaign/${campaignId}/negative_keyword/${negativeKeywordId}`, body);
+    }
+    /**
+     * Get negative keywords for an ad group
+     */
+    async getNegativeKeywordsForAdGroup(adGroupId, limit, offset) {
+        const params = {};
+        if (limit)
+            params.limit = limit;
+        if (offset)
+            params.offset = offset;
+        return await this.client.get(`${this.basePath}/ad_group/${adGroupId}/negative_keyword`, params);
+    }
+    /**
+     * Create a negative keyword for an ad group
+     */
+    async createNegativeKeywordForAdGroup(adGroupId, body) {
+        return await this.client.post(`${this.basePath}/ad_group/${adGroupId}/negative_keyword`, body);
+    }
+    /**
+     * Bulk create negative keywords for an ad group
+     */
+    async bulkCreateNegativeKeywordsForAdGroup(adGroupId, body) {
+        return await this.client.post(`${this.basePath}/ad_group/${adGroupId}/bulk_create_negative_keywords`, body);
+    }
+    /**
+     * Bulk delete negative keywords for an ad group
+     */
+    async bulkDeleteNegativeKeywordsForAdGroup(adGroupId, body) {
+        return await this.client.post(`${this.basePath}/ad_group/${adGroupId}/bulk_delete_negative_keywords`, body);
+    }
+    /**
+     * Bulk update negative keywords for an ad group
+     */
+    async bulkUpdateNegativeKeywordsForAdGroup(adGroupId, body) {
+        return await this.client.post(`${this.basePath}/ad_group/${adGroupId}/bulk_update_negative_keywords`, body);
+    }
+    /**
+     * Get a negative keyword for an ad group
+     */
+    async getNegativeKeywordForAdGroup(adGroupId, negativeKeywordId) {
+        return await this.client.get(`${this.basePath}/ad_group/${adGroupId}/negative_keyword/${negativeKeywordId}`);
+    }
+    /**
+     * Delete a negative keyword for an ad group
+     */
+    async deleteNegativeKeywordForAdGroup(adGroupId, negativeKeywordId) {
+        return await this.client.delete(`${this.basePath}/ad_group/${adGroupId}/negative_keyword/${negativeKeywordId}`);
+    }
+    /**
+     * Update a negative keyword for an ad group
+     */
+    async updateNegativeKeywordForAdGroup(adGroupId, negativeKeywordId, body) {
+        return await this.client.put(`${this.basePath}/ad_group/${adGroupId}/negative_keyword/${negativeKeywordId}`, body);
+    }
+}

package/build/api/marketing-and-promotions/recommendation.d.ts

@@ -0,0 +1,20 @@
+import type { EbayApiClient } from '../../api/client.js';
+import type { components } from '../../types/sell-apps/markeitng-and-promotions/sellRecommendationV1Oas3.js';
+type PagedListingRecommendationCollection = components['schemas']['PagedListingRecommendationCollection'];
+/**
+ * Recommendation API - Listing recommendations
+ * Based on: docs/sell-apps/marketing-and-promotions/sell_recommendation_v1_oas3.json
+ */
+export declare class RecommendationApi {
+    private client;
+    private readonly basePath;
+    constructor(client: EbayApiClient);
+    /**
+     * Find listing recommendations
+     * Endpoint: POST /find
+     */
+    findListingRecommendations(requestBody?: {
+        listingIds?: string[];
+    }, filter?: string, limit?: number, offset?: number, marketplaceId?: string): Promise<PagedListingRecommendationCollection>;
+}
+export {};

package/build/api/marketing-and-promotions/recommendation.js

@@ -0,0 +1,32 @@
+/**
+ * Recommendation API - Listing recommendations
+ * Based on: docs/sell-apps/marketing-and-promotions/sell_recommendation_v1_oas3.json
+ */
+export class RecommendationApi {
+    client;
+    basePath = '/sell/recommendation/v1';
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Find listing recommendations
+     * Endpoint: POST /find
+     */
+    async findListingRecommendations(requestBody, filter, limit, offset, marketplaceId) {
+        const params = {};
+        if (filter)
+            params.filter = filter;
+        if (limit)
+            params.limit = limit;
+        if (offset)
+            params.offset = offset;
+        const headers = {};
+        if (marketplaceId) {
+            headers['X-EBAY-C-MARKETPLACE-ID'] = marketplaceId;
+        }
+        return await this.client.post(`${this.basePath}/find`, requestBody || {}, {
+            params,
+            headers,
+        });
+    }
+}

package/build/api/order-management/dispute.d.ts

@@ -0,0 +1,65 @@
+import type { EbayApiClient } from '../../api/client.js';
+import type { components } from '../../types/sell-apps/order-management/sellFulfillmentV1Oas3.js';
+type AcceptPaymentDisputeRequest = components['schemas']['AcceptPaymentDisputeRequest'];
+type ContestPaymentDisputeRequest = components['schemas']['ContestPaymentDisputeRequest'];
+type DisputeSummaryResponse = components['schemas']['DisputeSummaryResponse'];
+type PaymentDispute = components['schemas']['PaymentDispute'];
+type PaymentDisputeActivityHistory = components['schemas']['PaymentDisputeActivityHistory'];
+type FileEvidence = components['schemas']['FileEvidence'];
+type AddEvidencePaymentDisputeRequest = components['schemas']['AddEvidencePaymentDisputeRequest'];
+type AddEvidencePaymentDisputeResponse = components['schemas']['AddEvidencePaymentDisputeResponse'];
+type UpdateEvidencePaymentDisputeRequest = components['schemas']['UpdateEvidencePaymentDisputeRequest'];
+/**
+ * Dispute API - Manage payment disputes
+ * Based on: docs/sell-apps/order-management/sell_fulfillment_v1_oas3.json
+ */
+export declare class DisputeApi {
+    private client;
+    private readonly basePath;
+    constructor(client: EbayApiClient);
+    /**
+     * Get payment dispute details
+     */
+    getPaymentDispute(paymentDisputeId: string): Promise<PaymentDispute>;
+    /**
+     * Get payment dispute evidence file
+     */
+    fetchEvidenceContent(paymentDisputeId: string, evidenceId: string, fileId: string): Promise<ArrayBuffer>;
+    /**
+     * Get payment dispute activity
+     */
+    getActivities(paymentDisputeId: string): Promise<PaymentDisputeActivityHistory>;
+    /**
+     * Search for payment disputes
+     */
+    getPaymentDisputeSummaries(params?: {
+        order_id?: string;
+        buyer_username?: string;
+        open_date_from?: string;
+        open_date_to?: string;
+        payment_dispute_status?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<DisputeSummaryResponse>;
+    /**
+     * Contest a payment dispute
+     */
+    contestPaymentDispute(paymentDisputeId: string, body?: ContestPaymentDisputeRequest): Promise<void>;
+    /**
+     * Accept a payment dispute
+     */
+    acceptPaymentDispute(paymentDisputeId: string, body?: AcceptPaymentDisputeRequest): Promise<void>;
+    /**
+     * Upload an evidence file
+     */
+    uploadEvidenceFile(paymentDisputeId: string, body: ArrayBuffer): Promise<FileEvidence>;
+    /**
+     * Add an evidence file
+     */
+    addEvidence(paymentDisputeId: string, body: AddEvidencePaymentDisputeRequest): Promise<AddEvidencePaymentDisputeResponse>;
+    /**
+     * Update an evidence file
+     */
+    updateEvidence(paymentDisputeId: string, body: UpdateEvidencePaymentDisputeRequest): Promise<void>;
+}
+export {};