@be-link/ecommerce-plan-allocation-service-node-sdk 0.0.39 → 0.0.40

package/enum.d.ts

@@ -37,6 +37,7 @@ export declare namespace ENUM {
             readonly DETAIL_NOT_FOUND: "入库单明细不存在";
             readonly SKU_NOT_FOUND: "SKU编码在入库单中不存在";
             readonly EMPTY_QUANTITY: "入库商品列表数量不能全部为0";
+            readonly HAS_PENDING_OR_APPROVED_REPLENISH: "存在待审批或已通过的补货申请，需先撤回补货申请才能确认入库";
         };
         /** 状态转换规则 */
         const STATUS_TRANSITIONS: {
@@ -51,13 +52,15 @@ export declare namespace ENUM {
             PENDING = "PENDING",
             PARTIAL = "PARTIAL",
             SHIPPED = "SHIPPED",
-            EARLY_COMPLETED = "EARLY_COMPLETED"
+            EARLY_COMPLETED = "EARLY_COMPLETED",
+            INVALID = "INVALID"
         }
         enum STATUS_CHINESE {
             PENDING = "\u5F85\u53D1\u8D27",
             PARTIAL = "\u90E8\u5206\u53D1\u8D27",
             SHIPPED = "\u5DF2\u53D1\u8D27",
-            EARLY_COMPLETED = "\u63D0\u524D\u5B8C\u6210"
+            EARLY_COMPLETED = "\u63D0\u524D\u5B8C\u6210",
+            INVALID = "\u5DF2\u5931\u6548"
         }
         /** 错误消息常量 */
         const ERROR_MESSAGES: {
@@ -125,6 +128,72 @@ export declare namespace ENUM {
             readonly RECORD_NOT_FOUND: "上传记录不存在";
         };
     }
+    namespace STORE_REPLENISH_ORDER_ENUM {
+        enum STATUS {
+            PENDING = "PENDING",
+            REJECT = "REJECT",
+            APPROVE = "APPROVE",
+            REPEAL = "REPEAL"
+        }
+        enum STATUS_CHINESE {
+            PENDING = "\u5F85\u5BA1\u6279",
+            REJECT = "\u5DF2\u62D2\u7EDD",
+            APPROVE = "\u5DF2\u901A\u8FC7",
+            REPEAL = "\u5DF2\u64A4\u9500"
+        }
+        enum APPLY_TYPE {
+            STOCK_IN_REPLENISH = "STOCK_IN_REPLENISH",
+            ACTIVE_APPLY = "ACTIVE_APPLY"
+        }
+        enum APPLY_TYPE_CHINESE {
+            STOCK_IN_REPLENISH = "\u95E8\u5E97\u5165\u5E93\u5355\u8865\u8D27",
+            ACTIVE_APPLY = "\u95E8\u5E97\u4E3B\u52A8\u7533\u8BF7\u8865\u8D27"
+        }
+        enum LOSS_TYPE {
+            STOCK = "STOCK",
+            WAREHOUSE = "WAREHOUSE",
+            EXPRESS = "EXPRESS",
+            NONE = "NONE"
+        }
+        enum LOSS_TYPE_CHINESE {
+            STOCK = "\u95E8\u5E97",
+            WAREHOUSE = "\u4ED3\u5E93",
+            EXPRESS = "\u5FEB\u9012",
+            NONE = "\u4E0D\u8BA1\u635F"
+        }
+        /** 状态映射 */
+        const STATUS_MAP: {
+            readonly PENDING: STATUS_CHINESE.PENDING;
+            readonly REJECT: STATUS_CHINESE.REJECT;
+            readonly APPROVE: STATUS_CHINESE.APPROVE;
+            readonly REPEAL: STATUS_CHINESE.REPEAL;
+        };
+        /** 申请类型映射 */
+        const APPLY_TYPE_MAP: {
+            readonly STOCK_IN_REPLENISH: APPLY_TYPE_CHINESE.STOCK_IN_REPLENISH;
+            readonly ACTIVE_APPLY: APPLY_TYPE_CHINESE.ACTIVE_APPLY;
+        };
+        /** 计损类型映射 */
+        const LOSS_TYPE_MAP: {
+            readonly STOCK: LOSS_TYPE_CHINESE.STOCK;
+            readonly WAREHOUSE: LOSS_TYPE_CHINESE.WAREHOUSE;
+            readonly EXPRESS: LOSS_TYPE_CHINESE.EXPRESS;
+            readonly NONE: LOSS_TYPE_CHINESE.NONE;
+        };
+        /** 错误消息常量 */
+        const ERROR_MESSAGES: {
+            readonly ORDER_NOT_FOUND: "补货单不存在";
+            readonly PRODUCT_NOT_FOUND: "商品不存在";
+            readonly SKU_NOT_FOUND: "SKU不存在";
+            readonly STOCK_IN_ORDER_NOT_FOUND: "入库单不存在";
+            readonly STORE_NOT_MATCH: "入库单与门店不匹配";
+            readonly INVALID_QUANTITY: "申请补货数量必须大于0";
+            readonly APPLY_QUANTITY_EXCEEDS_REMAINING: "申请数量不能大于剩余待收数量";
+            readonly STOCK_IN_ORDER_DETAIL_NOT_FOUND: "入库单中未找到对应的SKU明细";
+            readonly APPLY_FAILED: "补货申请失败，请稍后重试";
+            readonly ALREADY_APPLIED: "该入库单已经申请过补货，无法再次发起申请";
+        };
+    }
     namespace PRE_ALLOCATION_ORDER_ENUM {
         /** 预配货单状态（数字类型） */
         enum STATUS {
@@ -171,6 +240,12 @@ export declare namespace ENUM {
             STORE_STOCK_IN_REPLENISH = "\u95E8\u5E97\u5165\u5E93\u5355\u8865\u8D27",
             STORE_ACTIVE_APPLY = "\u95E8\u5E97\u4E3B\u52A8\u7533\u8BF7\u8865\u8D27"
         }
+        const SOURCE_TYPE_MAP: {
+            readonly 1: SOURCE_TYPE_CHINESE.ORDER_WITH_COUPON;
+            readonly 2: SOURCE_TYPE_CHINESE.MANUAL_IMPORT;
+            readonly 3: SOURCE_TYPE_CHINESE.STORE_STOCK_IN_REPLENISH;
+            readonly 4: SOURCE_TYPE_CHINESE.STORE_ACTIVE_APPLY;
+        };
         /** 错误消息常量 */
         const ERROR_MESSAGES: {
             readonly ORDER_NOT_FOUND: "预配货单不存在";

package/enum.js

@@ -47,6 +47,7 @@ var ENUM;
             DETAIL_NOT_FOUND: '入库单明细不存在',
             SKU_NOT_FOUND: 'SKU编码在入库单中不存在',
             EMPTY_QUANTITY: '入库商品列表数量不能全部为0',
+            HAS_PENDING_OR_APPROVED_REPLENISH: '存在待审批或已通过的补货申请，需先撤回补货申请才能确认入库',
         };
         /** 状态转换规则 */
         STORE_STOCK_IN_ORDER_ENUM.STATUS_TRANSITIONS = {
@@ -64,6 +65,7 @@ var ENUM;
             STATUS["PARTIAL"] = "PARTIAL";
             STATUS["SHIPPED"] = "SHIPPED";
             STATUS["EARLY_COMPLETED"] = "EARLY_COMPLETED";
+            STATUS["INVALID"] = "INVALID";
         })(STATUS = ALLOCATION_ORDER_ENUM.STATUS || (ALLOCATION_ORDER_ENUM.STATUS = {}));
         let STATUS_CHINESE;
         (function (STATUS_CHINESE) {
@@ -71,6 +73,7 @@ var ENUM;
             STATUS_CHINESE["PARTIAL"] = "\u90E8\u5206\u53D1\u8D27";
             STATUS_CHINESE["SHIPPED"] = "\u5DF2\u53D1\u8D27";
             STATUS_CHINESE["EARLY_COMPLETED"] = "\u63D0\u524D\u5B8C\u6210";
+            STATUS_CHINESE["INVALID"] = "\u5DF2\u5931\u6548";
         })(STATUS_CHINESE = ALLOCATION_ORDER_ENUM.STATUS_CHINESE || (ALLOCATION_ORDER_ENUM.STATUS_CHINESE = {}));
         /** 错误消息常量 */
         ALLOCATION_ORDER_ENUM.ERROR_MESSAGES = {
@@ -144,6 +147,79 @@ var ENUM;
             RECORD_NOT_FOUND: '上传记录不存在',
         };
     })(PRE_ALLOCATION_ORDER_UPLOAD_EXCEL_ENUM = ENUM.PRE_ALLOCATION_ORDER_UPLOAD_EXCEL_ENUM || (ENUM.PRE_ALLOCATION_ORDER_UPLOAD_EXCEL_ENUM = {}));
+    let STORE_REPLENISH_ORDER_ENUM;
+    (function (STORE_REPLENISH_ORDER_ENUM) {
+        let STATUS;
+        (function (STATUS) {
+            STATUS["PENDING"] = "PENDING";
+            STATUS["REJECT"] = "REJECT";
+            STATUS["APPROVE"] = "APPROVE";
+            STATUS["REPEAL"] = "REPEAL";
+        })(STATUS = STORE_REPLENISH_ORDER_ENUM.STATUS || (STORE_REPLENISH_ORDER_ENUM.STATUS = {}));
+        let STATUS_CHINESE;
+        (function (STATUS_CHINESE) {
+            STATUS_CHINESE["PENDING"] = "\u5F85\u5BA1\u6279";
+            STATUS_CHINESE["REJECT"] = "\u5DF2\u62D2\u7EDD";
+            STATUS_CHINESE["APPROVE"] = "\u5DF2\u901A\u8FC7";
+            STATUS_CHINESE["REPEAL"] = "\u5DF2\u64A4\u9500";
+        })(STATUS_CHINESE = STORE_REPLENISH_ORDER_ENUM.STATUS_CHINESE || (STORE_REPLENISH_ORDER_ENUM.STATUS_CHINESE = {}));
+        let APPLY_TYPE;
+        (function (APPLY_TYPE) {
+            APPLY_TYPE["STOCK_IN_REPLENISH"] = "STOCK_IN_REPLENISH";
+            APPLY_TYPE["ACTIVE_APPLY"] = "ACTIVE_APPLY";
+        })(APPLY_TYPE = STORE_REPLENISH_ORDER_ENUM.APPLY_TYPE || (STORE_REPLENISH_ORDER_ENUM.APPLY_TYPE = {}));
+        let APPLY_TYPE_CHINESE;
+        (function (APPLY_TYPE_CHINESE) {
+            APPLY_TYPE_CHINESE["STOCK_IN_REPLENISH"] = "\u95E8\u5E97\u5165\u5E93\u5355\u8865\u8D27";
+            APPLY_TYPE_CHINESE["ACTIVE_APPLY"] = "\u95E8\u5E97\u4E3B\u52A8\u7533\u8BF7\u8865\u8D27";
+        })(APPLY_TYPE_CHINESE = STORE_REPLENISH_ORDER_ENUM.APPLY_TYPE_CHINESE || (STORE_REPLENISH_ORDER_ENUM.APPLY_TYPE_CHINESE = {}));
+        let LOSS_TYPE;
+        (function (LOSS_TYPE) {
+            LOSS_TYPE["STOCK"] = "STOCK";
+            LOSS_TYPE["WAREHOUSE"] = "WAREHOUSE";
+            LOSS_TYPE["EXPRESS"] = "EXPRESS";
+            LOSS_TYPE["NONE"] = "NONE";
+        })(LOSS_TYPE = STORE_REPLENISH_ORDER_ENUM.LOSS_TYPE || (STORE_REPLENISH_ORDER_ENUM.LOSS_TYPE = {}));
+        let LOSS_TYPE_CHINESE;
+        (function (LOSS_TYPE_CHINESE) {
+            LOSS_TYPE_CHINESE["STOCK"] = "\u95E8\u5E97";
+            LOSS_TYPE_CHINESE["WAREHOUSE"] = "\u4ED3\u5E93";
+            LOSS_TYPE_CHINESE["EXPRESS"] = "\u5FEB\u9012";
+            LOSS_TYPE_CHINESE["NONE"] = "\u4E0D\u8BA1\u635F";
+        })(LOSS_TYPE_CHINESE = STORE_REPLENISH_ORDER_ENUM.LOSS_TYPE_CHINESE || (STORE_REPLENISH_ORDER_ENUM.LOSS_TYPE_CHINESE = {}));
+        /** 状态映射 */
+        STORE_REPLENISH_ORDER_ENUM.STATUS_MAP = {
+            [STATUS.PENDING]: STATUS_CHINESE.PENDING,
+            [STATUS.REJECT]: STATUS_CHINESE.REJECT,
+            [STATUS.APPROVE]: STATUS_CHINESE.APPROVE,
+            [STATUS.REPEAL]: STATUS_CHINESE.REPEAL,
+        };
+        /** 申请类型映射 */
+        STORE_REPLENISH_ORDER_ENUM.APPLY_TYPE_MAP = {
+            [APPLY_TYPE.STOCK_IN_REPLENISH]: APPLY_TYPE_CHINESE.STOCK_IN_REPLENISH,
+            [APPLY_TYPE.ACTIVE_APPLY]: APPLY_TYPE_CHINESE.ACTIVE_APPLY,
+        };
+        /** 计损类型映射 */
+        STORE_REPLENISH_ORDER_ENUM.LOSS_TYPE_MAP = {
+            [LOSS_TYPE.STOCK]: LOSS_TYPE_CHINESE.STOCK,
+            [LOSS_TYPE.WAREHOUSE]: LOSS_TYPE_CHINESE.WAREHOUSE,
+            [LOSS_TYPE.EXPRESS]: LOSS_TYPE_CHINESE.EXPRESS,
+            [LOSS_TYPE.NONE]: LOSS_TYPE_CHINESE.NONE,
+        };
+        /** 错误消息常量 */
+        STORE_REPLENISH_ORDER_ENUM.ERROR_MESSAGES = {
+            ORDER_NOT_FOUND: '补货单不存在',
+            PRODUCT_NOT_FOUND: '商品不存在',
+            SKU_NOT_FOUND: 'SKU不存在',
+            STOCK_IN_ORDER_NOT_FOUND: '入库单不存在',
+            STORE_NOT_MATCH: '入库单与门店不匹配',
+            INVALID_QUANTITY: '申请补货数量必须大于0',
+            APPLY_QUANTITY_EXCEEDS_REMAINING: '申请数量不能大于剩余待收数量',
+            STOCK_IN_ORDER_DETAIL_NOT_FOUND: '入库单中未找到对应的SKU明细',
+            APPLY_FAILED: '补货申请失败，请稍后重试',
+            ALREADY_APPLIED: '该入库单已经申请过补货，无法再次发起申请',
+        };
+    })(STORE_REPLENISH_ORDER_ENUM = ENUM.STORE_REPLENISH_ORDER_ENUM || (ENUM.STORE_REPLENISH_ORDER_ENUM = {}));
     let PRE_ALLOCATION_ORDER_ENUM;
     (function (PRE_ALLOCATION_ORDER_ENUM) {
         /** 预配货单状态（数字类型） */
@@ -197,6 +273,12 @@ var ENUM;
             SOURCE_TYPE_CHINESE["STORE_STOCK_IN_REPLENISH"] = "\u95E8\u5E97\u5165\u5E93\u5355\u8865\u8D27";
             SOURCE_TYPE_CHINESE["STORE_ACTIVE_APPLY"] = "\u95E8\u5E97\u4E3B\u52A8\u7533\u8BF7\u8865\u8D27";
         })(SOURCE_TYPE_CHINESE = PRE_ALLOCATION_ORDER_ENUM.SOURCE_TYPE_CHINESE || (PRE_ALLOCATION_ORDER_ENUM.SOURCE_TYPE_CHINESE = {}));
+        PRE_ALLOCATION_ORDER_ENUM.SOURCE_TYPE_MAP = {
+            [SOURCE_TYPE.ORDER_WITH_COUPON]: SOURCE_TYPE_CHINESE.ORDER_WITH_COUPON,
+            [SOURCE_TYPE.MANUAL_IMPORT]: SOURCE_TYPE_CHINESE.MANUAL_IMPORT,
+            [SOURCE_TYPE.STORE_STOCK_IN_REPLENISH]: SOURCE_TYPE_CHINESE.STORE_STOCK_IN_REPLENISH,
+            [SOURCE_TYPE.STORE_ACTIVE_APPLY]: SOURCE_TYPE_CHINESE.STORE_ACTIVE_APPLY,
+        };
         /** 错误消息常量 */
         PRE_ALLOCATION_ORDER_ENUM.ERROR_MESSAGES = {
             ORDER_NOT_FOUND: '预配货单不存在',

package/index.d.ts

@@ -6,9 +6,15 @@ export { storeStockInService } from './modules/storeStockIn/service';
 export { StoreStockInTypes } from './modules/storeStockIn/types';
 export { preAllocationOrderService } from './modules/preAllocationOrder/service';
 export { PreAllocationOrderTypes } from './modules/preAllocationOrder/types';
+export { storeReplenishOrderService } from './modules/storeReplenishOrder/service';
+export { StoreReplenishOrderTypes } from './modules/storeReplenishOrder/types';
+export { productStatisticsService } from './modules/productStatistics/service';
+export { ProductStatisticsTypes } from './modules/productStatistics/types';
 export { pickingRuleService } from './modules/pickingRule/service';
 export { PickingRuleTypes } from './modules/pickingRule/types';
 export { ENUM } from './enum';
 export { logisticsService } from './modules/logistics/service';
 export type { Service as LogisticsServiceTypes } from './modules/logistics/types';
+export { storeProductFulfillService } from './modules/storeProductFulfill/service';
+export { StoreProductFulfillTypes } from './modules/storeProductFulfill/types';
 export { ENUM as DEMO_ENUM } from './enum';

package/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEMO_ENUM = exports.logisticsService = exports.ENUM = exports.PickingRuleTypes = exports.pickingRuleService = exports.preAllocationOrderService = exports.storeStockInService = exports.allocationOrderService = exports.allocationService = void 0;
+exports.DEMO_ENUM = exports.storeProductFulfillService = exports.logisticsService = exports.ENUM = exports.PickingRuleTypes = exports.pickingRuleService = exports.productStatisticsService = exports.storeReplenishOrderService = exports.preAllocationOrderService = exports.storeStockInService = exports.allocationOrderService = exports.allocationService = void 0;
 var service_1 = require("./modules/allocation/service");
 Object.defineProperty(exports, "allocationService", { enumerable: true, get: function () { return service_1.allocationService; } });
 var service_2 = require("./modules/allocationOrder/service");
@@ -9,14 +9,20 @@ var service_3 = require("./modules/storeStockIn/service");
 Object.defineProperty(exports, "storeStockInService", { enumerable: true, get: function () { return service_3.storeStockInService; } });
 var service_4 = require("./modules/preAllocationOrder/service");
 Object.defineProperty(exports, "preAllocationOrderService", { enumerable: true, get: function () { return service_4.preAllocationOrderService; } });
-var service_5 = require("./modules/pickingRule/service");
-Object.defineProperty(exports, "pickingRuleService", { enumerable: true, get: function () { return service_5.pickingRuleService; } });
+var service_5 = require("./modules/storeReplenishOrder/service");
+Object.defineProperty(exports, "storeReplenishOrderService", { enumerable: true, get: function () { return service_5.storeReplenishOrderService; } });
+var service_6 = require("./modules/productStatistics/service");
+Object.defineProperty(exports, "productStatisticsService", { enumerable: true, get: function () { return service_6.productStatisticsService; } });
+var service_7 = require("./modules/pickingRule/service");
+Object.defineProperty(exports, "pickingRuleService", { enumerable: true, get: function () { return service_7.pickingRuleService; } });
 var types_1 = require("./modules/pickingRule/types");
 Object.defineProperty(exports, "PickingRuleTypes", { enumerable: true, get: function () { return types_1.PickingRuleTypes; } });
 var enum_1 = require("./enum");
 Object.defineProperty(exports, "ENUM", { enumerable: true, get: function () { return enum_1.ENUM; } });
-var service_6 = require("./modules/logistics/service");
-Object.defineProperty(exports, "logisticsService", { enumerable: true, get: function () { return service_6.logisticsService; } });
+var service_8 = require("./modules/logistics/service");
+Object.defineProperty(exports, "logisticsService", { enumerable: true, get: function () { return service_8.logisticsService; } });
+var service_9 = require("./modules/storeProductFulfill/service");
+Object.defineProperty(exports, "storeProductFulfillService", { enumerable: true, get: function () { return service_9.storeProductFulfillService; } });
 var enum_2 = require("./enum");
 Object.defineProperty(exports, "DEMO_ENUM", { enumerable: true, get: function () { return enum_2.ENUM; } });
 // 服务.模块.枚举名称.枚举值 示例: DEMO_ENUM.ORDER_ENUM.STATUS.PENDING

package/modules/allocationOrder/types.d.ts

@@ -94,6 +94,7 @@ export declare namespace AllocationOrderTypes {
             shippedAtStart?: number;
             shippedAtEnd?: number;
             productIds?: string[];
+            skuIds?: string[];
             skuCodes?: string[];
             warehouseIds?: string[];
             storeIds?: string[];
@@ -108,6 +109,7 @@ export declare namespace AllocationOrderTypes {
             pageIndex: number;
             pageSize: number;
             productIds?: string[];
+            skuIds?: string[];
             skuCodes?: string[];
             minRemainNum?: number;
             maxRemainNum?: number;
@@ -159,6 +161,7 @@ export declare namespace AllocationOrderTypes {
             shippedAtStart?: number;
             shippedAtEnd?: number;
             productIds?: string[];
+            skuIds?: string[];
             skuCodes?: string[];
             storeIds?: string[];
             warehouseIds?: string[];
@@ -246,8 +249,8 @@ export declare namespace AllocationOrderTypes {
             list: Entity.AllocationOrderWithExtension[];
             totalCount: number;
             pendingCount: number;
-            partialCount: number;
             shippedCount: number;
+            invalidCount: number;
         }
         /**
          * 获取配货单详情响应

package/modules/logistics/types.d.ts

@@ -55,6 +55,14 @@ export declare namespace Service {
         skuCode?: string;
         /** 规格名称（来自ProductServiceTypes） */
         specName?: string;
+        /** 商品分类 */
+        classification?: string;
+        /** 储藏方式 */
+        storageMethod?: string;
+        /** 配货方式 */
+        dispatchType?: string;
+        /** 结算分类 */
+        pickType?: string;
         /** 应配货量 */
         expectedQuantity?: number;
         /** 仓库实发 */
@@ -66,10 +74,6 @@ export declare namespace Service {
     interface StockInOrder {
         /** 入库单ID */
         id: string;
-        /** 物流信息 */
-        logistics: string;
-        /** 供应商名称 */
-        supplyName: string;
         /** 仓库ID */
         warehouseId: string;
         /** 门店ID */
@@ -80,8 +84,6 @@ export declare namespace Service {
         creator: string;
         /** 更新人 */
         updater: string;
-        /** 类型：WAREHOUSE:仓库, STORE:门店 */
-        type: string;
         /** 状态 PENDING:待收货, PARTIAL:部分收货, RECEIVED:已收货, EARLY_COMPLETED:提前完成 */
         status: string;
         /** 物流状态：0-没有物流信息、1-已入库、2-已到店、3-配送中 */
@@ -102,7 +104,7 @@ export declare namespace Service {
         createdAt: number;
         /** 更新时间 */
         updatedAt: number;
-        /** 批次编码（从 EcsDistributionBatch 表查询，targetId 对应入库单 id） */
+        /** 批次编码（入库单id） */
         code?: string;
         /** 商品列表（只包含必要字段：productId, productName, productImage） */
         products?: ProductBasicInfo[];

package/modules/pickingRule/types.d.ts

@@ -68,7 +68,7 @@ export declare namespace PickingRuleTypes {
         /** 编辑拣货规则 */
         interface UpdatePickingRule {
             warehouseId?: string;
-            skuCode: string;
+            skuId: string;
             weekDays?: number[];
             customDate?: {
                 startTime: number;
@@ -79,7 +79,7 @@ export declare namespace PickingRuleTypes {
         /** 批量删除拣货规则 */
         interface DeletePickingRule {
             warehouseId?: string;
-            skuCodes: string[];
+            skuIds: string[];
             updatedName: string;
         }
         /** 保存订单来源规则 */

package/modules/preAllocationOrder/service.d.ts

@@ -54,6 +54,14 @@ declare class PreAllocationOrderService extends BaseService implements PreAlloca
      * 批量修改配货数量
      */
     batchUpdatePickingNum(request: PreAllocationOrderTypes.Request.BatchUpdatePickingNum): Promise<PreAllocationOrderTypes.Response.BatchUpdatePickingNum>;
+    /**
+     * 批量填写配货备注
+     */
+    batchUpdatePickingRemark(request: PreAllocationOrderTypes.Request.BatchUpdatePickingRemark): Promise<PreAllocationOrderTypes.Response.BatchUpdatePickingRemark>;
+    /**
+     * 批量添加商品到预配货单
+     */
+    batchAddProducts(request: PreAllocationOrderTypes.Request.BatchAddProducts): Promise<PreAllocationOrderTypes.Response.BatchAddProducts>;
     /**
      * 查询预配货单商品明细
      */
@@ -61,7 +69,7 @@ declare class PreAllocationOrderService extends BaseService implements PreAlloca
     /**
      * 导出预配货单
      */
-    exportPreAllocationOrders(request: PreAllocationOrderTypes.Request.ExportPreAllocationOrders): Promise<PreAllocationOrderTypes.Response.ExportPreAllocationOrders>;
+    exportExcel(request: PreAllocationOrderTypes.Request.ExportPreAllocationOrders): Promise<PreAllocationOrderTypes.Response.ExportPreAllocationOrders>;
     /**
      * 删除预配货单
      */

package/modules/preAllocationOrder/service.js

@@ -99,6 +99,18 @@ let PreAllocationOrderService = class PreAllocationOrderService extends BaseServ
     batchUpdatePickingNum(request) {
         return (0, http_1.callApi)(this.getApiUrl(this.batchUpdatePickingNum), request);
     }
+    /**
+     * 批量填写配货备注
+     */
+    batchUpdatePickingRemark(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.batchUpdatePickingRemark), request);
+    }
+    /**
+     * 批量添加商品到预配货单
+     */
+    batchAddProducts(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.batchAddProducts), request);
+    }
     /**
      * 查询预配货单商品明细
      */
@@ -108,8 +120,8 @@ let PreAllocationOrderService = class PreAllocationOrderService extends BaseServ
     /**
      * 导出预配货单
      */
-    exportPreAllocationOrders(request) {
-        return (0, http_1.callApi)(this.getApiUrl(this.exportPreAllocationOrders), request);
+    exportExcel(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.exportExcel), request);
     }
     /**
      * 删除预配货单
@@ -182,14 +194,22 @@ __decorate([
     (0, tsoa_1.Post)('batch-update-picking-num'),
     __param(0, (0, tsoa_1.Body)())
 ], PreAllocationOrderService.prototype, "batchUpdatePickingNum", null);
+__decorate([
+    (0, tsoa_1.Post)('batch-update-picking-remark'),
+    __param(0, (0, tsoa_1.Body)())
+], PreAllocationOrderService.prototype, "batchUpdatePickingRemark", null);
+__decorate([
+    (0, tsoa_1.Post)('batch-add-products'),
+    __param(0, (0, tsoa_1.Body)())
+], PreAllocationOrderService.prototype, "batchAddProducts", null);
 __decorate([
     (0, tsoa_1.Post)('details'),
     __param(0, (0, tsoa_1.Body)())
 ], PreAllocationOrderService.prototype, "details", null);
 __decorate([
-    (0, tsoa_1.Post)('export'),
+    (0, tsoa_1.Post)('export-excel'),
     __param(0, (0, tsoa_1.Body)())
-], PreAllocationOrderService.prototype, "exportPreAllocationOrders", null);
+], PreAllocationOrderService.prototype, "exportExcel", null);
 __decorate([
     (0, tsoa_1.Post)('delete'),
     __param(0, (0, tsoa_1.Body)())

package/modules/preAllocationOrder/types.d.ts

@@ -161,6 +161,7 @@ export declare namespace PreAllocationOrderTypes {
         interface IInventoryWarningList {
             warehouseIds: string[];
             productIds?: string[];
+            skuIds?: string[];
             skuCodes?: string[];
             pageIndex: number;
             pageSize: number;
@@ -196,7 +197,8 @@ export declare namespace PreAllocationOrderTypes {
         }
         /** 搜索商品 */
         interface SearchProducts {
-            batchIds?: string[];
+            warehouseId: string;
+            batchNos?: string[];
             preAllocationOrderIds?: string[];
             productIds?: string[];
             skuCodes?: string[];
@@ -205,15 +207,35 @@ export declare namespace PreAllocationOrderTypes {
         }
         /** 批量修改配货数量 */
         interface BatchUpdatePickingNum {
-            preAllocationOrderIds: string[];
+            warehouseId: string;
+            batchNos?: string[];
+            preAllocationOrderIds?: string[];
             adjustments: Array<{
-                skuCode: string;
-                adjustmentType: 'ADD' | 'REDUCE';
+                skuId: string;
+                adjustmentType: 'ADD' | 'REDUCE' | 'SET';
                 adjustmentNum: number;
                 adjustmentReason: string;
             }>;
             operator: string;
         }
+        /** 批量填写配货备注 */
+        interface BatchUpdatePickingRemark {
+            warehouseId: string;
+            batchNos?: string[];
+            preAllocationOrderIds?: string[];
+            pickingRemark: string;
+            operator: string;
+        }
+        /** 批量添加商品到预配货单 */
+        interface BatchAddProducts {
+            preAllocationOrderId: string;
+            products: Array<{
+                skuId: string;
+                pickingNum: number;
+                pickingRemark?: string;
+            }>;
+            operator: string;
+        }
         /** 查询预配货单商品明细 */
         interface GetPreAllocationOrderDetails {
             preAllocationOrderId: string;
@@ -224,6 +246,9 @@ export declare namespace PreAllocationOrderTypes {
         }
         /** 导出预配货单 */
         interface ExportPreAllocationOrders {
+            warehouseId?: string;
+            batchNos?: string[];
+            preAllocationOrderIds?: string[];
             filters?: {
                 batchNos?: string[];
                 warehouseIds?: string[];
@@ -235,8 +260,6 @@ export declare namespace PreAllocationOrderTypes {
                 batchStatus?: number;
                 status?: number;
             };
-            batchIds?: string[];
-            preAllocationOrderIds?: string[];
             pageIndex?: number;
             pageSize?: number;
         }
@@ -354,6 +377,22 @@ export declare namespace PreAllocationOrderTypes {
             message: string;
             data: null;
         }
+        /** 批量填写配货备注响应 */
+        interface BatchUpdatePickingRemark {
+            code: number;
+            message: string;
+            data: null;
+        }
+        /** 批量添加商品到预配货单响应 */
+        interface BatchAddProducts {
+            code: number;
+            message: string;
+            data: {
+                addedCount: number;
+                updatedCount: number;
+                skippedCount: number;
+            };
+        }
         /** 查询预配货单商品明细响应 */
         interface GetPreAllocationOrderDetails {
             code: number;
@@ -443,7 +482,7 @@ export declare namespace PreAllocationOrderTypes {
         /** 查询预配货单商品明细 */
         details(request: PreAllocationOrderTypes.Request.GetPreAllocationOrderDetails): Promise<PreAllocationOrderTypes.Response.GetPreAllocationOrderDetails>;
         /** 导出预配货单 */
-        exportPreAllocationOrders(request: PreAllocationOrderTypes.Request.ExportPreAllocationOrders): Promise<PreAllocationOrderTypes.Response.ExportPreAllocationOrders>;
+        exportExcel(request: PreAllocationOrderTypes.Request.ExportPreAllocationOrders): Promise<PreAllocationOrderTypes.Response.ExportPreAllocationOrders>;
         /** 删除预配货单 */
         delete(request: PreAllocationOrderTypes.Request.DeletePreAllocationOrder): Promise<PreAllocationOrderTypes.Response.DeletePreAllocationOrder>;
         /** 删除预配货单明细 */

package/modules/productStatistics/service.d.ts

@@ -0,0 +1,8 @@
+import { ProductStatisticsTypes } from './types';
+import BaseService from '../BaseService';
+declare class ProductStatisticsService extends BaseService implements ProductStatisticsTypes.ProductStatisticsController {
+    protected prefixUrl: string;
+    getStockInProductStats(request: ProductStatisticsTypes.Request.GetStockInProductStats): Promise<ProductStatisticsTypes.Response.GetStockInProductStats>;
+}
+export declare const productStatisticsService: ProductStatisticsService;
+export default productStatisticsService;

package/modules/productStatistics/service.js

@@ -0,0 +1,37 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.productStatisticsService = void 0;
+const tsoa_1 = require("tsoa");
+const http_1 = require("../../utils/http");
+const BaseService_1 = __importDefault(require("../BaseService"));
+let ProductStatisticsService = class ProductStatisticsService extends BaseService_1.default {
+    constructor() {
+        super(...arguments);
+        this.prefixUrl = '/product-statistics';
+    }
+    getStockInProductStats(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.getStockInProductStats), request);
+    }
+};
+__decorate([
+    (0, tsoa_1.Post)('get-stock-in-product-stats'),
+    __param(0, (0, tsoa_1.Body)())
+], ProductStatisticsService.prototype, "getStockInProductStats", null);
+ProductStatisticsService = __decorate([
+    (0, tsoa_1.Route)('ProductStatistics'),
+    (0, tsoa_1.Tags)('productStatistics')
+], ProductStatisticsService);
+exports.productStatisticsService = new ProductStatisticsService();
+exports.default = exports.productStatisticsService;

package/modules/productStatistics/types.d.ts

@@ -0,0 +1,39 @@
+export declare namespace ProductStatisticsTypes {
+    /** 实体定义 */
+    namespace Entity {
+        /** 入库单商品统计项 */
+        interface StockInProductStat {
+            productId: string;
+            productName: string;
+            price: number;
+            productImage: string;
+            classification: string;
+            storageMethod: string;
+            dispatchType: string;
+            pickType: string;
+        }
+    }
+    /** 请求定义 */
+    namespace Request {
+        /** 查询入库单商品统计请求 */
+        interface GetStockInProductStats {
+            storeId: string;
+            updatedAtStart?: number;
+            updatedAtEnd?: number;
+            pageIndex: number;
+            pageSize: number;
+        }
+    }
+    /** 响应定义 */
+    namespace Response {
+        /** 查询入库单商品统计响应 */
+        interface GetStockInProductStats {
+            products: Entity.StockInProductStat[];
+        }
+    }
+    /** ProductStatistics Controller 接口定义 */
+    interface ProductStatisticsController {
+        /** 查询入库单商品统计 */
+        getStockInProductStats(request: ProductStatisticsTypes.Request.GetStockInProductStats): Promise<ProductStatisticsTypes.Response.GetStockInProductStats>;
+    }
+}

package/modules/productStatistics/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/modules/storeProductFulfill/service.d.ts

@@ -0,0 +1,9 @@
+import { StoreProductFulfillTypes } from './types';
+import BaseService from '../BaseService';
+declare class StoreProductFulfillService extends BaseService implements StoreProductFulfillTypes.StoreProductFulfillController {
+    protected prefixUrl: string;
+    getStoreProducts(request: StoreProductFulfillTypes.Request.GetStoreProducts): Promise<StoreProductFulfillTypes.Response.GetStoreProducts>;
+    getProductFulfillDetails(request: StoreProductFulfillTypes.Request.GetProductFulfillDetails): Promise<StoreProductFulfillTypes.Response.GetProductFulfillDetails>;
+}
+export declare const storeProductFulfillService: StoreProductFulfillService;
+export default storeProductFulfillService;

package/modules/storeProductFulfill/service.js

@@ -0,0 +1,44 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storeProductFulfillService = void 0;
+const tsoa_1 = require("tsoa");
+const http_1 = require("../../utils/http");
+const BaseService_1 = __importDefault(require("../BaseService"));
+let StoreProductFulfillService = class StoreProductFulfillService extends BaseService_1.default {
+    constructor() {
+        super(...arguments);
+        this.prefixUrl = '/store-product-fulfill';
+    }
+    getStoreProducts(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.getStoreProducts), request);
+    }
+    getProductFulfillDetails(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.getProductFulfillDetails), request);
+    }
+};
+__decorate([
+    (0, tsoa_1.Post)('get-store-products'),
+    __param(0, (0, tsoa_1.Body)())
+], StoreProductFulfillService.prototype, "getStoreProducts", null);
+__decorate([
+    (0, tsoa_1.Post)('get-product-fulfill-details'),
+    __param(0, (0, tsoa_1.Body)())
+], StoreProductFulfillService.prototype, "getProductFulfillDetails", null);
+StoreProductFulfillService = __decorate([
+    (0, tsoa_1.Route)('StoreProductFulfill'),
+    (0, tsoa_1.Tags)('storeProductFulfill')
+], StoreProductFulfillService);
+exports.storeProductFulfillService = new StoreProductFulfillService();
+exports.default = exports.storeProductFulfillService;

package/modules/storeProductFulfill/types.d.ts

@@ -0,0 +1,91 @@
+export declare namespace StoreProductFulfillTypes {
+    /** 门店商品履约商品项 */
+    interface StoreProductItem {
+        productId: string;
+        productName: string;
+        productImage: string;
+        skuId: string;
+        skuCode: string;
+        specName: string;
+        storeId: string;
+        storeName: string;
+        price: number;
+        classification: string;
+        storageMethod: string;
+        pickType: string;
+        dispatchType: string;
+    }
+    /** 入库记录项 */
+    interface StockInItem {
+        allocationOrderId: string;
+        stockInOrderId: string;
+        stockInTime: number;
+        stockInQty: number;
+    }
+    /** 补货提示项 */
+    interface ReplenishTipItem {
+        replenishOrderId: string;
+        replenishQty: number;
+        type: string;
+    }
+    /** 人工调整提示项 */
+    interface ManualAdjustTipItem {
+        adjustReason: string;
+        adjustQty: number;
+        operator: string;
+    }
+    /** 商品履约明细项 */
+    interface ProductFulfillDetailItem {
+        batchNo: string;
+        plannedQty: number;
+        salesQty: number;
+        replenishQty: number;
+        unVerifiedReturnQty: number;
+        manualAdjustQty: number;
+        stockInQty: number;
+        stockInList: StockInItem[];
+        replenishTips: ReplenishTipItem[];
+        manualAdjustTips: ManualAdjustTipItem[];
+    }
+    /** 请求定义 */
+    namespace Request {
+        /** 获取门店入库商品列表请求（按 skuId 合并） */
+        interface GetStoreProducts {
+            storeIds?: string[];
+            productIds?: string[];
+            skuIds?: string[];
+            skuCodes?: string[];
+            pageIndex: number;
+            pageSize: number;
+        }
+        /** 获取商品履约明细请求 */
+        interface GetProductFulfillDetails {
+            storeId: string;
+            skuId: string;
+            productId: string;
+            batchNo?: string;
+            replenishOrderId?: string;
+            allocationOrderId?: string;
+        }
+    }
+    /** 响应定义 */
+    namespace Response {
+        /** 获取门店入库商品列表响应 */
+        interface GetStoreProducts {
+            total: number;
+            list: StoreProductItem[];
+        }
+        /** 获取商品履约明细响应 */
+        interface GetProductFulfillDetails {
+            productInfo: StoreProductItem;
+            list: ProductFulfillDetailItem[];
+        }
+    }
+    /** StoreProductFulfill Controller 接口定义 */
+    interface StoreProductFulfillController {
+        /** 获取门店入库商品列表（按 skuId 合并） */
+        getStoreProducts(request: Request.GetStoreProducts): Promise<Response.GetStoreProducts>;
+        /** 获取商品履约明细 */
+        getProductFulfillDetails(request: Request.GetProductFulfillDetails): Promise<Response.GetProductFulfillDetails>;
+    }
+}

package/modules/storeProductFulfill/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/modules/storeReplenishOrder/service.d.ts

@@ -0,0 +1,43 @@
+import { StoreReplenishOrderTypes } from './types';
+import BaseService from '../BaseService';
+declare class StoreReplenishOrderService extends BaseService implements StoreReplenishOrderTypes.StoreReplenishOrderController {
+    protected prefixUrl: string;
+    /**
+     * 申请补货
+     */
+    applyReplenish(request: StoreReplenishOrderTypes.Request.ApplyReplenish): Promise<void>;
+    /**
+     * 撤销补货申请
+     */
+    cancelReplenish(request: StoreReplenishOrderTypes.Request.CancelReplenish): Promise<void>;
+    /**
+     * 查询补货申请历史
+     */
+    getReplenishHistory(request: StoreReplenishOrderTypes.Request.GetReplenishHistory): Promise<StoreReplenishOrderTypes.Response.GetReplenishHistory>;
+    /**
+     * 获取补货单详情
+     */
+    getReplenishDetail(request: StoreReplenishOrderTypes.Request.GetReplenishDetail): Promise<StoreReplenishOrderTypes.Response.GetReplenishDetail>;
+    /**
+     * 获取补货审批列表
+     */
+    getApprovalList(request: StoreReplenishOrderTypes.Request.GetApprovalList): Promise<StoreReplenishOrderTypes.Response.GetApprovalList>;
+    /**
+     * 批量拒绝补货申请
+     */
+    batchReject(request: StoreReplenishOrderTypes.Request.BatchReject): Promise<void>;
+    /**
+     * 审批通过补货申请
+     */
+    approveReplenish(request: StoreReplenishOrderTypes.Request.ApproveReplenish): Promise<void>;
+    /**
+     * 撤销审批
+     */
+    revokeApproval(request: StoreReplenishOrderTypes.Request.RevokeApproval): Promise<void>;
+    /**
+     * 更新审批理由
+     */
+    updateApprovalReason(request: StoreReplenishOrderTypes.Request.UpdateApprovalReason): Promise<void>;
+}
+export declare const storeReplenishOrderService: StoreReplenishOrderService;
+export default storeReplenishOrderService;

package/modules/storeReplenishOrder/service.js

@@ -0,0 +1,120 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storeReplenishOrderService = void 0;
+const tsoa_1 = require("tsoa");
+const http_1 = require("../../utils/http");
+const BaseService_1 = __importDefault(require("../BaseService"));
+let StoreReplenishOrderService = class StoreReplenishOrderService extends BaseService_1.default {
+    constructor() {
+        super(...arguments);
+        this.prefixUrl = '/store-replenish-order';
+    }
+    /**
+     * 申请补货
+     */
+    applyReplenish(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.applyReplenish), request);
+    }
+    /**
+     * 撤销补货申请
+     */
+    cancelReplenish(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.cancelReplenish), request);
+    }
+    /**
+     * 查询补货申请历史
+     */
+    getReplenishHistory(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.getReplenishHistory), request);
+    }
+    /**
+     * 获取补货单详情
+     */
+    getReplenishDetail(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.getReplenishDetail), request);
+    }
+    /**
+     * 获取补货审批列表
+     */
+    getApprovalList(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.getApprovalList), request);
+    }
+    /**
+     * 批量拒绝补货申请
+     */
+    batchReject(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.batchReject), request);
+    }
+    /**
+     * 审批通过补货申请
+     */
+    approveReplenish(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.approveReplenish), request);
+    }
+    /**
+     * 撤销审批
+     */
+    revokeApproval(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.revokeApproval), request);
+    }
+    /**
+     * 更新审批理由
+     */
+    updateApprovalReason(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.updateApprovalReason), request);
+    }
+};
+__decorate([
+    (0, tsoa_1.Post)('apply-replenish'),
+    __param(0, (0, tsoa_1.Body)())
+], StoreReplenishOrderService.prototype, "applyReplenish", null);
+__decorate([
+    (0, tsoa_1.Post)('cancel-replenish'),
+    __param(0, (0, tsoa_1.Body)())
+], StoreReplenishOrderService.prototype, "cancelReplenish", null);
+__decorate([
+    (0, tsoa_1.Post)('get-replenish-history'),
+    __param(0, (0, tsoa_1.Body)())
+], StoreReplenishOrderService.prototype, "getReplenishHistory", null);
+__decorate([
+    (0, tsoa_1.Post)('get-replenish-detail'),
+    __param(0, (0, tsoa_1.Body)())
+], StoreReplenishOrderService.prototype, "getReplenishDetail", null);
+__decorate([
+    (0, tsoa_1.Post)('get-approval-list'),
+    __param(0, (0, tsoa_1.Body)())
+], StoreReplenishOrderService.prototype, "getApprovalList", null);
+__decorate([
+    (0, tsoa_1.Post)('batch-reject'),
+    __param(0, (0, tsoa_1.Body)())
+], StoreReplenishOrderService.prototype, "batchReject", null);
+__decorate([
+    (0, tsoa_1.Post)('approve-replenish'),
+    __param(0, (0, tsoa_1.Body)())
+], StoreReplenishOrderService.prototype, "approveReplenish", null);
+__decorate([
+    (0, tsoa_1.Post)('revoke-approval'),
+    __param(0, (0, tsoa_1.Body)())
+], StoreReplenishOrderService.prototype, "revokeApproval", null);
+__decorate([
+    (0, tsoa_1.Post)('update-approval-reason'),
+    __param(0, (0, tsoa_1.Body)())
+], StoreReplenishOrderService.prototype, "updateApprovalReason", null);
+StoreReplenishOrderService = __decorate([
+    (0, tsoa_1.Route)('StoreReplenishOrder'),
+    (0, tsoa_1.Tags)('storeReplenishOrder')
+], StoreReplenishOrderService);
+exports.storeReplenishOrderService = new StoreReplenishOrderService();
+exports.default = exports.storeReplenishOrderService;

package/modules/storeReplenishOrder/types.d.ts

@@ -0,0 +1,197 @@
+export declare namespace StoreReplenishOrderTypes {
+    /** 实体定义 */
+    namespace Entity {
+        /** 媒体文件 */
+        interface MediaFile {
+            url: string;
+            type: string;
+        }
+        /** 补货申请历史列表项（轻量级） */
+        interface ReplenishHistoryItem {
+            id: string;
+            status: string;
+            productId: string;
+            productName: string;
+            productImage?: string;
+            skuId: string;
+            skuCode: string;
+            specName?: string;
+            createdAt: number;
+            applyNum: number;
+        }
+        /** 补货审批列表项 */
+        interface ReplenishApprovalItem {
+            id: string;
+            applyType: string;
+            storeName: string;
+            productImage?: string;
+            productName: string;
+            productId: string;
+            skuId: string;
+            specName: string;
+            skuCode: string;
+            dispatchType: string;
+            applyNum: number;
+            approvalNum: number;
+            status: string;
+            createdAt: number;
+            approvalTime?: number;
+        }
+    }
+    /** 请求参数定义 */
+    namespace Request {
+        /** 申请补货 */
+        interface ApplyReplenish {
+            productId: string;
+            skuId: string;
+            stockInOrderId?: string;
+            applyNum: number;
+            applyReason: string;
+            mediaFiles?: Entity.MediaFile[];
+            operator: string;
+            storeId: string;
+        }
+        /** 撤销补货申请 */
+        interface CancelReplenish {
+            id: string;
+        }
+        /** 查询补货申请历史 */
+        interface GetReplenishHistory {
+            storeId: string;
+            status?: string;
+            productName?: string;
+            productIds?: string[];
+            createdAtStart?: number;
+            createdAtEnd?: number;
+            pageIndex?: number;
+            pageSize?: number;
+        }
+        /** 获取补货单详情 */
+        interface GetReplenishDetail {
+            id: string;
+        }
+        /** 获取补货审批列表 */
+        interface GetApprovalList {
+            pageIndex?: number;
+            pageSize?: number;
+            storeIds?: string[];
+            productIds?: string[];
+            skuIds?: string[];
+            skuCodes?: string[];
+            createdAtStart?: number;
+            createdAtEnd?: number;
+            applyType?: string;
+            ids?: string[];
+            status?: string;
+            approvalTimeStart?: number;
+            approvalTimeEnd?: number;
+        }
+        /** 批量拒绝补货申请 */
+        interface BatchReject {
+            ids: string[];
+            reason: string;
+            operator: string;
+        }
+        /** 审批通过补货申请 */
+        interface ApproveReplenish {
+            id: string;
+            status: string;
+            lossType?: string;
+            approvalNum?: number;
+            approvalReason: string;
+            operator: string;
+        }
+        /** 更新审批理由 */
+        interface UpdateApprovalReason {
+            id: string;
+            approvalReason: string;
+            operator: string;
+        }
+        /** 撤销审批 */
+        interface RevokeApproval {
+            id: string;
+            reason: string;
+            operator: string;
+        }
+    }
+    /** 响应结果定义 */
+    namespace Response {
+        /** 查询补货申请历史响应 */
+        interface GetReplenishHistory {
+            list: Entity.ReplenishHistoryItem[];
+            total: number;
+        }
+        /** 获取补货审批列表响应 */
+        interface GetApprovalList {
+            list: Entity.ReplenishApprovalItem[];
+            total: number;
+            totalCount: number;
+            pendingCount: number;
+            rejectCount: number;
+            approveCount: number;
+        }
+        /** 获取补货单详情响应 */
+        interface GetReplenishDetail {
+            /** 补货单基础信息 */
+            baseInfo: {
+                id: string;
+                status: string;
+                createdAt: number;
+                storeId: string;
+                storeName: string;
+            };
+            /** 商品信息 */
+            productInfo: {
+                productId: string;
+                skuId: string;
+                skuCode: string;
+                productName: string;
+                dispatchType: string;
+                specName: string;
+                productImage?: string;
+            };
+            /** 申请信息 */
+            applyInfo: {
+                applyReason: string;
+                applyNum: number;
+                mediaFiles?: Entity.MediaFile[];
+            };
+            /** 审批信息 */
+            approvalInfo?: {
+                approvalReason?: string;
+                lossType?: string;
+                approvalNum?: number;
+                batchNo?: string;
+                approvalTime?: number;
+            };
+            /** 审批记录 */
+            approvalRecords?: Array<{
+                approver: string;
+                approvalTime: number;
+                reason: string;
+                status: string;
+            }>;
+        }
+    }
+    /** StoreReplenishOrder Controller 接口定义 */
+    interface StoreReplenishOrderController {
+        /** 申请补货 */
+        applyReplenish(request: StoreReplenishOrderTypes.Request.ApplyReplenish): Promise<void>;
+        /** 撤销补货申请 */
+        cancelReplenish(request: StoreReplenishOrderTypes.Request.CancelReplenish): Promise<void>;
+        /** 查询补货申请历史 */
+        getReplenishHistory(request: StoreReplenishOrderTypes.Request.GetReplenishHistory): Promise<StoreReplenishOrderTypes.Response.GetReplenishHistory>;
+        /** 获取补货单详情 */
+        getReplenishDetail(request: StoreReplenishOrderTypes.Request.GetReplenishDetail): Promise<StoreReplenishOrderTypes.Response.GetReplenishDetail>;
+        /** 获取补货审批列表 */
+        getApprovalList(request: StoreReplenishOrderTypes.Request.GetApprovalList): Promise<StoreReplenishOrderTypes.Response.GetApprovalList>;
+        /** 批量拒绝补货申请 */
+        batchReject(request: StoreReplenishOrderTypes.Request.BatchReject): Promise<void>;
+        /** 审批通过补货申请 */
+        approveReplenish(request: StoreReplenishOrderTypes.Request.ApproveReplenish): Promise<void>;
+        /** 撤销审批 */
+        revokeApproval(request: StoreReplenishOrderTypes.Request.RevokeApproval): Promise<void>;
+        /** 更新审批理由 */
+        updateApprovalReason(request: StoreReplenishOrderTypes.Request.UpdateApprovalReason): Promise<void>;
+    }
+}

package/modules/storeReplenishOrder/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/modules/storeStockIn/types.d.ts

@@ -71,6 +71,7 @@ export declare namespace StoreStockInTypes {
             pageIndex: number;
             pageSize: number;
             productIds?: string[];
+            skuIds?: string[];
             skuCodes?: string[];
         }
         /** 查询入库单列表请求 */
@@ -84,6 +85,7 @@ export declare namespace StoreStockInTypes {
             receivedTimeStart?: number;
             receivedTimeEnd?: number;
             productIds?: string[];
+            skuIds?: string[];
             skuCodes?: string[];
             storeIds?: string[];
             warehouseIds?: string[];
@@ -112,6 +114,7 @@ export declare namespace StoreStockInTypes {
             receivedTimeStart?: number;
             receivedTimeEnd?: number;
             productIds?: string[];
+            skuIds?: string[];
             skuCodes?: string[];
             storeIds?: string[];
             warehouseIds?: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@be-link/ecommerce-plan-allocation-service-node-sdk",
-  "version": "0.0.39",
+  "version": "0.0.40",
   "description": "EcommercePlanAllocationService Node.js SDK",
   "main": "index.js",
   "types": "index.d.ts",