@lehaotech/walmart-mcp 0.5.4

package/build/api/index.d.ts

@@ -0,0 +1,44 @@
+import { type WalmartConfig } from '../config/environment.js';
+import { WalmartApiClient } from './client.js';
+import { WalmartOAuthClient } from '../auth/oauth.js';
+import { ItemsApi } from './items/items-api.js';
+import { InventoryApi } from './inventory/inventory-api.js';
+import { OrdersApi } from './orders/orders-api.js';
+import { PricingApi } from './pricing/pricing-api.js';
+import { FeedsApi } from './feeds/feeds-api.js';
+import { FulfillmentApi } from './fulfillment/fulfillment-api.js';
+import { ReturnsApi } from './returns/returns-api.js';
+import { ReportsApi } from './reports/reports-api.js';
+import { NotificationsApi } from './notifications/notifications-api.js';
+import { AdvertisingApi } from './advertising/advertising-api.js';
+import { SettingsApi } from './settings/settings-api.js';
+export declare class WalmartSellerApi {
+    private client;
+    auth: WalmartOAuthClient;
+    items: ItemsApi;
+    inventory: InventoryApi;
+    orders: OrdersApi;
+    pricing: PricingApi;
+    feeds: FeedsApi;
+    fulfillment: FulfillmentApi;
+    returns: ReturnsApi;
+    reports: ReportsApi;
+    notifications: NotificationsApi;
+    advertising: AdvertisingApi;
+    settings: SettingsApi;
+    constructor(config: WalmartConfig);
+    initialize(): Promise<void>;
+    /** Snapshot the rate limiter state for the walmart_get_rate_budget tool. */
+    getRateLimiterStatus(): {
+        name: string;
+        localMaxRequests: number;
+        localWindowMs: number;
+        localCurrentCount: number;
+        localRemaining: number;
+        serverTokensRemaining: number | null;
+        serverReplenishTime: string | null;
+        serverTokensSeenAt: string | null;
+    };
+    /** Expose the marketplace client for the walmart_call_endpoint discovery tool. */
+    getMarketplaceClient(): WalmartApiClient;
+}

package/build/api/index.js

@@ -0,0 +1,56 @@
+import { WalmartApiClient } from './client.js';
+import { ItemsApi } from './items/items-api.js';
+import { InventoryApi } from './inventory/inventory-api.js';
+import { OrdersApi } from './orders/orders-api.js';
+import { PricingApi } from './pricing/pricing-api.js';
+import { FeedsApi } from './feeds/feeds-api.js';
+import { FulfillmentApi } from './fulfillment/fulfillment-api.js';
+import { ReturnsApi } from './returns/returns-api.js';
+import { ReportsApi } from './reports/reports-api.js';
+import { NotificationsApi } from './notifications/notifications-api.js';
+import { WalmartAdClient } from './advertising/ad-client.js';
+import { AdvertisingApi } from './advertising/advertising-api.js';
+import { SettingsApi } from './settings/settings-api.js';
+export class WalmartSellerApi {
+    client;
+    auth;
+    items;
+    inventory;
+    orders;
+    pricing;
+    feeds;
+    fulfillment;
+    returns;
+    reports;
+    notifications;
+    advertising;
+    settings;
+    constructor(config) {
+        this.client = new WalmartApiClient(config);
+        this.auth = this.client.getAuthClient();
+        this.items = new ItemsApi(this.client);
+        this.inventory = new InventoryApi(this.client);
+        this.orders = new OrdersApi(this.client);
+        this.pricing = new PricingApi(this.client);
+        this.feeds = new FeedsApi(this.client);
+        this.fulfillment = new FulfillmentApi(this.client);
+        this.returns = new ReturnsApi(this.client);
+        this.reports = new ReportsApi(this.client);
+        this.notifications = new NotificationsApi(this.client);
+        this.settings = new SettingsApi(this.client);
+        // Advertising uses a separate HTTP client with different auth
+        const adClient = new WalmartAdClient(config);
+        this.advertising = new AdvertisingApi(adClient);
+    }
+    async initialize() {
+        await this.client.initialize();
+    }
+    /** Snapshot the rate limiter state for the walmart_get_rate_budget tool. */
+    getRateLimiterStatus() {
+        return this.client.getRateLimiter().getStatus();
+    }
+    /** Expose the marketplace client for the walmart_call_endpoint discovery tool. */
+    getMarketplaceClient() {
+        return this.client;
+    }
+}

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

@@ -0,0 +1,27 @@
+import { WalmartApiClient } from '../client.js';
+export declare class InventoryApi {
+    private client;
+    private basePath;
+    constructor(client: WalmartApiClient);
+    getInventory(sku: string): Promise<unknown>;
+    updateInventory(data: {
+        sku: string;
+        quantity: number;
+        shipNode?: string;
+    }): Promise<unknown>;
+    getInventoryAllNodes(sku: string): Promise<unknown>;
+    updateInventoryMultiNode(sku: string, data: object): Promise<unknown>;
+    getAllInventory(params?: {
+        limit?: number;
+        offset?: string;
+        shipNode?: string;
+    }): Promise<unknown>;
+    submitInventoryFeed(data: object): Promise<unknown>;
+    submitMultiNodeInventoryFeed(data: object): Promise<unknown>;
+    getLagTime(sku: string): Promise<unknown>;
+    updateLagTime(data: {
+        sku: string;
+        fulfillmentLagTime: number;
+    }): Promise<unknown>;
+    submitLagTimeFeed(data: object): Promise<unknown>;
+}

package/build/api/inventory/inventory-api.js

@@ -0,0 +1,49 @@
+export class InventoryApi {
+    client;
+    basePath = '/v3';
+    constructor(client) {
+        this.client = client;
+    }
+    async getInventory(sku) {
+        if (!sku)
+            throw new Error('SKU is required');
+        return await this.client.get(`${this.basePath}/inventory`, { sku });
+    }
+    async updateInventory(data) {
+        if (!data.sku)
+            throw new Error('SKU is required');
+        return await this.client.put(`${this.basePath}/inventory`, data);
+    }
+    async getInventoryAllNodes(sku) {
+        if (!sku)
+            throw new Error('SKU is required');
+        return await this.client.get(`${this.basePath}/inventories/${encodeURIComponent(sku)}`);
+    }
+    async updateInventoryMultiNode(sku, data) {
+        if (!sku)
+            throw new Error('SKU is required');
+        return await this.client.put(`${this.basePath}/inventories/${encodeURIComponent(sku)}`, data);
+    }
+    async getAllInventory(params) {
+        return await this.client.get(`${this.basePath}/inventories`, params);
+    }
+    async submitInventoryFeed(data) {
+        return await this.client.post(`${this.basePath}/feeds?feedType=inventory`, data, { headers: { 'Content-Type': 'application/json' } });
+    }
+    async submitMultiNodeInventoryFeed(data) {
+        return await this.client.post(`${this.basePath}/feeds?feedType=MP_INVENTORY`, data, { headers: { 'Content-Type': 'application/json' } });
+    }
+    async getLagTime(sku) {
+        if (!sku)
+            throw new Error('SKU is required');
+        return await this.client.get(`${this.basePath}/lagtime`, { sku });
+    }
+    async updateLagTime(data) {
+        if (!data.sku)
+            throw new Error('SKU is required');
+        return await this.client.put(`${this.basePath}/lagtime`, data);
+    }
+    async submitLagTimeFeed(data) {
+        return await this.client.post(`${this.basePath}/feeds?feedType=LAGTIME`, data, { headers: { 'Content-Type': 'application/json' } });
+    }
+}

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

@@ -0,0 +1,33 @@
+import { WalmartApiClient } from '../client.js';
+export declare class ItemsApi {
+    private client;
+    private basePath;
+    constructor(client: WalmartApiClient);
+    getAllItems(params?: {
+        limit?: number;
+        offset?: string;
+        lifecycleStatus?: string;
+        publishedStatus?: string;
+        sku?: string;
+    }): Promise<unknown>;
+    getItem(sku: string): Promise<unknown>;
+    retireItem(sku: string): Promise<unknown>;
+    bulkRetireItems(data: {
+        sku: string;
+    }[]): Promise<unknown>;
+    getItemCount(params?: {
+        status?: string;
+        lifecycleStatus?: string;
+        publishedStatus?: string;
+    }): Promise<unknown>;
+    getTaxonomy(): Promise<unknown>;
+    getItemSpec(params: {
+        productType: string;
+        version?: string;
+    }): Promise<unknown>;
+    submitItemFeed(data: object): Promise<unknown>;
+    submitItemUpdateFeed(data: object): Promise<unknown>;
+    submitWfsItemFeed(data: object): Promise<unknown>;
+    convertToWfs(data: object): Promise<unknown>;
+    getHazmatItems(data?: object): Promise<unknown>;
+}

package/build/api/items/items-api.js

@@ -0,0 +1,67 @@
+export class ItemsApi {
+    client;
+    basePath = '/v3';
+    constructor(client) {
+        this.client = client;
+    }
+    async getAllItems(params) {
+        const query = {};
+        if (params?.limit)
+            query.limit = params.limit;
+        if (params?.offset)
+            query.offset = params.offset;
+        if (params?.lifecycleStatus)
+            query.lifecycleStatus = params.lifecycleStatus;
+        if (params?.publishedStatus)
+            query.publishedStatus = params.publishedStatus;
+        if (params?.sku)
+            query.sku = params.sku;
+        return await this.client.get(`${this.basePath}/items`, query);
+    }
+    async getItem(sku) {
+        if (!sku)
+            throw new Error('SKU is required');
+        return await this.client.get(`${this.basePath}/items/${encodeURIComponent(sku)}`);
+    }
+    async retireItem(sku) {
+        if (!sku)
+            throw new Error('SKU is required');
+        return await this.client.delete(`${this.basePath}/items/${encodeURIComponent(sku)}`);
+    }
+    async bulkRetireItems(data) {
+        if (!data?.length)
+            throw new Error('At least one SKU is required');
+        return await this.client.post(`${this.basePath}/items/retire`, { skus: data });
+    }
+    async getItemCount(params) {
+        // `status` is mandatory on /v3/items/count (item statuses in CSV, e.g.
+        // PUBLISHED, UNPUBLISHED). Default to PUBLISHED when not supplied.
+        const query = { status: 'PUBLISHED', ...params };
+        return await this.client.get(`${this.basePath}/items/count`, query);
+    }
+    async getTaxonomy() {
+        return await this.client.get(`${this.basePath}/taxonomy`);
+    }
+    async getItemSpec(params) {
+        if (!params.productType)
+            throw new Error('productType is required');
+        return await this.client.get(`${this.basePath}/items/spec`, params);
+    }
+    async submitItemFeed(data) {
+        return await this.client.post(`${this.basePath}/feeds?feedType=item`, data, { headers: { 'Content-Type': 'application/json' } });
+    }
+    async submitItemUpdateFeed(data) {
+        return await this.client.post(`${this.basePath}/feeds?feedType=MP_MAINTENANCE`, data, { headers: { 'Content-Type': 'application/json' } });
+    }
+    async submitWfsItemFeed(data) {
+        return await this.client.post(`${this.basePath}/feeds?feedType=MP_WFS_ITEM`, data, { headers: { 'Content-Type': 'application/json' } });
+    }
+    async convertToWfs(data) {
+        return await this.client.post(`${this.basePath}/feeds?feedType=OMNI_WFS`, data, { headers: { 'Content-Type': 'application/json' } });
+    }
+    async getHazmatItems(data) {
+        // Hazmat compliance "on hold" items are retrieved via the on-hold search
+        // endpoint (POST). The previous `/v3/items/hazmat` path does not exist (405).
+        return await this.client.post(`${this.basePath}/items/onhold/search`, data ?? {});
+    }
+}

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

@@ -0,0 +1,14 @@
+import { WalmartApiClient } from '../client.js';
+export declare class NotificationsApi {
+    private client;
+    private basePath;
+    constructor(client: WalmartApiClient);
+    createSubscription(data: object): Promise<unknown>;
+    getSubscriptions(params?: {
+        eventType?: string;
+    }): Promise<unknown>;
+    getSubscription(subscriptionId: string): Promise<unknown>;
+    updateSubscription(subscriptionId: string, data: object): Promise<unknown>;
+    deleteSubscription(subscriptionId: string): Promise<unknown>;
+    testSubscription(subscriptionId: string): Promise<unknown>;
+}

package/build/api/notifications/notifications-api.js

@@ -0,0 +1,33 @@
+export class NotificationsApi {
+    client;
+    basePath = '/v3/notifications/subscriptions';
+    constructor(client) {
+        this.client = client;
+    }
+    async createSubscription(data) {
+        return await this.client.post(this.basePath, data);
+    }
+    async getSubscriptions(params) {
+        return await this.client.get(this.basePath, params);
+    }
+    async getSubscription(subscriptionId) {
+        if (!subscriptionId)
+            throw new Error('subscriptionId is required');
+        return await this.client.get(`${this.basePath}/${encodeURIComponent(subscriptionId)}`);
+    }
+    async updateSubscription(subscriptionId, data) {
+        if (!subscriptionId)
+            throw new Error('subscriptionId is required');
+        return await this.client.put(`${this.basePath}/${encodeURIComponent(subscriptionId)}`, data);
+    }
+    async deleteSubscription(subscriptionId) {
+        if (!subscriptionId)
+            throw new Error('subscriptionId is required');
+        return await this.client.delete(`${this.basePath}/${encodeURIComponent(subscriptionId)}`);
+    }
+    async testSubscription(subscriptionId) {
+        if (!subscriptionId)
+            throw new Error('subscriptionId is required');
+        return await this.client.post(`${this.basePath}/${encodeURIComponent(subscriptionId)}/test`);
+    }
+}

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

@@ -0,0 +1,32 @@
+import { WalmartApiClient } from '../client.js';
+export declare class OrdersApi {
+    private client;
+    private basePath;
+    constructor(client: WalmartApiClient);
+    getAllOrders(params?: {
+        limit?: number;
+        offset?: string;
+        status?: string;
+        createdStartDate?: string;
+        createdEndDate?: string;
+        customerOrderId?: string;
+        purchaseOrderId?: string;
+        sku?: string;
+        shipNode?: string;
+    }): Promise<unknown>;
+    getReleasedOrders(params?: {
+        limit?: number;
+        offset?: string;
+        createdStartDate?: string;
+        createdEndDate?: string;
+        shipNode?: string;
+    }): Promise<unknown>;
+    getOrder(purchaseOrderId: string): Promise<unknown>;
+    acknowledgeOrder(purchaseOrderId: string): Promise<unknown>;
+    shipOrder(purchaseOrderId: string, data: object): Promise<unknown>;
+    cancelOrder(purchaseOrderId: string, data: object): Promise<unknown>;
+    refundOrder(purchaseOrderId: string, data: object): Promise<unknown>;
+    getShippingCarriers(): Promise<unknown>;
+    createShippingLabel(data: object): Promise<unknown>;
+    getShippingEstimate(params: object): Promise<unknown>;
+}

package/build/api/orders/orders-api.js

@@ -0,0 +1,47 @@
+export class OrdersApi {
+    client;
+    basePath = '/v3/orders';
+    constructor(client) {
+        this.client = client;
+    }
+    async getAllOrders(params) {
+        return await this.client.get(this.basePath, params);
+    }
+    async getReleasedOrders(params) {
+        return await this.client.get(`${this.basePath}/released`, params);
+    }
+    async getOrder(purchaseOrderId) {
+        if (!purchaseOrderId)
+            throw new Error('purchaseOrderId is required');
+        return await this.client.get(`${this.basePath}/${encodeURIComponent(purchaseOrderId)}`);
+    }
+    async acknowledgeOrder(purchaseOrderId) {
+        if (!purchaseOrderId)
+            throw new Error('purchaseOrderId is required');
+        return await this.client.post(`${this.basePath}/${encodeURIComponent(purchaseOrderId)}/acknowledge`);
+    }
+    async shipOrder(purchaseOrderId, data) {
+        if (!purchaseOrderId)
+            throw new Error('purchaseOrderId is required');
+        return await this.client.post(`${this.basePath}/${encodeURIComponent(purchaseOrderId)}/shipping`, data);
+    }
+    async cancelOrder(purchaseOrderId, data) {
+        if (!purchaseOrderId)
+            throw new Error('purchaseOrderId is required');
+        return await this.client.post(`${this.basePath}/${encodeURIComponent(purchaseOrderId)}/cancel`, data);
+    }
+    async refundOrder(purchaseOrderId, data) {
+        if (!purchaseOrderId)
+            throw new Error('purchaseOrderId is required');
+        return await this.client.post(`${this.basePath}/${encodeURIComponent(purchaseOrderId)}/refund`, data);
+    }
+    async getShippingCarriers() {
+        return await this.client.get('/v3/shipping/carriers');
+    }
+    async createShippingLabel(data) {
+        return await this.client.post('/v3/shipping/labels', data);
+    }
+    async getShippingEstimate(params) {
+        return await this.client.get('/v3/shipping/estimate', params);
+    }
+}

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

@@ -0,0 +1,32 @@
+import { WalmartApiClient } from '../client.js';
+export declare class PricingApi {
+    private client;
+    private basePath;
+    constructor(client: WalmartApiClient);
+    /**
+     * Update the regular (BASE) price for a single SKU. Accepts semantic params
+     * and builds the Walmart `/v3/price` payload, so callers don't have to
+     * hand-assemble Walmart's nested pricing structure. For promotional or
+     * strikethrough pricing, use the promo price feed.
+     */
+    updatePrice(data: {
+        sku: string;
+        amount: number;
+        currency?: string;
+    }): Promise<unknown>;
+    submitPriceFeed(data: object): Promise<unknown>;
+    submitMpPriceFeed(data: object): Promise<unknown>;
+    submitPromoPriceFeed(data: object): Promise<unknown>;
+    getRepricerStrategies(): Promise<unknown>;
+    createRepricerStrategy(data: object): Promise<unknown>;
+    updateRepricerStrategy(data: object): Promise<unknown>;
+    deleteRepricerStrategy(strategyId: string): Promise<unknown>;
+    assignItemsToStrategy(data: {
+        strategyId: string;
+        items: object[];
+    }): Promise<unknown>;
+    unassignItemsFromStrategy(data: {
+        strategyId: string;
+        skus: string[];
+    }): Promise<unknown>;
+}

package/build/api/pricing/pricing-api.js

@@ -0,0 +1,60 @@
+export class PricingApi {
+    client;
+    basePath = '/v3';
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Update the regular (BASE) price for a single SKU. Accepts semantic params
+     * and builds the Walmart `/v3/price` payload, so callers don't have to
+     * hand-assemble Walmart's nested pricing structure. For promotional or
+     * strikethrough pricing, use the promo price feed.
+     */
+    async updatePrice(data) {
+        if (!data.sku)
+            throw new Error('SKU is required');
+        if (typeof data.amount !== 'number' || Number.isNaN(data.amount)) {
+            throw new Error('amount (a number, e.g. 16.99) is required');
+        }
+        const currency = data.currency || 'USD';
+        const payload = {
+            sku: data.sku,
+            pricing: [
+                {
+                    currentPriceType: 'BASE',
+                    currentPrice: { currency, amount: data.amount },
+                },
+            ],
+        };
+        return await this.client.put(`${this.basePath}/price`, payload);
+    }
+    async submitPriceFeed(data) {
+        return await this.client.post(`${this.basePath}/feeds?feedType=price`, data, { headers: { 'Content-Type': 'application/json' } });
+    }
+    async submitMpPriceFeed(data) {
+        return await this.client.post(`${this.basePath}/feeds?feedType=MP_ITEM_PRICE_UPDATE`, data, { headers: { 'Content-Type': 'application/json' } });
+    }
+    async submitPromoPriceFeed(data) {
+        return await this.client.post(`${this.basePath}/feeds?feedType=PROMO_PRICE`, data, { headers: { 'Content-Type': 'application/json' } });
+    }
+    async getRepricerStrategies() {
+        return await this.client.get(`${this.basePath}/repricer/strategies`);
+    }
+    async createRepricerStrategy(data) {
+        return await this.client.post(`${this.basePath}/repricer/strategy`, data);
+    }
+    async updateRepricerStrategy(data) {
+        return await this.client.put(`${this.basePath}/repricer/strategy`, data);
+    }
+    async deleteRepricerStrategy(strategyId) {
+        if (!strategyId)
+            throw new Error('strategyId is required');
+        return await this.client.delete(`${this.basePath}/repricer/strategy`, { strategyId });
+    }
+    async assignItemsToStrategy(data) {
+        return await this.client.post(`${this.basePath}/repricer/strategy/items`, data);
+    }
+    async unassignItemsFromStrategy(data) {
+        return await this.client.delete(`${this.basePath}/repricer/strategy/items`, data);
+    }
+}

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

@@ -0,0 +1,37 @@
+import { WalmartApiClient } from '../client.js';
+export declare class ReportsApi {
+    private client;
+    constructor(client: WalmartApiClient);
+    createReport(data: object): Promise<unknown>;
+    getReportRequests(params?: {
+        reportType?: string;
+        reportVersion?: string;
+    }): Promise<unknown>;
+    getReportStatus(requestId: string): Promise<unknown>;
+    downloadReport(params: {
+        requestId?: string;
+        reportType?: string;
+    }): Promise<unknown>;
+    createReportSchedule(data: object): Promise<unknown>;
+    getReportSchedules(params?: {
+        reportType?: string;
+    }): Promise<unknown>;
+    updateReportSchedule(scheduleId: string, data: object): Promise<unknown>;
+    deleteReportSchedule(scheduleId: string): Promise<unknown>;
+    getUnpublishedItems(params?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<unknown>;
+    getListingQuality(params?: {
+        category?: string;
+    }): Promise<unknown>;
+    getQualityCategories(params?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<unknown>;
+    getItemQualityDetails(params?: {
+        category?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<unknown>;
+}

package/build/api/reports/reports-api.js

@@ -0,0 +1,51 @@
+export class ReportsApi {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    // ===== Report Requests =====
+    async createReport(data) {
+        return await this.client.post('/v3/reports/reportRequests', data);
+    }
+    async getReportRequests(params) {
+        return await this.client.get('/v3/reports/reportRequests', params);
+    }
+    async getReportStatus(requestId) {
+        if (!requestId)
+            throw new Error('requestId is required');
+        return await this.client.get(`/v3/reports/reportRequests/${encodeURIComponent(requestId)}`);
+    }
+    async downloadReport(params) {
+        return await this.client.get('/v3/reports/downloadReport', params);
+    }
+    // ===== Report Schedules =====
+    async createReportSchedule(data) {
+        return await this.client.post('/v3/reports/schedules', data);
+    }
+    async getReportSchedules(params) {
+        return await this.client.get('/v3/reports/schedules', params);
+    }
+    async updateReportSchedule(scheduleId, data) {
+        if (!scheduleId)
+            throw new Error('scheduleId is required');
+        return await this.client.put(`/v3/reports/schedules/${encodeURIComponent(scheduleId)}`, data);
+    }
+    async deleteReportSchedule(scheduleId) {
+        if (!scheduleId)
+            throw new Error('scheduleId is required');
+        return await this.client.delete(`/v3/reports/schedules/${encodeURIComponent(scheduleId)}`);
+    }
+    // ===== Insights =====
+    async getUnpublishedItems(params) {
+        return await this.client.get('/v3/insights/items/unpublished', params);
+    }
+    async getListingQuality(params) {
+        return await this.client.get('/v3/insights/items/listingQuality/score', params);
+    }
+    async getQualityCategories(params) {
+        return await this.client.get('/v3/insights/items/listingQuality/categories', params);
+    }
+    async getItemQualityDetails(params) {
+        return await this.client.get('/v3/insights/items/listingQuality/items', params);
+    }
+}

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

@@ -0,0 +1,26 @@
+import { WalmartApiClient } from '../client.js';
+export declare class ReturnsApi {
+    private client;
+    private basePath;
+    constructor(client: WalmartApiClient);
+    getAllReturns(params?: {
+        limit?: number;
+        offset?: number;
+        status?: string;
+        returnCreationStartDate?: string;
+        returnCreationEndDate?: string;
+        customerOrderId?: string;
+    }): Promise<unknown>;
+    getReturn(returnOrderId: string): Promise<unknown>;
+    approveReturn(data: object): Promise<unknown>;
+    rejectReturn(data: object): Promise<unknown>;
+    issueReturnRefund(returnOrderId: string, itemId: string, data: object): Promise<unknown>;
+    generateReturnLabel(returnOrderId: string, itemId: string, data: object): Promise<unknown>;
+    getWfsReturns(params?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<unknown>;
+    getReturnCount(params?: {
+        status?: string;
+    }): Promise<unknown>;
+}

package/build/api/returns/returns-api.js

@@ -0,0 +1,37 @@
+export class ReturnsApi {
+    client;
+    basePath = '/v3/returns';
+    constructor(client) {
+        this.client = client;
+    }
+    async getAllReturns(params) {
+        return await this.client.get(this.basePath, params);
+    }
+    async getReturn(returnOrderId) {
+        if (!returnOrderId)
+            throw new Error('returnOrderId is required');
+        return await this.client.get(`${this.basePath}/${encodeURIComponent(returnOrderId)}`);
+    }
+    async approveReturn(data) {
+        return await this.client.post(`${this.basePath}/approve`, data);
+    }
+    async rejectReturn(data) {
+        return await this.client.post(`${this.basePath}/reject`, data);
+    }
+    async issueReturnRefund(returnOrderId, itemId, data) {
+        if (!returnOrderId || !itemId)
+            throw new Error('returnOrderId and itemId are required');
+        return await this.client.post(`${this.basePath}/${encodeURIComponent(returnOrderId)}/items/${encodeURIComponent(itemId)}/refund`, data);
+    }
+    async generateReturnLabel(returnOrderId, itemId, data) {
+        if (!returnOrderId || !itemId)
+            throw new Error('returnOrderId and itemId are required');
+        return await this.client.post(`${this.basePath}/${encodeURIComponent(returnOrderId)}/items/${encodeURIComponent(itemId)}/shippinglabel`, data);
+    }
+    async getWfsReturns(params) {
+        return await this.client.get(this.basePath, { ...params, isWFSEnabled: 'Y' });
+    }
+    async getReturnCount(params) {
+        return await this.client.get(`${this.basePath}/count`, params);
+    }
+}

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

@@ -0,0 +1,9 @@
+import { WalmartApiClient } from '../client.js';
+export declare class SettingsApi {
+    private client;
+    constructor(client: WalmartApiClient);
+    getShippingSettings(): Promise<unknown>;
+    updateShippingSettings(data: object): Promise<unknown>;
+    getFulfillmentCenters(): Promise<unknown>;
+    getPartnerInfo(): Promise<object>;
+}