@lehaotech/walmart-mcp 0.5.4

package/build/tools/definitions/returns.d.ts

@@ -0,0 +1,441 @@
+import { z } from 'zod';
+export declare const returnTools: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        limit: z.ZodOptional<z.ZodNumber>;
+        offset: z.ZodOptional<z.ZodNumber>;
+        status: z.ZodOptional<z.ZodString>;
+        returnCreationStartDate: z.ZodOptional<z.ZodString>;
+        returnCreationEndDate: z.ZodOptional<z.ZodString>;
+        customerOrderId: z.ZodOptional<z.ZodString>;
+        returnOrderId?: undefined;
+        approvalData?: undefined;
+        rejectionData?: undefined;
+        itemId?: undefined;
+        refundData?: undefined;
+        labelData?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        returnOrderId: z.ZodString;
+        limit?: undefined;
+        offset?: undefined;
+        status?: undefined;
+        returnCreationStartDate?: undefined;
+        returnCreationEndDate?: undefined;
+        customerOrderId?: undefined;
+        approvalData?: undefined;
+        rejectionData?: undefined;
+        itemId?: undefined;
+        refundData?: undefined;
+        labelData?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        approvalData: z.ZodObject<{
+            returnOrderId: z.ZodString;
+            returnOrderLines: z.ZodArray<z.ZodObject<{
+                returnOrderLineNumber: z.ZodNumber;
+                returnReason: z.ZodOptional<z.ZodString>;
+                actionType: z.ZodOptional<z.ZodEnum<["APPROVE", "REJECT", "KEEP_IT"]>>;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                returnOrderLineNumber: z.ZodNumber;
+                returnReason: z.ZodOptional<z.ZodString>;
+                actionType: z.ZodOptional<z.ZodEnum<["APPROVE", "REJECT", "KEEP_IT"]>>;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                returnOrderLineNumber: z.ZodNumber;
+                returnReason: z.ZodOptional<z.ZodString>;
+                actionType: z.ZodOptional<z.ZodEnum<["APPROVE", "REJECT", "KEEP_IT"]>>;
+            }, z.ZodTypeAny, "passthrough">>, "many">;
+        }, "strict", z.ZodTypeAny, {
+            returnOrderId: string;
+            returnOrderLines: z.objectOutputType<{
+                returnOrderLineNumber: z.ZodNumber;
+                returnReason: z.ZodOptional<z.ZodString>;
+                actionType: z.ZodOptional<z.ZodEnum<["APPROVE", "REJECT", "KEEP_IT"]>>;
+            }, z.ZodTypeAny, "passthrough">[];
+        }, {
+            returnOrderId: string;
+            returnOrderLines: z.objectInputType<{
+                returnOrderLineNumber: z.ZodNumber;
+                returnReason: z.ZodOptional<z.ZodString>;
+                actionType: z.ZodOptional<z.ZodEnum<["APPROVE", "REJECT", "KEEP_IT"]>>;
+            }, z.ZodTypeAny, "passthrough">[];
+        }>;
+        limit?: undefined;
+        offset?: undefined;
+        status?: undefined;
+        returnCreationStartDate?: undefined;
+        returnCreationEndDate?: undefined;
+        customerOrderId?: undefined;
+        returnOrderId?: undefined;
+        rejectionData?: undefined;
+        itemId?: undefined;
+        refundData?: undefined;
+        labelData?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        rejectionData: z.ZodObject<{
+            returnOrderId: z.ZodString;
+            returnOrderLines: z.ZodArray<z.ZodIntersection<z.ZodObject<{
+                returnOrderLineNumber: z.ZodNumber;
+                returnReason: z.ZodOptional<z.ZodString>;
+                actionType: z.ZodOptional<z.ZodEnum<["APPROVE", "REJECT", "KEEP_IT"]>>;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                returnOrderLineNumber: z.ZodNumber;
+                returnReason: z.ZodOptional<z.ZodString>;
+                actionType: z.ZodOptional<z.ZodEnum<["APPROVE", "REJECT", "KEEP_IT"]>>;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                returnOrderLineNumber: z.ZodNumber;
+                returnReason: z.ZodOptional<z.ZodString>;
+                actionType: z.ZodOptional<z.ZodEnum<["APPROVE", "REJECT", "KEEP_IT"]>>;
+            }, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
+                rejectionReason: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                rejectionReason: string;
+            }, {
+                rejectionReason: string;
+            }>>, "many">;
+        }, "strict", z.ZodTypeAny, {
+            returnOrderId: string;
+            returnOrderLines: ({
+                returnOrderLineNumber: number;
+                returnReason?: string | undefined;
+                actionType?: "APPROVE" | "REJECT" | "KEEP_IT" | undefined;
+            } & {
+                [k: string]: unknown;
+            } & {
+                rejectionReason: string;
+            })[];
+        }, {
+            returnOrderId: string;
+            returnOrderLines: ({
+                returnOrderLineNumber: number;
+                returnReason?: string | undefined;
+                actionType?: "APPROVE" | "REJECT" | "KEEP_IT" | undefined;
+            } & {
+                [k: string]: unknown;
+            } & {
+                rejectionReason: string;
+            })[];
+        }>;
+        limit?: undefined;
+        offset?: undefined;
+        status?: undefined;
+        returnCreationStartDate?: undefined;
+        returnCreationEndDate?: undefined;
+        customerOrderId?: undefined;
+        returnOrderId?: undefined;
+        approvalData?: undefined;
+        itemId?: undefined;
+        refundData?: undefined;
+        labelData?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        returnOrderId: z.ZodString;
+        itemId: z.ZodString;
+        refundData: z.ZodObject<{
+            refundReason: z.ZodString;
+            chargeRefunds: z.ZodArray<z.ZodObject<{
+                chargeType: z.ZodEnum<["PRODUCT", "SHIPPING", "TAX", "FEE"]>;
+                chargeName: z.ZodString;
+                chargeAmount: z.ZodObject<{
+                    currency: z.ZodEnum<["USD", "MXN", "CAD", "CLP"]>;
+                    amount: z.ZodNumber;
+                }, "strict", z.ZodTypeAny, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }>;
+                taxRefundAmount: z.ZodOptional<z.ZodObject<{
+                    currency: z.ZodEnum<["USD", "MXN", "CAD", "CLP"]>;
+                    amount: z.ZodNumber;
+                }, "strict", z.ZodTypeAny, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }>>;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                chargeType: z.ZodEnum<["PRODUCT", "SHIPPING", "TAX", "FEE"]>;
+                chargeName: z.ZodString;
+                chargeAmount: z.ZodObject<{
+                    currency: z.ZodEnum<["USD", "MXN", "CAD", "CLP"]>;
+                    amount: z.ZodNumber;
+                }, "strict", z.ZodTypeAny, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }>;
+                taxRefundAmount: z.ZodOptional<z.ZodObject<{
+                    currency: z.ZodEnum<["USD", "MXN", "CAD", "CLP"]>;
+                    amount: z.ZodNumber;
+                }, "strict", z.ZodTypeAny, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }>>;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                chargeType: z.ZodEnum<["PRODUCT", "SHIPPING", "TAX", "FEE"]>;
+                chargeName: z.ZodString;
+                chargeAmount: z.ZodObject<{
+                    currency: z.ZodEnum<["USD", "MXN", "CAD", "CLP"]>;
+                    amount: z.ZodNumber;
+                }, "strict", z.ZodTypeAny, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }>;
+                taxRefundAmount: z.ZodOptional<z.ZodObject<{
+                    currency: z.ZodEnum<["USD", "MXN", "CAD", "CLP"]>;
+                    amount: z.ZodNumber;
+                }, "strict", z.ZodTypeAny, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }>>;
+            }, z.ZodTypeAny, "passthrough">>, "many">;
+            sku: z.ZodOptional<z.ZodString>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            refundReason: z.ZodString;
+            chargeRefunds: z.ZodArray<z.ZodObject<{
+                chargeType: z.ZodEnum<["PRODUCT", "SHIPPING", "TAX", "FEE"]>;
+                chargeName: z.ZodString;
+                chargeAmount: z.ZodObject<{
+                    currency: z.ZodEnum<["USD", "MXN", "CAD", "CLP"]>;
+                    amount: z.ZodNumber;
+                }, "strict", z.ZodTypeAny, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }>;
+                taxRefundAmount: z.ZodOptional<z.ZodObject<{
+                    currency: z.ZodEnum<["USD", "MXN", "CAD", "CLP"]>;
+                    amount: z.ZodNumber;
+                }, "strict", z.ZodTypeAny, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }>>;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                chargeType: z.ZodEnum<["PRODUCT", "SHIPPING", "TAX", "FEE"]>;
+                chargeName: z.ZodString;
+                chargeAmount: z.ZodObject<{
+                    currency: z.ZodEnum<["USD", "MXN", "CAD", "CLP"]>;
+                    amount: z.ZodNumber;
+                }, "strict", z.ZodTypeAny, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }>;
+                taxRefundAmount: z.ZodOptional<z.ZodObject<{
+                    currency: z.ZodEnum<["USD", "MXN", "CAD", "CLP"]>;
+                    amount: z.ZodNumber;
+                }, "strict", z.ZodTypeAny, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }>>;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                chargeType: z.ZodEnum<["PRODUCT", "SHIPPING", "TAX", "FEE"]>;
+                chargeName: z.ZodString;
+                chargeAmount: z.ZodObject<{
+                    currency: z.ZodEnum<["USD", "MXN", "CAD", "CLP"]>;
+                    amount: z.ZodNumber;
+                }, "strict", z.ZodTypeAny, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }>;
+                taxRefundAmount: z.ZodOptional<z.ZodObject<{
+                    currency: z.ZodEnum<["USD", "MXN", "CAD", "CLP"]>;
+                    amount: z.ZodNumber;
+                }, "strict", z.ZodTypeAny, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }>>;
+            }, z.ZodTypeAny, "passthrough">>, "many">;
+            sku: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            refundReason: z.ZodString;
+            chargeRefunds: z.ZodArray<z.ZodObject<{
+                chargeType: z.ZodEnum<["PRODUCT", "SHIPPING", "TAX", "FEE"]>;
+                chargeName: z.ZodString;
+                chargeAmount: z.ZodObject<{
+                    currency: z.ZodEnum<["USD", "MXN", "CAD", "CLP"]>;
+                    amount: z.ZodNumber;
+                }, "strict", z.ZodTypeAny, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }>;
+                taxRefundAmount: z.ZodOptional<z.ZodObject<{
+                    currency: z.ZodEnum<["USD", "MXN", "CAD", "CLP"]>;
+                    amount: z.ZodNumber;
+                }, "strict", z.ZodTypeAny, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }>>;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                chargeType: z.ZodEnum<["PRODUCT", "SHIPPING", "TAX", "FEE"]>;
+                chargeName: z.ZodString;
+                chargeAmount: z.ZodObject<{
+                    currency: z.ZodEnum<["USD", "MXN", "CAD", "CLP"]>;
+                    amount: z.ZodNumber;
+                }, "strict", z.ZodTypeAny, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }>;
+                taxRefundAmount: z.ZodOptional<z.ZodObject<{
+                    currency: z.ZodEnum<["USD", "MXN", "CAD", "CLP"]>;
+                    amount: z.ZodNumber;
+                }, "strict", z.ZodTypeAny, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }>>;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                chargeType: z.ZodEnum<["PRODUCT", "SHIPPING", "TAX", "FEE"]>;
+                chargeName: z.ZodString;
+                chargeAmount: z.ZodObject<{
+                    currency: z.ZodEnum<["USD", "MXN", "CAD", "CLP"]>;
+                    amount: z.ZodNumber;
+                }, "strict", z.ZodTypeAny, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }>;
+                taxRefundAmount: z.ZodOptional<z.ZodObject<{
+                    currency: z.ZodEnum<["USD", "MXN", "CAD", "CLP"]>;
+                    amount: z.ZodNumber;
+                }, "strict", z.ZodTypeAny, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }, {
+                    currency: "USD" | "MXN" | "CAD" | "CLP";
+                    amount: number;
+                }>>;
+            }, z.ZodTypeAny, "passthrough">>, "many">;
+            sku: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">>;
+        limit?: undefined;
+        offset?: undefined;
+        status?: undefined;
+        returnCreationStartDate?: undefined;
+        returnCreationEndDate?: undefined;
+        customerOrderId?: undefined;
+        approvalData?: undefined;
+        rejectionData?: undefined;
+        labelData?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        returnOrderId: z.ZodString;
+        itemId: z.ZodString;
+        labelData: z.ZodObject<{
+            carrierName: z.ZodOptional<z.ZodString>;
+            carrierId: z.ZodOptional<z.ZodString>;
+            methodCode: z.ZodOptional<z.ZodString>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            carrierName: z.ZodOptional<z.ZodString>;
+            carrierId: z.ZodOptional<z.ZodString>;
+            methodCode: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            carrierName: z.ZodOptional<z.ZodString>;
+            carrierId: z.ZodOptional<z.ZodString>;
+            methodCode: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">>;
+        limit?: undefined;
+        offset?: undefined;
+        status?: undefined;
+        returnCreationStartDate?: undefined;
+        returnCreationEndDate?: undefined;
+        customerOrderId?: undefined;
+        approvalData?: undefined;
+        rejectionData?: undefined;
+        refundData?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        limit: z.ZodOptional<z.ZodNumber>;
+        offset: z.ZodOptional<z.ZodNumber>;
+        status?: undefined;
+        returnCreationStartDate?: undefined;
+        returnCreationEndDate?: undefined;
+        customerOrderId?: undefined;
+        returnOrderId?: undefined;
+        approvalData?: undefined;
+        rejectionData?: undefined;
+        itemId?: undefined;
+        refundData?: undefined;
+        labelData?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        status: z.ZodOptional<z.ZodString>;
+        limit?: undefined;
+        offset?: undefined;
+        returnCreationStartDate?: undefined;
+        returnCreationEndDate?: undefined;
+        customerOrderId?: undefined;
+        returnOrderId?: undefined;
+        approvalData?: undefined;
+        rejectionData?: undefined;
+        itemId?: undefined;
+        refundData?: undefined;
+        labelData?: undefined;
+    };
+})[];

package/build/tools/definitions/returns.js

@@ -0,0 +1,126 @@
+import { z } from 'zod';
+import { SkuSchema, MoneySchema } from './shared-schemas.js';
+// Walmart return line — used in approve/reject body.
+// Each entry references one return order line.
+const ReturnOrderLineSchema = z
+    .object({
+    returnOrderLineNumber: z.number().int().min(1),
+    returnReason: z.string().optional(),
+    actionType: z.enum(['APPROVE', 'REJECT', 'KEEP_IT']).optional(),
+})
+    .passthrough();
+const ApproveReturnBodySchema = z
+    .object({
+    returnOrderId: z.string().min(1, 'returnOrderId required'),
+    returnOrderLines: z
+        .array(ReturnOrderLineSchema)
+        .min(1, 'Need at least 1 return order line to approve'),
+})
+    .strict();
+const RejectReturnBodySchema = z
+    .object({
+    returnOrderId: z.string().min(1, 'returnOrderId required'),
+    returnOrderLines: z
+        .array(ReturnOrderLineSchema.and(z.object({
+        rejectionReason: z.string().min(1, 'rejectionReason required for each line'),
+    })))
+        .min(1),
+})
+    .strict();
+// Refund charges per line.
+const ChargeRefundSchema = z
+    .object({
+    chargeType: z.enum(['PRODUCT', 'SHIPPING', 'TAX', 'FEE']),
+    chargeName: z.string().min(1),
+    chargeAmount: MoneySchema,
+    taxRefundAmount: MoneySchema.optional(),
+})
+    .passthrough();
+const RefundBodySchema = z
+    .object({
+    refundReason: z.string().min(1, 'refundReason required'),
+    chargeRefunds: z
+        .array(ChargeRefundSchema)
+        .min(1, 'Need at least 1 charge refund entry'),
+    sku: SkuSchema.optional(),
+})
+    .passthrough();
+// Generate return label body — typically empty or carrier preference.
+const LabelBodySchema = z
+    .object({
+    carrierName: z.string().optional(),
+    carrierId: z.string().optional(),
+    methodCode: z.string().optional(),
+})
+    .passthrough();
+export const returnTools = [
+    {
+        name: 'walmart_get_all_returns',
+        description: 'Get all returns with optional filters. Returns include status, reason, and refund details.',
+        inputSchema: {
+            limit: z.number().int().min(1).max(200).optional().describe('Results per page'),
+            offset: z.number().int().min(0).optional().describe('Pagination offset'),
+            status: z.string().optional().describe('Filter by return status'),
+            returnCreationStartDate: z.string().optional().describe('Start date filter (ISO 8601)'),
+            returnCreationEndDate: z.string().optional().describe('End date filter (ISO 8601)'),
+            customerOrderId: z.string().optional().describe('Filter by customer order ID'),
+        },
+    },
+    {
+        name: 'walmart_get_return',
+        description: 'Get a single return by return order ID. Returns full details including items, reason, and refund info.',
+        inputSchema: {
+            returnOrderId: z.string().describe('Return order ID'),
+        },
+    },
+    {
+        name: 'walmart_approve_return',
+        description: 'Approve a customer return request. Required for seller-fulfilled returns. Body must include ' +
+            'returnOrderId and a non-empty returnOrderLines array.',
+        inputSchema: {
+            approvalData: ApproveReturnBodySchema,
+        },
+    },
+    {
+        name: 'walmart_reject_return',
+        description: 'Reject a customer return request. Each returnOrderLine must include a rejectionReason string.',
+        inputSchema: {
+            rejectionData: RejectReturnBodySchema,
+        },
+    },
+    {
+        name: 'walmart_issue_return_refund',
+        description: 'Issue a refund for a returned item. refundData requires refundReason and a non-empty ' +
+            'chargeRefunds array. Refund amount cannot exceed the original charge.',
+        inputSchema: {
+            returnOrderId: z.string().describe('Return order ID'),
+            itemId: z.string().describe('Return item ID to refund'),
+            refundData: RefundBodySchema,
+        },
+    },
+    {
+        name: 'walmart_generate_return_label',
+        description: 'Generate a prepaid return shipping label for a return item.',
+        inputSchema: {
+            returnOrderId: z.string().describe('Return order ID'),
+            itemId: z.string().describe('Return item ID'),
+            labelData: LabelBodySchema,
+        },
+    },
+    {
+        name: 'walmart_get_wfs_returns',
+        description: 'Get WFS (Walmart Fulfillment Services) returns by sending GET /v3/returns?isWFSEnabled=Y. ' +
+            'For sellers without WFS enrollment, Walmart returns the same set as walmart_get_all_returns.',
+        inputSchema: {
+            limit: z.number().int().min(1).max(200).optional().describe('Results per page'),
+            offset: z.number().int().min(0).optional().describe('Pagination offset'),
+        },
+    },
+    {
+        name: 'walmart_get_return_count',
+        description: 'Get count of returns grouped by status. Useful for dashboard metrics.',
+        inputSchema: {
+            status: z.string().optional().describe('Filter by return status'),
+        },
+    },
+];

package/build/tools/definitions/settings.d.ts

@@ -0,0 +1,100 @@
+import { z } from 'zod';
+export declare const settingsTools: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        settingsData?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        settingsData: z.ZodObject<{
+            shippingTemplates: z.ZodArray<z.ZodObject<{
+                templateName: z.ZodString;
+                isDefault: z.ZodOptional<z.ZodBoolean>;
+                methods: z.ZodArray<z.ZodObject<{
+                    methodCode: z.ZodEnum<["Standard", "Expedited", "OneDay", "TwoDay", "Freight", "Value"]>;
+                    transitTime: z.ZodOptional<z.ZodNumber>;
+                    isActive: z.ZodDefault<z.ZodBoolean>;
+                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                    methodCode: z.ZodEnum<["Standard", "Expedited", "OneDay", "TwoDay", "Freight", "Value"]>;
+                    transitTime: z.ZodOptional<z.ZodNumber>;
+                    isActive: z.ZodDefault<z.ZodBoolean>;
+                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                    methodCode: z.ZodEnum<["Standard", "Expedited", "OneDay", "TwoDay", "Freight", "Value"]>;
+                    transitTime: z.ZodOptional<z.ZodNumber>;
+                    isActive: z.ZodDefault<z.ZodBoolean>;
+                }, z.ZodTypeAny, "passthrough">>, "many">;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                templateName: z.ZodString;
+                isDefault: z.ZodOptional<z.ZodBoolean>;
+                methods: z.ZodArray<z.ZodObject<{
+                    methodCode: z.ZodEnum<["Standard", "Expedited", "OneDay", "TwoDay", "Freight", "Value"]>;
+                    transitTime: z.ZodOptional<z.ZodNumber>;
+                    isActive: z.ZodDefault<z.ZodBoolean>;
+                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                    methodCode: z.ZodEnum<["Standard", "Expedited", "OneDay", "TwoDay", "Freight", "Value"]>;
+                    transitTime: z.ZodOptional<z.ZodNumber>;
+                    isActive: z.ZodDefault<z.ZodBoolean>;
+                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                    methodCode: z.ZodEnum<["Standard", "Expedited", "OneDay", "TwoDay", "Freight", "Value"]>;
+                    transitTime: z.ZodOptional<z.ZodNumber>;
+                    isActive: z.ZodDefault<z.ZodBoolean>;
+                }, z.ZodTypeAny, "passthrough">>, "many">;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                templateName: z.ZodString;
+                isDefault: z.ZodOptional<z.ZodBoolean>;
+                methods: z.ZodArray<z.ZodObject<{
+                    methodCode: z.ZodEnum<["Standard", "Expedited", "OneDay", "TwoDay", "Freight", "Value"]>;
+                    transitTime: z.ZodOptional<z.ZodNumber>;
+                    isActive: z.ZodDefault<z.ZodBoolean>;
+                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                    methodCode: z.ZodEnum<["Standard", "Expedited", "OneDay", "TwoDay", "Freight", "Value"]>;
+                    transitTime: z.ZodOptional<z.ZodNumber>;
+                    isActive: z.ZodDefault<z.ZodBoolean>;
+                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                    methodCode: z.ZodEnum<["Standard", "Expedited", "OneDay", "TwoDay", "Freight", "Value"]>;
+                    transitTime: z.ZodOptional<z.ZodNumber>;
+                    isActive: z.ZodDefault<z.ZodBoolean>;
+                }, z.ZodTypeAny, "passthrough">>, "many">;
+            }, z.ZodTypeAny, "passthrough">>, "many">;
+        }, "strict", z.ZodTypeAny, {
+            shippingTemplates: z.objectOutputType<{
+                templateName: z.ZodString;
+                isDefault: z.ZodOptional<z.ZodBoolean>;
+                methods: z.ZodArray<z.ZodObject<{
+                    methodCode: z.ZodEnum<["Standard", "Expedited", "OneDay", "TwoDay", "Freight", "Value"]>;
+                    transitTime: z.ZodOptional<z.ZodNumber>;
+                    isActive: z.ZodDefault<z.ZodBoolean>;
+                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                    methodCode: z.ZodEnum<["Standard", "Expedited", "OneDay", "TwoDay", "Freight", "Value"]>;
+                    transitTime: z.ZodOptional<z.ZodNumber>;
+                    isActive: z.ZodDefault<z.ZodBoolean>;
+                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                    methodCode: z.ZodEnum<["Standard", "Expedited", "OneDay", "TwoDay", "Freight", "Value"]>;
+                    transitTime: z.ZodOptional<z.ZodNumber>;
+                    isActive: z.ZodDefault<z.ZodBoolean>;
+                }, z.ZodTypeAny, "passthrough">>, "many">;
+            }, z.ZodTypeAny, "passthrough">[];
+        }, {
+            shippingTemplates: z.objectInputType<{
+                templateName: z.ZodString;
+                isDefault: z.ZodOptional<z.ZodBoolean>;
+                methods: z.ZodArray<z.ZodObject<{
+                    methodCode: z.ZodEnum<["Standard", "Expedited", "OneDay", "TwoDay", "Freight", "Value"]>;
+                    transitTime: z.ZodOptional<z.ZodNumber>;
+                    isActive: z.ZodDefault<z.ZodBoolean>;
+                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                    methodCode: z.ZodEnum<["Standard", "Expedited", "OneDay", "TwoDay", "Freight", "Value"]>;
+                    transitTime: z.ZodOptional<z.ZodNumber>;
+                    isActive: z.ZodDefault<z.ZodBoolean>;
+                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                    methodCode: z.ZodEnum<["Standard", "Expedited", "OneDay", "TwoDay", "Freight", "Value"]>;
+                    transitTime: z.ZodOptional<z.ZodNumber>;
+                    isActive: z.ZodDefault<z.ZodBoolean>;
+                }, z.ZodTypeAny, "passthrough">>, "many">;
+            }, z.ZodTypeAny, "passthrough">[];
+        }>;
+    };
+})[];