@lehaotech/walmart-mcp 0.5.4

package/build/api/advertising/ad-client.js

@@ -0,0 +1,174 @@
+import axios from 'axios';
+import { createSign, randomUUID } from 'crypto';
+import { getAdBaseUrl } from '../../config/environment.js';
+import { apiLogger, truncateData } from '../../utils/logger.js';
+import { RateLimiter } from '../../utils/rate-limiter.js';
+import { WalmartApiError, formatWalmartError } from '../../utils/api-error.js';
+export class WalmartAdClient {
+    config;
+    http;
+    accessToken = null;
+    tokenExpiry = 0;
+    rateLimiter;
+    constructor(config) {
+        this.config = config;
+        // Advertising API: ~10 req/s, use 500 req/60s as safe window
+        this.rateLimiter = new RateLimiter(500, 60_000, 'advertising');
+        this.http = axios.create({
+            baseURL: getAdBaseUrl(config.environment),
+            timeout: 30_000,
+            headers: {
+                'Content-Type': 'application/json',
+                'Accept': 'application/json',
+            },
+        });
+        this.setupInterceptors();
+    }
+    /**
+     * Serialize request params into a query string deterministically (insertion
+     * order, scalars and arrays). Used to embed params into the request URL so
+     * the signed URL is byte-for-byte identical to what is actually sent —
+     * Walmart Connect validates the signature against the full request URL,
+     * including the query string.
+     */
+    serializeParams(params) {
+        const parts = [];
+        for (const [key, value] of Object.entries(params)) {
+            if (value === undefined || value === null)
+                continue;
+            const values = Array.isArray(value) ? value : [value];
+            for (const v of values) {
+                parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(v))}`);
+            }
+        }
+        return parts.join('&');
+    }
+    generateSignature(url, method, timestamp) {
+        if (!this.config.adPrivateKey) {
+            throw new Error('WALMART_AD_PRIVATE_KEY is required for advertising API');
+        }
+        const stringToSign = `${this.config.adConsumerId}\n${url}\n${method.toUpperCase()}\n${timestamp}\n`;
+        const sign = createSign('RSA-SHA256');
+        sign.update(stringToSign);
+        return sign.sign(this.config.adPrivateKey, 'base64');
+    }
+    async getAccessToken() {
+        if (this.accessToken && Date.now() < this.tokenExpiry) {
+            return this.accessToken;
+        }
+        const tokenUrl = `${getAdBaseUrl(this.config.environment)}/v1/oauth/token`;
+        const timestamp = Date.now().toString();
+        const signature = this.generateSignature(tokenUrl, 'POST', timestamp);
+        const response = await axios.post(tokenUrl, null, {
+            headers: {
+                'WM_CONSUMER.ID': this.config.adConsumerId,
+                'WM_SEC.AUTH_SIGNATURE': signature,
+                'WM_CONSUMER.INTIMESTAMP': timestamp,
+                'WM_SEC.KEY_VERSION': this.config.adKeyVersion || '1',
+                'Content-Type': 'application/x-www-form-urlencoded',
+            },
+            params: {
+                grant_type: 'client_credentials',
+            },
+        });
+        this.accessToken = response.data.access_token;
+        this.tokenExpiry = Date.now() + (response.data.expires_in || 900) * 1000 - 120_000;
+        apiLogger.info('Advertising token refreshed');
+        return this.accessToken;
+    }
+    setupInterceptors() {
+        this.http.interceptors.request.use(async (reqConfig) => {
+            if (!this.config.adConsumerId || !this.config.adPrivateKey) {
+                throw new Error('Walmart Connect credentials not configured. Set WALMART_AD_CONSUMER_ID and WALMART_AD_PRIVATE_KEY.');
+            }
+            // Pre-flight rate limit check
+            await this.rateLimiter.acquireAsync();
+            const token = await this.getAccessToken();
+            const timestamp = Date.now().toString();
+            // Embed any query params into the URL itself, then clear reqConfig.params
+            // so axios does not re-append them. This guarantees the URL we sign is
+            // identical to the URL actually sent (signature covers the query string).
+            let url = reqConfig.url || '';
+            if (reqConfig.params && typeof reqConfig.params === 'object') {
+                const qs = this.serializeParams(reqConfig.params);
+                if (qs) {
+                    url += (url.includes('?') ? '&' : '?') + qs;
+                    reqConfig.url = url;
+                    reqConfig.params = undefined;
+                }
+            }
+            const fullUrl = `${reqConfig.baseURL || ''}${url}`;
+            const signature = this.generateSignature(fullUrl, reqConfig.method?.toUpperCase() || 'GET', timestamp);
+            reqConfig.headers['Authorization'] = `Bearer ${token}`;
+            reqConfig.headers['WM_CONSUMER.ID'] = this.config.adConsumerId;
+            reqConfig.headers['WM_SEC.AUTH_SIGNATURE'] = signature;
+            reqConfig.headers['WM_CONSUMER.INTIMESTAMP'] = timestamp;
+            reqConfig.headers['WM_QOS.CORRELATION_ID'] = randomUUID();
+            reqConfig.headers['WM_SEC.KEY_VERSION'] = this.config.adKeyVersion || '1';
+            apiLogger.http(`→ AD ${reqConfig.method?.toUpperCase()} ${reqConfig.url}`, {
+                params: reqConfig.params,
+            });
+            return reqConfig;
+        }, (error) => {
+            apiLogger.error('Ad request interceptor error', { error: String(error) });
+            return Promise.reject(error);
+        });
+        this.http.interceptors.response.use((response) => {
+            apiLogger.http(`← AD ${response.status} ${response.statusText}`);
+            return response;
+        }, async (error) => {
+            if (!axios.isAxiosError(error) || !error.response || !error.config) {
+                throw error;
+            }
+            const status = error.response.status;
+            const config = error.config;
+            if (status === 401 && !config.__authRetried) {
+                config.__authRetried = true;
+                apiLogger.warn('AD 401 - refreshing token');
+                this.accessToken = null;
+                this.tokenExpiry = 0;
+                return this.http.request(config);
+            }
+            if (status === 429) {
+                const retryAfter = error.response.headers['retry-after'] || '60';
+                throw new Error(`Advertising rate limit exceeded. Retry after ${retryAfter}s.`);
+            }
+            if (status >= 500) {
+                const retryCount = config.__retryCount || 0;
+                if (retryCount < 3) {
+                    config.__retryCount = retryCount + 1;
+                    const delay = Math.pow(2, retryCount) * 1000;
+                    apiLogger.warn(`AD ${status} - retry ${retryCount + 1}/3 in ${delay}ms`);
+                    await new Promise((r) => setTimeout(r, delay));
+                    return this.http.request(config);
+                }
+            }
+            const data = error.response.data;
+            const errorMsg = data?.message
+                ? `HTTP ${status}: ${data.message}`
+                : formatWalmartError(status, error.response.statusText, data);
+            apiLogger.error(`AD API Error: ${errorMsg}`, {
+                url: config.url,
+                status,
+                response: truncateData(data),
+            });
+            throw new WalmartApiError(errorMsg, status, data);
+        });
+    }
+    async get(endpoint, params) {
+        const response = await this.http.get(endpoint, { params });
+        return response.data;
+    }
+    async post(endpoint, data) {
+        const response = await this.http.post(endpoint, data);
+        return response.data;
+    }
+    async put(endpoint, data) {
+        const response = await this.http.put(endpoint, data);
+        return response.data;
+    }
+    async delete(endpoint, params) {
+        const response = await this.http.delete(endpoint, { params });
+        return response.data;
+    }
+}

package/build/api/advertising/advertising-api.d.ts

@@ -0,0 +1,50 @@
+import { WalmartAdClient } from './ad-client.js';
+export declare class AdvertisingApi {
+    private client;
+    constructor(client: WalmartAdClient);
+    getCampaigns(params?: {
+        campaignId?: number;
+        status?: string;
+        name?: string;
+    }): Promise<unknown>;
+    createCampaign(data: object): Promise<unknown>;
+    updateCampaign(data: object): Promise<unknown>;
+    deleteCampaign(data: object): Promise<unknown>;
+    getAdGroups(params?: {
+        campaignId?: number;
+        adGroupId?: number;
+    }): Promise<unknown>;
+    createAdGroups(data: object): Promise<unknown>;
+    updateAdGroups(data: object): Promise<unknown>;
+    getAdItems(params?: {
+        campaignId?: number;
+        adGroupId?: number;
+        status?: string;
+    }): Promise<unknown>;
+    addAdItems(data: object): Promise<unknown>;
+    updateAdItems(data: object): Promise<unknown>;
+    getKeywords(params?: {
+        campaignId?: number;
+        adGroupId?: number;
+        keywordId?: number;
+    }): Promise<unknown>;
+    addKeywords(data: object): Promise<unknown>;
+    updateKeywords(data: object): Promise<unknown>;
+    getKeywordAnalytics(data: object): Promise<unknown>;
+    createPlacementBids(data: object): Promise<unknown>;
+    getPlacementBids(params?: {
+        campaignId?: number;
+    }): Promise<unknown>;
+    createPlatformBids(data: object): Promise<unknown>;
+    createReportSnapshot(data: object): Promise<unknown>;
+    getReportSnapshots(params?: {
+        snapshotId?: string;
+        reportType?: string;
+    }): Promise<unknown>;
+    getRealtimeStats(data: object): Promise<unknown>;
+    getLatestReportDate(): Promise<unknown>;
+    getItemRecommendations(data: object): Promise<unknown>;
+    getKeywordRecommendations(data: object): Promise<unknown>;
+    getSearchTrends(data: object): Promise<unknown>;
+    getSbaProfile(): Promise<unknown>;
+}

package/build/api/advertising/advertising-api.js

@@ -0,0 +1,89 @@
+export class AdvertisingApi {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    // ===== Campaigns =====
+    async getCampaigns(params) {
+        return await this.client.get('/v1/campaigns', params);
+    }
+    async createCampaign(data) {
+        return await this.client.post('/v1/campaigns', data);
+    }
+    async updateCampaign(data) {
+        return await this.client.put('/v1/campaigns', data);
+    }
+    async deleteCampaign(data) {
+        return await this.client.put('/v1/campaigns/delete', data);
+    }
+    // ===== Ad Groups =====
+    async getAdGroups(params) {
+        return await this.client.get('/v1/adGroups', params);
+    }
+    async createAdGroups(data) {
+        return await this.client.post('/v1/adGroups', data);
+    }
+    async updateAdGroups(data) {
+        return await this.client.put('/v1/adGroups', data);
+    }
+    // ===== Ad Items =====
+    async getAdItems(params) {
+        return await this.client.get('/v1/adItems', params);
+    }
+    async addAdItems(data) {
+        return await this.client.post('/v1/adItems', data);
+    }
+    async updateAdItems(data) {
+        return await this.client.put('/v1/adItems', data);
+    }
+    // ===== Keywords =====
+    async getKeywords(params) {
+        return await this.client.get('/v1/keywords', params);
+    }
+    async addKeywords(data) {
+        return await this.client.post('/v1/keywords', data);
+    }
+    async updateKeywords(data) {
+        return await this.client.put('/v1/keywords', data);
+    }
+    async getKeywordAnalytics(data) {
+        return await this.client.post('/v1/keywords/analytics', data);
+    }
+    // ===== Bid Multipliers =====
+    async createPlacementBids(data) {
+        return await this.client.post('/v1/bid-multipliers/placement', data);
+    }
+    async getPlacementBids(params) {
+        return await this.client.get('/v1/bid-multipliers/placement', params);
+    }
+    async createPlatformBids(data) {
+        return await this.client.post('/v1/bid-multipliers/platform', data);
+    }
+    // ===== Reports & Stats =====
+    async createReportSnapshot(data) {
+        return await this.client.post('/v2/snapshots/reports', data);
+    }
+    async getReportSnapshots(params) {
+        return await this.client.get('/v2/snapshots/reports', params);
+    }
+    async getRealtimeStats(data) {
+        return await this.client.post('/v1/stats', data);
+    }
+    async getLatestReportDate() {
+        return await this.client.get('/v1/latest-report-date');
+    }
+    // ===== Recommendations & Insights =====
+    async getItemRecommendations(data) {
+        return await this.client.post('/v1/recommendations/items', data);
+    }
+    async getKeywordRecommendations(data) {
+        return await this.client.post('/v1/recommendations/keywords', data);
+    }
+    async getSearchTrends(data) {
+        return await this.client.post('/v1/insights/top-search-trends', data);
+    }
+    // ===== Sponsored Brands =====
+    async getSbaProfile() {
+        return await this.client.get('/v2/sba_profile');
+    }
+}

package/build/api/client.d.ts

@@ -0,0 +1,19 @@
+import { type WalmartConfig } from '../config/environment.js';
+import { WalmartOAuthClient } from '../auth/oauth.js';
+import { RateLimiter } from '../utils/rate-limiter.js';
+export declare class WalmartApiClient {
+    private config;
+    private http;
+    private authClient;
+    private rateLimiter;
+    constructor(config: WalmartConfig);
+    initialize(): Promise<void>;
+    getAuthClient(): WalmartOAuthClient;
+    /** Expose the rate limiter so the rate-budget MCP tool can snapshot it. */
+    getRateLimiter(): RateLimiter;
+    private setupInterceptors;
+    get<T = unknown>(endpoint: string, params?: object): Promise<T>;
+    post<T = unknown>(endpoint: string, data?: object, config?: object): Promise<T>;
+    put<T = unknown>(endpoint: string, data?: object): Promise<T>;
+    delete<T = unknown>(endpoint: string, params?: object): Promise<T>;
+}

package/build/api/client.js

@@ -0,0 +1,150 @@
+import axios from 'axios';
+import { randomUUID } from 'crypto';
+import { getBaseUrl } from '../config/environment.js';
+import { WalmartOAuthClient } from '../auth/oauth.js';
+import { apiLogger, truncateData } from '../utils/logger.js';
+import { RateLimiter } from '../utils/rate-limiter.js';
+import { WalmartApiError, formatWalmartError } from '../utils/api-error.js';
+import { findKnownIssueHint } from '../utils/known-issues.js';
+export class WalmartApiClient {
+    config;
+    http;
+    authClient;
+    rateLimiter;
+    constructor(config) {
+        this.config = config;
+        this.authClient = new WalmartOAuthClient(config);
+        // Walmart token bucket: ~20 req/s, use 1000 req/60s as safe sliding window
+        this.rateLimiter = new RateLimiter(1000, 60_000, 'marketplace');
+        this.http = axios.create({
+            baseURL: getBaseUrl(config.environment),
+            timeout: 30_000,
+            headers: {
+                'Content-Type': 'application/json',
+                'Accept': 'application/json',
+            },
+        });
+        this.setupInterceptors();
+    }
+    async initialize() {
+        await this.authClient.initialize();
+    }
+    getAuthClient() {
+        return this.authClient;
+    }
+    /** Expose the rate limiter so the rate-budget MCP tool can snapshot it. */
+    getRateLimiter() {
+        return this.rateLimiter;
+    }
+    setupInterceptors() {
+        // ===== Request Interceptor =====
+        this.http.interceptors.request.use(async (reqConfig) => {
+            // 0. Pre-flight rate limit check
+            await this.rateLimiter.acquireAsync();
+            // 1. Inject access token
+            const token = await this.authClient.getAccessToken();
+            reqConfig.headers['WM_SEC.ACCESS_TOKEN'] = token;
+            // 2. Inject required Walmart headers
+            reqConfig.headers['WM_QOS.CORRELATION_ID'] = randomUUID();
+            reqConfig.headers['WM_SVC.NAME'] = this.config.svcName;
+            // 3. Optional headers
+            if (this.config.consumerChannelType) {
+                reqConfig.headers['WM_CONSUMER.CHANNEL.TYPE'] = this.config.consumerChannelType;
+            }
+            if (this.config.market !== 'us') {
+                reqConfig.headers['WM_MARKET'] = this.config.market;
+            }
+            apiLogger.http(`→ ${reqConfig.method?.toUpperCase()} ${reqConfig.url}`, {
+                params: reqConfig.params,
+            });
+            return reqConfig;
+        }, (error) => {
+            apiLogger.error('Request interceptor error', { error: String(error) });
+            return Promise.reject(error);
+        });
+        // ===== Response Interceptor =====
+        this.http.interceptors.response.use((response) => {
+            const tokenCount = response.headers['x-current-token-count'];
+            const replenish = response.headers['x-next-replenish-time'];
+            // Update rate limiter from server headers
+            this.rateLimiter.updateFromHeaders(response.headers);
+            apiLogger.http(`← ${response.status} ${response.statusText}`, tokenCount ? { rateTokens: tokenCount, replenish } : undefined);
+            return response;
+        }, async (error) => {
+            if (!axios.isAxiosError(error) || !error.response || !error.config) {
+                throw error;
+            }
+            const status = error.response.status;
+            const config = error.config;
+            // 401: Refresh token + retry once
+            if (status === 401 && !config.__authRetried) {
+                config.__authRetried = true;
+                apiLogger.warn('401 Unauthorized - refreshing token');
+                await this.authClient.refreshToken();
+                const newToken = await this.authClient.getAccessToken();
+                config.headers['WM_SEC.ACCESS_TOKEN'] = newToken;
+                return this.http.request(config);
+            }
+            // 429: Rate limit exceeded
+            if (status === 429) {
+                const retryAfter = error.response.headers['retry-after'] || '60';
+                apiLogger.warn(`429 Rate limit - retry after ${retryAfter}s`);
+                throw new Error(`Rate limit exceeded. Retry after ${retryAfter} seconds. ` +
+                    `Remaining tokens: ${error.response.headers['x-current-token-count'] || 'unknown'}`);
+            }
+            // 423: Resource locked - retry once after 60s
+            if (status === 423 && !config.__lockRetried) {
+                config.__lockRetried = true;
+                apiLogger.warn('423 Resource locked - retrying in 60s');
+                await new Promise((r) => setTimeout(r, 60_000));
+                return this.http.request(config);
+            }
+            // 5xx: Exponential backoff retry (max 3)
+            if (status >= 500) {
+                const retryCount = config.__retryCount || 0;
+                if (retryCount < 3) {
+                    config.__retryCount = retryCount + 1;
+                    const delay = Math.pow(2, retryCount) * 1000;
+                    apiLogger.warn(`${status} Server error - retry ${retryCount + 1}/3 in ${delay}ms`);
+                    await new Promise((r) => setTimeout(r, delay));
+                    return this.http.request(config);
+                }
+            }
+            // Parse Walmart error response, preserving the full body detail.
+            const errorMsg = formatWalmartError(status, error.response.statusText, error.response.data);
+            // Build endpoint label for error context: "GET /v3/items?limit=5".
+            const method = (config.method ?? 'GET').toUpperCase();
+            const path = config.url ?? '';
+            const endpoint = `${method} ${path}`;
+            // Look up workaround hint for known-broken Walmart endpoints. Strip
+            // the query string so URL parameters do not interfere with the regex
+            // match.
+            const pathForLookup = path.split('?')[0] ?? path;
+            const hint = findKnownIssueHint(method, pathForLookup);
+            apiLogger.error(`API Error: ${errorMsg}`, {
+                url: config.url,
+                status,
+                response: truncateData(error.response.data),
+                ...(hint ? { hint } : {}),
+            });
+            throw new WalmartApiError(errorMsg, status, error.response.data, endpoint, undefined, hint);
+        });
+    }
+    // ===== HTTP Methods =====
+    async get(endpoint, params) {
+        const response = await this.http.get(endpoint, { params });
+        return response.data;
+    }
+    async post(endpoint, data, config) {
+        const response = await this.http.post(endpoint, data, config);
+        return response.data;
+    }
+    async put(endpoint, data) {
+        const response = await this.http.put(endpoint, data);
+        return response.data;
+    }
+    async delete(endpoint, params) {
+        const response = await this.http.delete(endpoint, { params });
+        return response.data;
+    }
+}

package/build/api/feeds/feeds-api.d.ts

@@ -0,0 +1,15 @@
+import { WalmartApiClient } from '../client.js';
+export declare class FeedsApi {
+    private client;
+    private basePath;
+    constructor(client: WalmartApiClient);
+    getAllFeedStatuses(params?: {
+        limit?: number;
+        offset?: number;
+        feedType?: string;
+    }): Promise<unknown>;
+    getFeedStatus(feedId: string, includeDetails?: boolean): Promise<unknown>;
+    getFeedItemStatus(feedId: string): Promise<unknown>;
+    submitFeed(feedType: string, data: object): Promise<unknown>;
+    pollFeedUntilComplete(feedId: string, maxWaitMs?: number, initialDelayMs?: number): Promise<unknown>;
+}

package/build/api/feeds/feeds-api.js

@@ -0,0 +1,53 @@
+import { feedLogger } from '../../utils/logger.js';
+export class FeedsApi {
+    client;
+    basePath = '/v3/feeds';
+    constructor(client) {
+        this.client = client;
+    }
+    async getAllFeedStatuses(params) {
+        return await this.client.get(this.basePath, params);
+    }
+    async getFeedStatus(feedId, includeDetails = false) {
+        if (!feedId)
+            throw new Error('feedId is required');
+        const params = includeDetails ? { includeDetails: 'true' } : undefined;
+        return await this.client.get(`${this.basePath}/${encodeURIComponent(feedId)}`, params);
+    }
+    async getFeedItemStatus(feedId) {
+        if (!feedId)
+            throw new Error('feedId is required');
+        return await this.client.get(`${this.basePath}/${encodeURIComponent(feedId)}`, {
+            includeDetails: 'true',
+        });
+    }
+    async submitFeed(feedType, data) {
+        if (!feedType)
+            throw new Error('feedType is required');
+        return await this.client.post(`${this.basePath}?feedType=${encodeURIComponent(feedType)}`, data, { headers: { 'Content-Type': 'application/json' } });
+    }
+    async pollFeedUntilComplete(feedId, maxWaitMs = 7_200_000, initialDelayMs = 15_000) {
+        if (!feedId)
+            throw new Error('feedId is required');
+        const intervals = [15_000, 30_000, 60_000, 120_000, 240_000];
+        const startTime = Date.now();
+        let attempt = 0;
+        feedLogger.info(`Polling feed ${feedId} until complete (max ${maxWaitMs / 1000}s)`);
+        while (Date.now() - startTime < maxWaitMs) {
+            const delay = attempt < intervals.length ? intervals[attempt] : 240_000;
+            if (attempt === 0 && initialDelayMs > 0) {
+                await new Promise((r) => setTimeout(r, initialDelayMs));
+            }
+            else {
+                await new Promise((r) => setTimeout(r, delay));
+            }
+            const result = await this.getFeedStatus(feedId, true);
+            feedLogger.info(`Feed ${feedId} status: ${result.feedStatus} (attempt ${attempt + 1})`);
+            if (result.feedStatus === 'PROCESSED' || result.feedStatus === 'ERROR') {
+                return result;
+            }
+            attempt++;
+        }
+        throw new Error(`Feed ${feedId} did not complete within ${maxWaitMs / 1000} seconds`);
+    }
+}

package/build/api/fulfillment/fulfillment-api.d.ts

@@ -0,0 +1,37 @@
+import { WalmartApiClient } from '../client.js';
+export declare class FulfillmentApi {
+    private client;
+    constructor(client: WalmartApiClient);
+    createInboundOrder(data: object): Promise<unknown>;
+    getInboundShipments(params?: {
+        limit?: number;
+        offset?: number;
+        status?: string;
+    }): Promise<unknown>;
+    getInboundErrors(params?: {
+        inboundOrderId?: string;
+        shipmentId?: string;
+    }): Promise<unknown>;
+    getShipmentItems(params?: {
+        shipmentId?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<unknown>;
+    getShipmentQuantities(params?: {
+        shipmentId?: string;
+    }): Promise<unknown>;
+    getShipmentLabel(shipmentId: string): Promise<unknown>;
+    updateShipmentTracking(data: object): Promise<unknown>;
+    cancelInboundOrder(inboundOrderId: string): Promise<unknown>;
+    getShippingLabel(purchaseOrderId: string): Promise<unknown>;
+    getLabelByTracking(carrierId: string, trackingNo: string): Promise<unknown>;
+    discardLabel(data: object): Promise<unknown>;
+    getPackageTypes(carrierId: string): Promise<unknown>;
+    createMcsOrder(data: object): Promise<unknown>;
+    cancelMcsOrder(data: object): Promise<unknown>;
+    getMcsOrderStatus(orderId: string): Promise<unknown>;
+    getCarrierRateQuotes(data: object): Promise<unknown>;
+    bookCarrierShipment(data: object): Promise<unknown>;
+    getCarrierLabel(shipmentId: string): Promise<unknown>;
+    scheduleCarrierPickup(data: object): Promise<unknown>;
+}

package/build/api/fulfillment/fulfillment-api.js

@@ -0,0 +1,81 @@
+export class FulfillmentApi {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    // ===== WFS Inbound =====
+    async createInboundOrder(data) {
+        return await this.client.post('/v3/inbound-shipments', data);
+    }
+    async getInboundShipments(params) {
+        return await this.client.get('/v3/inbound-shipments', params);
+    }
+    async getInboundErrors(params) {
+        return await this.client.get('/v3/inbound-shipment-errors', params);
+    }
+    async getShipmentItems(params) {
+        return await this.client.get('/v3/shipment-items', params);
+    }
+    async getShipmentQuantities(params) {
+        return await this.client.get('/v3/shipment-quantities', params);
+    }
+    async getShipmentLabel(shipmentId) {
+        if (!shipmentId)
+            throw new Error('shipmentId is required');
+        return await this.client.get(`/v3/fulfillment/label/${encodeURIComponent(shipmentId)}`);
+    }
+    async updateShipmentTracking(data) {
+        return await this.client.post('/v3/shipment-tracking', data);
+    }
+    async cancelInboundOrder(inboundOrderId) {
+        if (!inboundOrderId)
+            throw new Error('inboundOrderId is required');
+        return await this.client.delete(`/v3/inbound-shipments/${encodeURIComponent(inboundOrderId)}`);
+    }
+    // ===== Shipping Labels =====
+    async getShippingLabel(purchaseOrderId) {
+        if (!purchaseOrderId)
+            throw new Error('purchaseOrderId is required');
+        return await this.client.get(`/v3/shipping/labels/${encodeURIComponent(purchaseOrderId)}`);
+    }
+    async getLabelByTracking(carrierId, trackingNo) {
+        if (!carrierId || !trackingNo)
+            throw new Error('carrierId and trackingNo are required');
+        return await this.client.get(`/v3/shipping/labels/carriers/${encodeURIComponent(carrierId)}/trackings/${encodeURIComponent(trackingNo)}`);
+    }
+    async discardLabel(data) {
+        return await this.client.post('/v3/shipping/labels/discard', data);
+    }
+    async getPackageTypes(carrierId) {
+        if (!carrierId)
+            throw new Error('carrierId is required');
+        return await this.client.get(`/v3/shipping/carriers/${encodeURIComponent(carrierId)}/packagetypes`);
+    }
+    // ===== Multichannel Solutions =====
+    async createMcsOrder(data) {
+        return await this.client.post('/v3/mcs/orders', data);
+    }
+    async cancelMcsOrder(data) {
+        return await this.client.post('/v3/mcs/orders/cancel', data);
+    }
+    async getMcsOrderStatus(orderId) {
+        if (!orderId)
+            throw new Error('orderId is required');
+        return await this.client.get(`/v3/mcs/orders/${encodeURIComponent(orderId)}`);
+    }
+    // ===== WFS Carrier =====
+    async getCarrierRateQuotes(data) {
+        return await this.client.post('/v3/wfs/carriers/quotes', data);
+    }
+    async bookCarrierShipment(data) {
+        return await this.client.post('/v3/wfs/carriers/book', data);
+    }
+    async getCarrierLabel(shipmentId) {
+        if (!shipmentId)
+            throw new Error('shipmentId is required');
+        return await this.client.get(`/v3/wfs/carriers/labels/${encodeURIComponent(shipmentId)}`);
+    }
+    async scheduleCarrierPickup(data) {
+        return await this.client.post('/v3/wfs/carriers/pickup', data);
+    }
+}