import { request } from "./request";
import type { MaterialItem, PageResult } from "./basic-data";
import type { UserSimple } from "./purchase";

export interface Warehouse {
  id?: number;
  code?: string;
  name?: string;
  address?: string;
  area?: number;
  chargeUserId?: number;
  chargeUserName?: string;
  frozen?: boolean;
  remark?: string;
  createTime?: string;
}

export interface MaterialStock {
  id?: number;
  itemTypeId?: number;
  itemId?: number;
  itemCode?: string;
  itemName?: string;
  specification?: string;
  unitMeasureName?: string;
  batchId?: number;
  batchCode?: string;
  warehouseId?: number;
  warehouseCode?: string;
  warehouseName?: string;
  locationId?: number;
  locationName?: string;
  areaId?: number;
  areaName?: string;
  vendorId?: number;
  vendorName?: string;
  quantity?: number;
  frozenQuantity?: number;
  reservedQuantity?: number;
  inTransitQuantity?: number;
  availableQuantity?: number;
  receiptTime?: string;
  frozen?: boolean;
  createTime?: string;
}
export interface Batch {
  id?: number;
  code?: string;
  itemId?: number;
  itemCode?: string;
  itemName?: string;
  itemSpecification?: string;
  unitName?: string;
  produceDate?: string;
  expireDate?: string;
  receiptDate?: string;
  vendorId?: number;
  vendorCode?: string;
  vendorName?: string;
  clientId?: number;
  clientCode?: string;
  clientName?: string;
  salesOrderCode?: string;
  purchaseOrderCode?: string;
  workOrderId?: number;
  workOrderCode?: string;
  workstationId?: number;
  workstationCode?: string;
  taskId?: number;
  taskCode?: string;
  toolId?: number;
  toolCode?: string;
  moldId?: number;
  lotNumber?: string;
  qualityStatus?: number;
  remark?: string;
}
export interface WarehouseLocation {
  id?: number;
  code?: string;
  name?: string;
  warehouseId?: number;
  warehouseName?: string;
  area?: number;
  frozen?: boolean;
  remark?: string;
  createTime?: string;
}
export interface WarehouseArea {
  id?: number;
  code?: string;
  name?: string;
  warehouseId?: number;
  warehouseName?: string;
  locationId?: number;
  locationName?: string;
  area?: number;
  maxLoad?: number;
  positionX?: number;
  positionY?: number;
  positionZ?: number;
  status?: number;
  frozen?: boolean;
  allowItemMixing?: boolean;
  allowBatchMixing?: boolean;
  remark?: string;
  createTime?: string;
}
export interface Transaction {
  id?: number;
  type?: number;
  typeName?: string;
  bizType?: number;
  bizTypeName?: string;
  bizCode?: string;
  itemId?: number;
  itemCode?: string;
  itemName?: string;
  quantity?: number;
  batchCode?: string;
  warehouseName?: string;
  locationName?: string;
  areaName?: string;
  transactionTime?: string;
  createTime?: string;
}

export interface ArrivalNotice {
  id?: number;
  code?: string;
  name?: string;
  purchaseOrderId?: number;
  purchaseOrderCode?: string;
  purchaseOrderNo?: string;
  vendorId?: number;
  vendorCode?: string;
  vendorName?: string;
  arrivalDate?: string;
  contactName?: string;
  contactTelephone?: string;
  status?: number;
  remark?: string;
  createTime?: string;
}

export interface ArrivalNoticeLine {
  id?: number;
  noticeId?: number;
  itemId?: number;
  itemCode?: string;
  itemName?: string;
  specification?: string;
  unitMeasureName?: string;
  arrivalQuantity?: number;
  qualifiedQuantity?: number;
  iqcCheckFlag?: boolean;
  iqcId?: number;
  iqcCode?: string;
  remark?: string;
}

export interface ItemReceipt {
  id?: number;
  code?: string;
  name?: string;
  iqcId?: number;
  iqcCode?: string;
  noticeId?: number;
  noticeCode?: string;
  purchaseOrderCode?: string;
  vendorId?: number;
  vendorName?: string;
  warehouseId?: number;
  warehouseName?: string;
  locationId?: number;
  locationName?: string;
  areaId?: number;
  areaName?: string;
  receiptDate?: string;
  status?: number;
  remark?: string;
  createTime?: string;
}

export interface ItemReceiptLine {
  id?: number;
  receiptId?: number;
  receiptCode?: string;
  arrivalNoticeLineId?: number;
  purchaseOrderCode?: string;
  itemId?: number;
  itemCode?: string;
  itemName?: string;
  specification?: string;
  unitMeasureName?: string;
  receivedQuantity?: number;
  batchId?: number;
  batchCode?: string;
  productionDate?: string;
  expireDate?: string;
  lotNumber?: string;
  iqcCheckFlag?: boolean;
  iqcId?: number;
  iqcCode?: string;
  remark?: string;
}

export interface ItemReceiptDetail {
  id?: number;
  receiptId?: number;
  lineId?: number;
  itemId?: number;
  itemCode?: string;
  itemName?: string;
  specification?: string;
  unitMeasureName?: string;
  batchId?: number;
  batchCode?: string;
  warehouseId?: number;
  warehouseName?: string;
  locationId?: number;
  locationName?: string;
  areaId?: number;
  areaName?: string;
  quantity?: number;
  remark?: string;
}

export interface ReturnVendor {
  id?: number;
  code?: string;
  name?: string;
  purchaseOrderId?: number;
  purchaseOrderCode?: string;
  vendorId?: number;
  vendorCode?: string;
  vendorName?: string;
  vendorNickname?: string;
  returnDate?: string;
  returnReason?: string;
  transportCode?: string;
  transportTelephone?: string;
  status?: number;
  remark?: string;
  createTime?: string;
}

export interface ReturnVendorLine {
  id?: number;
  returnId?: number;
  itemId?: number;
  itemCode?: string;
  itemName?: string;
  specification?: string;
  unitMeasureName?: string;
  quantity?: number;
  batchId?: number;
  batchCode?: string;
  remark?: string;
}

export interface ReturnVendorDetail {
  id?: number;
  returnId?: number;
  lineId?: number;
  materialStockId?: number;
  itemId?: number;
  quantity?: number;
  batchId?: number;
  batchCode?: string;
  warehouseId?: number;
  warehouseName?: string;
  locationId?: number;
  locationName?: string;
  areaId?: number;
  areaName?: string;
  remark?: string;
}

export interface WlsWorkOrder {
  id?: number;
  code?: string;
  name?: string;
  itemId?: number;
  itemCode?: string;
  itemName?: string;
  quantity?: number;
  status?: number;
  productionStatus?: number;
}
export interface WlsTask {
  id?: number;
  code?: string;
  name?: string;
  taskCode?: string;
  taskName?: string;
  workOrderId?: number;
  workstationId?: number;
  workstationCode?: string;
  workstationName?: string;
}
export interface WlsWorkstation {
  id?: number;
  code?: string;
  name?: string;
}
export interface Transfer {
  id?: number; code?: string; name?: string; type?: number; deliveryFlag?: boolean; recipientName?: string; recipientTelephone?: string; destinationAddress?: string; carrier?: string; shippingNumber?: string; confirmFlag?: boolean; transferDate?: string; status?: number; remark?: string; createTime?: string;
}
export interface TransferLine {
  id?: number; transferId?: number; materialStockId?: number; itemId?: number; itemCode?: string; itemName?: string; specification?: string; unitMeasureName?: string; quantity?: number; quantityMax?: number; batchId?: number; batchCode?: string; fromWarehouseId?: number; fromWarehouseName?: string; fromLocationId?: number; fromLocationName?: string; fromAreaId?: number; fromAreaName?: string; remark?: string;
}
export interface TransferDetail {
  id?: number; lineId?: number; transferId?: number; itemId?: number; itemCode?: string; itemName?: string; specification?: string; unitMeasureName?: string; quantity?: number; batchId?: number; batchCode?: string; toWarehouseId?: number; toWarehouseName?: string; toLocationId?: number; toLocationName?: string; toAreaId?: number; toAreaName?: string; remark?: string;
}
export interface StockTakingPlan {
  id?: number; code?: string; name?: string; type?: number; startTime?: string; endTime?: string; blindFlag?: boolean; frozen?: boolean; status?: number; remark?: string; createTime?: string;
}
export interface StockTakingPlanParam {
  id?: number; planId?: number; type?: number; valueId?: number; valueCode?: string; valueName?: string; remark?: string;
}
export interface StockTakingTask {
  id?: number; code?: string; name?: string; takingDate?: string; type?: number; userId?: number; userNickname?: string; planId?: number; planCode?: string; planName?: string; blindFlag?: boolean; frozen?: boolean; startTime?: string; endTime?: string; status?: number; remark?: string; createTime?: string;
}
export interface StockTakingTaskLine {
  id?: number; taskId?: number; materialStockId?: number; itemId?: number; itemCode?: string; itemName?: string; specification?: string; unitMeasureName?: string; batchId?: number; batchCode?: string; quantity?: number; takingQuantity?: number; differenceQuantity?: number; warehouseId?: number; warehouseName?: string; locationId?: number; locationName?: string; areaId?: number; areaName?: string; status?: number; remark?: string;
}
export interface StockTakingResult {
  id?: number; taskId?: number; lineId?: number; materialStockId?: number; itemId?: number; itemCode?: string; itemName?: string; specification?: string; unitMeasureName?: string; batchId?: number; batchCode?: string; warehouseId?: number; warehouseName?: string; locationId?: number; locationName?: string; areaId?: number; areaName?: string; quantity?: number; takingQuantity?: number; remark?: string; createTime?: string;
}
export interface WlsPackage {
  id?: number; code?: string; parentId?: number; packageDate?: string; salesOrderCode?: string; saleOrderId?: number; invoiceCode?: string; clientId?: number; clientCode?: string; clientName?: string; clientNickname?: string; length?: number; width?: number; height?: number; sizeUnitId?: number; sizeUnitName?: string; netWeight?: number; grossWeight?: number; weightUnitId?: number; weightUnitName?: string; inspectorUserId?: number; inspectorName?: string; status?: number; remark?: string; createTime?: string; children?: WlsPackage[];
}
export interface PackageLine {
  id?: number; packageId?: number; materialStockId?: number; itemId?: number; itemCode?: string; itemName?: string; specification?: string; unitMeasureName?: string; quantity?: number; workOrderId?: number; workOrderCode?: string; batchCode?: string; expireDate?: string; remark?: string; createTime?: string;
}
export interface SnGroup {
  uuid?: string; count?: number; itemId?: number; itemCode?: string; itemName?: string; specification?: string; unitName?: string; batchCode?: string; workOrderId?: number; createTime?: string;
}
export interface Sn {
  id?: number; uuid?: string; code?: string; itemId?: number; itemCode?: string; itemName?: string; specification?: string; unitName?: string; batchCode?: string; workOrderId?: number; createTime?: string;
}
export interface SnGenerate { itemId?: number; batchCode?: string; workOrderId?: number; count?: number; }
export interface BarcodeRecord {
  id?: number;
  configId?: number;
  format?: number;
  bizType?: number;
  content?: string;
  bizId?: number;
  bizCode?: string;
  bizName?: string;
  status?: number;
  remark?: string;
  createTime?: string;
}
export interface BarcodeConfig {
  id?: number;
  format?: number;
  bizType?: number;
  contentFormat?: string;
  contentExample?: string;
  autoGenerateFlag?: boolean;
  defaultTemplate?: string;
  status?: number;
  remark?: string;
  createTime?: string;
}
export interface WlsDocBase {
  id?: number;
  code?: string;
  name?: string;
  vendorId?: number;
  vendorCode?: string;
  vendorName?: string;
  workOrderId?: number;
  workOrderCode?: string;
  workOrderName?: string;
  taskId?: number;
  taskCode?: string;
  taskName?: string;
  workstationId?: number;
  workstationCode?: string;
  workstationName?: string;
  clientId?: number;
  clientCode?: string;
  clientName?: string;
  saleOrderId?: number;
  salesOrderCode?: string;
  saleOrderCode?: string;
  noticeId?: number;
  noticeCode?: string;
  sourceDocType?: string;
  sourceDocId?: number;
  sourceDocCode?: string;
  issueDate?: string;
  requiredTime?: string;
  receiptDate?: string;
  returnDate?: string;
  salesDate?: string;
  type?: number;
  recipientName?: string;
  recipientTelephone?: string;
  recipientAddress?: string;
  contactName?: string;
  contactTelephone?: string;
  contactAddress?: string;
  carrier?: string;
  shippingNumber?: string;
  returnReason?: string;
  status?: number;
  outStatus?: number;
  remark?: string;
  createTime?: string;
}
export interface WlsDocLine {
  id?: number;
  issueId?: number;
  receiptId?: number;
  noticeId?: number;
  salesId?: number;
  returnId?: number;
  issueLineId?: number;
  noticeLineId?: number;
  saleOrderItemId?: number;
  itemId?: number;
  mdmItemId?: number;
  materialStockId?: number;
  sourceDocLineId?: number;
  itemCode?: string;
  itemName?: string;
  specification?: string;
  unitMeasureName?: string;
  unitMeasure?: string;
  quantity?: number;
  quantityMax?: number;
  pickedQuantity?: number;
  outCount?: number;
  batchId?: number;
  batchCode?: string;
  productionDate?: string;
  expireDate?: string;
  lotNumber?: string;
  iqcCheckFlag?: boolean;
  oqcCheckFlag?: boolean;
  rqcCheckFlag?: boolean;
  qualityStatus?: number;
  rqcId?: number;
  warehouseId?: number;
  warehouseCode?: string;
  warehouseName?: string;
  locationId?: number;
  locationCode?: string;
  locationName?: string;
  areaId?: number;
  areaCode?: string;
  areaName?: string;
  remark?: string;
}
export interface WlsDocDetail {
  id?: number;
  issueId?: number;
  receiptId?: number;
  salesId?: number;
  returnId?: number;
  lineId?: number;
  materialStockId?: number;
  itemId?: number;
  itemCode?: string;
  itemName?: string;
  specification?: string;
  unitMeasureName?: string;
  quantity?: number;
  quantityMax?: number;
  batchId?: number;
  batchCode?: string;
  warehouseId?: number;
  warehouseName?: string;
  locationId?: number;
  locationName?: string;
  areaId?: number;
  areaName?: string;
  remark?: string;
}

type QueryValue = string | number | boolean | string[] | undefined;
const header = (accessToken: string) => ({ Authorization: `Bearer ${accessToken}` });
function query(params: Record<string, QueryValue>) {
  const content = Object.entries(params)
    .filter(([, value]) => value !== undefined && value !== "")
    .flatMap(([key, value]) => Array.isArray(value) ? value.map(item => `${encodeURIComponent(key)}=${encodeURIComponent(String(item))}`) : [`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`])
    .join("&");
  return content ? `?${content}` : "";
}
export function generateAutoCode(accessToken: string, ruleCode: string) {
  return request<string>("/mes/md/auto-code-record/generate", { method: "POST", data: { ruleCode }, header: header(accessToken) });
}
export function getWarehousePage(accessToken: string, params: { pageNo: number; pageSize: number; code?: string; name?: string; frozen?: boolean }) {
  return request<PageResult<Warehouse>>(`/mes/wm/warehouse/page${query(params)}`, { header: header(accessToken) });
}
export function getWarehouseSimpleList(accessToken: string) {
  return request<Warehouse[]>("/mes/wm/warehouse/simple-list", { header: header(accessToken) });
}
export function getWarehouse(accessToken: string, id: number) {
  return request<Warehouse>(`/mes/wm/warehouse/get${query({ id })}`, { header: header(accessToken) });
}
export function createWarehouse(accessToken: string, data: Warehouse) {
  return request<number>("/mes/wm/warehouse/create", { method: "POST", data, header: header(accessToken) });
}
export function updateWarehouse(accessToken: string, data: Warehouse) {
  return request<boolean>("/mes/wm/warehouse/update", { method: "PUT", data, header: header(accessToken) });
}
export function deleteWarehouse(accessToken: string, id: number) {
  return request<boolean>(`/mes/wm/warehouse/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}
export function getMaterialStockPage(accessToken: string, params: { pageNo: number; pageSize: number; itemTypeId?: number; itemId?: number; itemName?: string; vendorId?: number; vendorName?: string; batchId?: number; batchCode?: string; warehouseId?: number; locationId?: number; areaId?: number; frozen?: boolean; virtualFilter?: "all" | "exclude" | "only" }) {
  return request<PageResult<MaterialStock>>(`/mes/wm/material-stock/page${query(params)}`, { header: header(accessToken) });
}
export function getBatchPage(accessToken: string, params: { pageNo: number; pageSize: number; code?: string; itemId?: number; vendorId?: number; clientId?: number; workOrderId?: number; taskId?: number; workstationId?: number; toolId?: number; moldId?: number; salesOrderCode?: string; purchaseOrderCode?: string; lotNumber?: string; qualityStatus?: number; produceDate?: string[]; expireDate?: string[]; receiptDate?: string[] }) {
  return request<PageResult<Batch>>(`/mes/wm/batch/page${query(params)}`, { header: header(accessToken) });
}
export function updateMaterialStockFrozen(accessToken: string, data: { id: number; frozen: boolean }) {
  return request<boolean>("/mes/wm/material-stock/update-frozen", { method: "PUT", data, header: header(accessToken) });
}
export function getWarehouseLocationSimpleList(accessToken: string, warehouseId?: number) {
  return request<WarehouseLocation[]>(`/mes/wm/warehouse-location/simple-list${query({ warehouseId })}`, { header: header(accessToken) });
}
export function getWarehouseLocationPage(accessToken: string, params: { pageNo: number; pageSize: number; warehouseId?: number; name?: string }) {
  return request<PageResult<WarehouseLocation>>(`/mes/wm/warehouse-location/page${query(params)}`, { header: header(accessToken) });
}
export function getWarehouseLocation(accessToken: string, id: number) {
  return request<WarehouseLocation>(`/mes/wm/warehouse-location/get${query({ id })}`, { header: header(accessToken) });
}
export function createWarehouseLocation(accessToken: string, data: WarehouseLocation) {
  return request<number>("/mes/wm/warehouse-location/create", { method: "POST", data, header: header(accessToken) });
}
export function updateWarehouseLocation(accessToken: string, data: WarehouseLocation) {
  return request<boolean>("/mes/wm/warehouse-location/update", { method: "PUT", data, header: header(accessToken) });
}
export function deleteWarehouseLocation(accessToken: string, id: number) {
  return request<boolean>(`/mes/wm/warehouse-location/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}
export function getWarehouseAreaSimpleList(accessToken: string, locationId?: number) {
  return request<WarehouseArea[]>(`/mes/wm/warehouse-area/simple-list${query({ locationId })}`, { header: header(accessToken) });
}
export function getWarehouseAreaPage(accessToken: string, params: { pageNo: number; pageSize: number; locationId?: number; name?: string }) {
  return request<PageResult<WarehouseArea>>(`/mes/wm/warehouse-area/page${query(params)}`, { header: header(accessToken) });
}
export function getWarehouseArea(accessToken: string, id: number) {
  return request<WarehouseArea>(`/mes/wm/warehouse-area/get${query({ id })}`, { header: header(accessToken) });
}
export function createWarehouseArea(accessToken: string, data: WarehouseArea) {
  return request<number>("/mes/wm/warehouse-area/create", { method: "POST", data, header: header(accessToken) });
}
export function updateWarehouseArea(accessToken: string, data: WarehouseArea) {
  return request<boolean>("/mes/wm/warehouse-area/update", { method: "PUT", data, header: header(accessToken) });
}
export function deleteWarehouseArea(accessToken: string, id: number) {
  return request<boolean>(`/mes/wm/warehouse-area/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}
export function moveMaterialStock(accessToken: string, data: { materialStockId: number; toWarehouseId: number; toLocationId: number; toAreaId: number; quantity: number; remark?: string }) {
  return request<boolean>("/mes/wm/material-stock/move", { method: "POST", data, header: header(accessToken) });
}
export function adjustMaterialStockIn(accessToken: string, data: { itemId: number; warehouseId: number; locationId: number; areaId: number; batchId?: number; batchCode?: string; produceDate?: string; expireDate?: string; receiptDate?: string; vendorId?: number; purchaseOrderCode?: string; lotNumber?: string; qualityStatus?: string; quantity: number; reason?: string }) {
  return request<number>("/mes/wm/material-stock/adjust-in", { method: "POST", data, header: header(accessToken) });
}
export function adjustMaterialStockOut(accessToken: string, data: { itemId: number; warehouseId: number; locationId: number; areaId: number; batchId?: number; batchCode?: string; vendorId?: number; quantity: number; reason?: string }) {
  return request<number>("/mes/wm/material-stock/adjust-out", { method: "POST", data, header: header(accessToken) });
}
export function getTransactionPage(accessToken: string, params: { pageNo: number; pageSize: number; bizCode?: string }) {
  return request<PageResult<Transaction>>(`/mes/wm/transaction/page${query(params)}`, { header: header(accessToken) });
}
export function getTransferPage(accessToken: string, params: { pageNo: number; pageSize: number; code?: string; name?: string; type?: number; status?: number }) { return request<PageResult<Transfer>>(`/mes/wm/transfer/page${query(params)}`, { header: header(accessToken) }); }
export function getTransfer(accessToken: string, id: number) { return request<Transfer>(`/mes/wm/transfer/get${query({ id })}`, { header: header(accessToken) }); }
export function createTransfer(accessToken: string, data: Transfer) { return request<number>("/mes/wm/transfer/create", { method: "POST", data, header: header(accessToken) }); }
export function updateTransfer(accessToken: string, data: Transfer) { return request<boolean>("/mes/wm/transfer/update", { method: "PUT", data, header: header(accessToken) }); }
export function deleteTransfer(accessToken: string, id: number) { return request<boolean>(`/mes/wm/transfer/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) }); }
export function submitTransfer(accessToken: string, id: number) { return request<boolean>(`/mes/wm/transfer/submit${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function confirmTransfer(accessToken: string, id: number) { return request<boolean>(`/mes/wm/transfer/confirm${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function stockTransfer(accessToken: string, id: number) { return request<boolean>(`/mes/wm/transfer/stock${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function finishTransfer(accessToken: string, id: number) { return request<boolean>(`/mes/wm/transfer/finish${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function cancelTransfer(accessToken: string, id: number) { return request<boolean>(`/mes/wm/transfer/cancel${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function getTransferLineList(accessToken: string, transferId: number) { return request<TransferLine[]>(`/mes/wm/transfer-line/list${query({ transferId })}`, { header: header(accessToken) }); }
export function createTransferLine(accessToken: string, data: TransferLine) { return request<number>("/mes/wm/transfer-line/create", { method: "POST", data, header: header(accessToken) }); }
export function updateTransferLine(accessToken: string, data: TransferLine) { return request<boolean>("/mes/wm/transfer-line/update", { method: "PUT", data, header: header(accessToken) }); }
export function deleteTransferLine(accessToken: string, id: number) { return request<boolean>(`/mes/wm/transfer-line/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) }); }
export function getTransferDetailList(accessToken: string, lineId: number) { return request<TransferDetail[]>(`/mes/wm/transfer-detail/list-by-line${query({ lineId })}`, { header: header(accessToken) }); }
export function createTransferDetail(accessToken: string, data: TransferDetail) { return request<number>("/mes/wm/transfer-detail/create", { method: "POST", data, header: header(accessToken) }); }
export function updateTransferDetail(accessToken: string, data: TransferDetail) { return request<boolean>("/mes/wm/transfer-detail/update", { method: "PUT", data, header: header(accessToken) }); }
export function deleteTransferDetail(accessToken: string, id: number) { return request<boolean>(`/mes/wm/transfer-detail/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) }); }
export function getStockTakingPlanPage(accessToken: string, params: { pageNo: number; pageSize: number; code?: string; name?: string; type?: number; status?: number }) { return request<PageResult<StockTakingPlan>>(`/mes/wm/stocktaking-plan/page${query(params)}`, { header: header(accessToken) }); }
export function getStockTakingPlan(accessToken: string, id: number) { return request<StockTakingPlan>(`/mes/wm/stocktaking-plan/get${query({ id })}`, { header: header(accessToken) }); }
export function createStockTakingPlan(accessToken: string, data: StockTakingPlan) { return request<number>("/mes/wm/stocktaking-plan/create", { method: "POST", data, header: header(accessToken) }); }
export function updateStockTakingPlan(accessToken: string, data: StockTakingPlan) { return request<boolean>("/mes/wm/stocktaking-plan/update", { method: "PUT", data, header: header(accessToken) }); }
export function updateStockTakingPlanStatus(accessToken: string, id: number, status: number) { return request<boolean>(`/mes/wm/stocktaking-plan/update-status${query({ id, status })}`, { method: "PUT", header: header(accessToken) }); }
export function deleteStockTakingPlan(accessToken: string, id: number) { return request<boolean>(`/mes/wm/stocktaking-plan/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) }); }
export function getStockTakingPlanParamPage(accessToken: string, params: { pageNo: number; pageSize: number; planId?: number }) { return request<PageResult<StockTakingPlanParam>>(`/mes/wm/stocktaking-plan-param/page${query(params)}`, { header: header(accessToken) }); }
export function createStockTakingPlanParam(accessToken: string, data: StockTakingPlanParam) { return request<number>("/mes/wm/stocktaking-plan-param/create", { method: "POST", data, header: header(accessToken) }); }
export function updateStockTakingPlanParam(accessToken: string, data: StockTakingPlanParam) { return request<boolean>("/mes/wm/stocktaking-plan-param/update", { method: "PUT", data, header: header(accessToken) }); }
export function deleteStockTakingPlanParam(accessToken: string, id: number) { return request<boolean>(`/mes/wm/stocktaking-plan-param/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) }); }
export function getStockTakingTaskPage(accessToken: string, params: { pageNo: number; pageSize: number; code?: string; name?: string; type?: number; status?: number }) { return request<PageResult<StockTakingTask>>(`/mes/wm/stocktaking-task/page${query(params)}`, { header: header(accessToken) }); }
export function getStockTakingTask(accessToken: string, id: number) { return request<StockTakingTask>(`/mes/wm/stocktaking-task/get${query({ id })}`, { header: header(accessToken) }); }
export function createStockTakingTask(accessToken: string, data: StockTakingTask) { return request<number>("/mes/wm/stocktaking-task/create", { method: "POST", data, header: header(accessToken) }); }
export function updateStockTakingTask(accessToken: string, data: StockTakingTask) { return request<boolean>("/mes/wm/stocktaking-task/update", { method: "PUT", data, header: header(accessToken) }); }
export function deleteStockTakingTask(accessToken: string, id: number) { return request<boolean>(`/mes/wm/stocktaking-task/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) }); }
export function submitStockTakingTask(accessToken: string, id: number) { return request<boolean>(`/mes/wm/stocktaking-task/submit${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function cancelStockTakingTask(accessToken: string, id: number) { return request<boolean>(`/mes/wm/stocktaking-task/cancel${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function finishStockTakingTask(accessToken: string, id: number) { return request<boolean>("/mes/wm/stocktaking-task/finish", { method: "PUT", data: { id }, header: header(accessToken) }); }
export function getStockTakingTaskLinePage(accessToken: string, params: { pageNo: number; pageSize: number; taskId?: number }) { return request<PageResult<StockTakingTaskLine>>(`/mes/wm/stocktaking-task-line/page${query(params)}`, { header: header(accessToken) }); }
export function getStockTakingTaskLineSimpleList(accessToken: string, taskId: number) { return request<StockTakingTaskLine[]>(`/mes/wm/stocktaking-task-line/simple-list${query({ taskId })}`, { header: header(accessToken) }); }
export function createStockTakingTaskLine(accessToken: string, data: StockTakingTaskLine) { return request<number>("/mes/wm/stocktaking-task-line/create", { method: "POST", data, header: header(accessToken) }); }
export function updateStockTakingTaskLine(accessToken: string, data: StockTakingTaskLine) { return request<boolean>("/mes/wm/stocktaking-task-line/update", { method: "PUT", data, header: header(accessToken) }); }
export function deleteStockTakingTaskLine(accessToken: string, id: number) { return request<boolean>(`/mes/wm/stocktaking-task-line/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) }); }
export function getStockTakingResultPage(accessToken: string, params: { pageNo: number; pageSize: number; taskId?: number }) { return request<PageResult<StockTakingResult>>(`/mes/wm/stocktaking-task-result/page${query(params)}`, { header: header(accessToken) }); }
export function createStockTakingResult(accessToken: string, data: StockTakingResult) { return request<number>("/mes/wm/stocktaking-task-result/create", { method: "POST", data, header: header(accessToken) }); }
export function updateStockTakingResult(accessToken: string, data: StockTakingResult) { return request<boolean>("/mes/wm/stocktaking-task-result/update", { method: "PUT", data, header: header(accessToken) }); }
export function deleteStockTakingResult(accessToken: string, id: number) { return request<boolean>(`/mes/wm/stocktaking-task-result/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) }); }
export function getPackagePage(accessToken: string, params: { pageNo: number; pageSize: number; code?: string; status?: number; childableOnly?: boolean }) { return request<PageResult<WlsPackage>>(`/mes/wm/package/page${query(params)}`, { header: header(accessToken) }); }
export function getPackage(accessToken: string, id: number) { return request<WlsPackage>(`/mes/wm/package/get${query({ id })}`, { header: header(accessToken) }); }
export function createPackage(accessToken: string, data: WlsPackage) { return request<number>("/mes/wm/package/create", { method: "POST", data, header: header(accessToken) }); }
export function updatePackage(accessToken: string, data: WlsPackage) { return request<boolean>("/mes/wm/package/update", { method: "PUT", data, header: header(accessToken) }); }
export function deletePackage(accessToken: string, id: number) { return request<boolean>(`/mes/wm/package/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) }); }
export function finishPackage(accessToken: string, id: number) { return request<boolean>(`/mes/wm/package/finish${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function addChildPackage(accessToken: string, parentId: number, childId: number) { return request<boolean>(`/mes/wm/package/add-child-package${query({ parentId, childId })}`, { method: "PUT", header: header(accessToken) }); }
export function removeChildPackage(accessToken: string, childId: number) { return request<boolean>(`/mes/wm/package/remove-child-package${query({ childId })}`, { method: "PUT", header: header(accessToken) }); }
export function getPackageLinePage(accessToken: string, params: { pageNo: number; pageSize: number; packageId?: number }) { return request<PageResult<PackageLine>>(`/mes/wm/package-line/page${query(params)}`, { header: header(accessToken) }); }
export function createPackageLine(accessToken: string, data: PackageLine) { return request<number>("/mes/wm/package-line/create", { method: "POST", data, header: header(accessToken) }); }
export function updatePackageLine(accessToken: string, data: PackageLine) { return request<boolean>("/mes/wm/package-line/update", { method: "PUT", data, header: header(accessToken) }); }
export function deletePackageLine(accessToken: string, id: number) { return request<boolean>(`/mes/wm/package-line/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) }); }
export function generateSnCodes(accessToken: string, data: SnGenerate) { return request<boolean>("/mes/wm/sn/generate", { method: "POST", data, header: header(accessToken) }); }
export function getSnGroupPage(accessToken: string, params: { pageNo: number; pageSize: number; uuid?: string; code?: string; itemId?: number; batchCode?: string }) { return request<PageResult<SnGroup>>(`/mes/wm/sn/group-page${query(params)}`, { header: header(accessToken) }); }
export function getSnListByUuid(accessToken: string, uuid: string) { return request<Sn[]>(`/mes/wm/sn/list-by-uuid${query({ uuid })}`, { header: header(accessToken) }); }
export function deleteSnBatch(accessToken: string, uuid: string) { return request<boolean>(`/mes/wm/sn/delete-batch${query({ uuid })}`, { method: "DELETE", header: header(accessToken) }); }
export function getBarcodePage(accessToken: string, params: { pageNo: number; pageSize: number; bizType?: number; bizCode?: string; bizName?: string; content?: string }) { return request<PageResult<BarcodeRecord>>(`/mes/wm/barcode/page${query(params)}`, { header: header(accessToken) }); }
export function getBarcode(accessToken: string, id: number) { return request<BarcodeRecord>(`/mes/wm/barcode/get${query({ id })}`, { header: header(accessToken) }); }
export function createBarcode(accessToken: string, data: BarcodeRecord) { return request<number>("/mes/wm/barcode/create", { method: "POST", data, header: header(accessToken) }); }
export function updateBarcode(accessToken: string, data: BarcodeRecord) { return request<boolean>("/mes/wm/barcode/update", { method: "PUT", data, header: header(accessToken) }); }
export function deleteBarcode(accessToken: string, id: number) { return request<boolean>(`/mes/wm/barcode/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) }); }
export function generateBarcodeContent(accessToken: string, bizType: number, bizCode: string) { return request<string>(`/mes/wm/barcode/generate-content${query({ bizType, bizCode })}`, { header: header(accessToken) }); }
export function getBarcodeConfigPage(accessToken: string, params: { pageNo: number; pageSize: number; format?: number; bizType?: number }) { return request<PageResult<BarcodeConfig>>(`/mes/wm/barcode-config/page${query(params)}`, { header: header(accessToken) }); }
export function getBarcodeConfig(accessToken: string, id: number) { return request<BarcodeConfig>(`/mes/wm/barcode-config/get${query({ id })}`, { header: header(accessToken) }); }
export function createBarcodeConfig(accessToken: string, data: BarcodeConfig) { return request<number>("/mes/wm/barcode-config/create", { method: "POST", data, header: header(accessToken) }); }
export function updateBarcodeConfig(accessToken: string, data: BarcodeConfig) { return request<boolean>("/mes/wm/barcode-config/update", { method: "PUT", data, header: header(accessToken) }); }
export function deleteBarcodeConfig(accessToken: string, id: number) { return request<boolean>(`/mes/wm/barcode-config/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) }); }
export function getArrivalNoticePage(accessToken: string, params: { pageNo: number; pageSize: number; code?: string; vendorName?: string; status?: number }) {
  return request<PageResult<ArrivalNotice>>(`/mes/wm/arrival-notice/page${query(params)}`, { header: header(accessToken) });
}
export function getArrivalNotice(accessToken: string, id: number) {
  return request<ArrivalNotice>(`/mes/wm/arrival-notice/get${query({ id })}`, { header: header(accessToken) });
}
export function createArrivalNotice(accessToken: string, data: ArrivalNotice) {
  return request<number>("/mes/wm/arrival-notice/create", { method: "POST", data, header: header(accessToken) });
}
export function updateArrivalNotice(accessToken: string, data: ArrivalNotice) {
  return request<boolean>("/mes/wm/arrival-notice/update", { method: "PUT", data, header: header(accessToken) });
}
export function deleteArrivalNotice(accessToken: string, id: number) {
  return request<boolean>(`/mes/wm/arrival-notice/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}
export function submitArrivalNotice(accessToken: string, id: number) {
  return request<boolean>(`/mes/wm/arrival-notice/submit${query({ id })}`, { method: "PUT", header: header(accessToken) });
}
export function generateArrivalNoticeFromPurchaseOrder(accessToken: string, purchaseOrderId: number) {
  return request<number>(`/mes/wm/arrival-notice/generate-from-purchase-order${query({ purchaseOrderId })}`, { method: "POST", header: header(accessToken) });
}
export function getArrivalNoticeLinePage(accessToken: string, params: { pageNo: number; pageSize: number; noticeId?: number }) {
  return request<PageResult<ArrivalNoticeLine>>(`/mes/wm/arrival-notice-line/page${query(params)}`, { header: header(accessToken) });
}
export function createArrivalNoticeLine(accessToken: string, data: ArrivalNoticeLine) {
  return request<number>("/mes/wm/arrival-notice-line/create", { method: "POST", data, header: header(accessToken) });
}
export function updateArrivalNoticeLine(accessToken: string, data: ArrivalNoticeLine) {
  return request<boolean>("/mes/wm/arrival-notice-line/update", { method: "PUT", data, header: header(accessToken) });
}
export function deleteArrivalNoticeLine(accessToken: string, id: number) {
  return request<boolean>(`/mes/wm/arrival-notice-line/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}
export function getItemReceiptPage(accessToken: string, params: { pageNo: number; pageSize: number; code?: string }) {
  return request<PageResult<ItemReceipt>>(`/mes/wm/item-receipt/page${query(params)}`, { header: header(accessToken) });
}
export function getItemReceipt(accessToken: string, id: number) {
  return request<ItemReceipt>(`/mes/wm/item-receipt/get${query({ id })}`, { header: header(accessToken) });
}
export function createItemReceipt(accessToken: string, data: ItemReceipt) {
  return request<number>("/mes/wm/item-receipt/create", { method: "POST", data, header: header(accessToken) });
}
export function updateItemReceipt(accessToken: string, data: ItemReceipt) {
  return request<boolean>("/mes/wm/item-receipt/update", { method: "PUT", data, header: header(accessToken) });
}
export function deleteItemReceipt(accessToken: string, id: number) {
  return request<boolean>(`/mes/wm/item-receipt/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}
export function submitItemReceipt(accessToken: string, id: number) {
  return request<boolean>(`/mes/wm/item-receipt/submit${query({ id })}`, { method: "PUT", header: header(accessToken) });
}
export function stockItemReceipt(accessToken: string, id: number) {
  return request<boolean>(`/mes/wm/item-receipt/stock${query({ id })}`, { method: "PUT", header: header(accessToken) });
}
export function finishItemReceipt(accessToken: string, id: number) {
  return request<boolean>(`/mes/wm/item-receipt/finish${query({ id })}`, { method: "PUT", header: header(accessToken) });
}
export function cancelItemReceipt(accessToken: string, id: number) {
  return request<boolean>(`/mes/wm/item-receipt/cancel${query({ id })}`, { method: "PUT", header: header(accessToken) });
}
export function generateItemReceiptFromArrivalNotice(accessToken: string, arrivalNoticeId: number) {
  return request<number>(`/mes/wm/item-receipt/generate-from-arrival-notice${query({ arrivalNoticeId })}`, { method: "POST", header: header(accessToken) });
}
export function getItemReceiptLinePage(accessToken: string, params: { pageNo: number; pageSize: number; receiptId?: number }) {
  return request<PageResult<ItemReceiptLine>>(`/mes/wm/item-receipt-line/page${query(params)}`, { header: header(accessToken) });
}
export function createItemReceiptLine(accessToken: string, data: ItemReceiptLine) {
  return request<number>("/mes/wm/item-receipt-line/create", { method: "POST", data, header: header(accessToken) });
}
export function updateItemReceiptLine(accessToken: string, data: ItemReceiptLine) {
  return request<boolean>("/mes/wm/item-receipt-line/update", { method: "PUT", data, header: header(accessToken) });
}
export function deleteItemReceiptLine(accessToken: string, id: number) {
  return request<boolean>(`/mes/wm/item-receipt-line/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}
export function getItemReceiptDetailListByLine(accessToken: string, lineId: number) {
  return request<ItemReceiptDetail[]>(`/mes/wm/item-receipt-detail/list-by-line${query({ lineId })}`, { header: header(accessToken) });
}
export function getItemReceiptDetail(accessToken: string, id: number) {
  return request<ItemReceiptDetail>(`/mes/wm/item-receipt-detail/get${query({ id })}`, { header: header(accessToken) });
}
export function createItemReceiptDetail(accessToken: string, data: ItemReceiptDetail) {
  return request<number>("/mes/wm/item-receipt-detail/create", { method: "POST", data, header: header(accessToken) });
}
export function updateItemReceiptDetail(accessToken: string, data: ItemReceiptDetail) {
  return request<boolean>("/mes/wm/item-receipt-detail/update", { method: "PUT", data, header: header(accessToken) });
}
export function deleteItemReceiptDetail(accessToken: string, id: number) {
  return request<boolean>(`/mes/wm/item-receipt-detail/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}
export function getReturnVendorPage(accessToken: string, params: { pageNo: number; pageSize: number; code?: string }) {
  return request<PageResult<ReturnVendor>>(`/mes/wm/return-vendor/page${query(params)}`, { header: header(accessToken) });
}
export function getReturnVendor(accessToken: string, id: number) {
  return request<ReturnVendor>(`/mes/wm/return-vendor/get${query({ id })}`, { header: header(accessToken) });
}
export function createReturnVendor(accessToken: string, data: ReturnVendor) {
  return request<number>("/mes/wm/return-vendor/create", { method: "POST", data, header: header(accessToken) });
}
export function updateReturnVendor(accessToken: string, data: ReturnVendor) {
  return request<boolean>("/mes/wm/return-vendor/update", { method: "PUT", data, header: header(accessToken) });
}
export function deleteReturnVendor(accessToken: string, id: number) {
  return request<boolean>(`/mes/wm/return-vendor/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}
export function submitReturnVendor(accessToken: string, id: number) {
  return request<boolean>(`/mes/wm/return-vendor/submit${query({ id })}`, { method: "PUT", header: header(accessToken) });
}
export function stockReturnVendor(accessToken: string, id: number) {
  return request<boolean>(`/mes/wm/return-vendor/stock${query({ id })}`, { method: "PUT", header: header(accessToken) });
}
export function finishReturnVendor(accessToken: string, id: number) {
  return request<boolean>(`/mes/wm/return-vendor/finish${query({ id })}`, { method: "PUT", header: header(accessToken) });
}
export function cancelReturnVendor(accessToken: string, id: number) {
  return request<boolean>(`/mes/wm/return-vendor/cancel${query({ id })}`, { method: "PUT", header: header(accessToken) });
}
export function checkReturnVendorQuantity(accessToken: string, id: number) {
  return request<boolean>(`/mes/wm/return-vendor/check-quantity${query({ id })}`, { header: header(accessToken) });
}
export function getReturnVendorLinePage(accessToken: string, params: { pageNo: number; pageSize: number; returnId?: number }) {
  return request<PageResult<ReturnVendorLine>>(`/mes/wm/return-vendor-line/page${query(params)}`, { header: header(accessToken) });
}
export function createReturnVendorLine(accessToken: string, data: ReturnVendorLine) {
  return request<number>("/mes/wm/return-vendor-line/create", { method: "POST", data, header: header(accessToken) });
}
export function updateReturnVendorLine(accessToken: string, data: ReturnVendorLine) {
  return request<boolean>("/mes/wm/return-vendor-line/update", { method: "PUT", data, header: header(accessToken) });
}
export function deleteReturnVendorLine(accessToken: string, id: number) {
  return request<boolean>(`/mes/wm/return-vendor-line/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}
export function getReturnVendorDetailListByLine(accessToken: string, lineId: number) {
  return request<ReturnVendorDetail[]>(`/mes/wm/return-vendor-detail/list-by-line${query({ lineId })}`, { header: header(accessToken) });
}
export function getReturnVendorDetail(accessToken: string, id: number) {
  return request<ReturnVendorDetail>(`/mes/wm/return-vendor-detail/get${query({ id })}`, { header: header(accessToken) });
}
export function createReturnVendorDetail(accessToken: string, data: ReturnVendorDetail) {
  return request<number>("/mes/wm/return-vendor-detail/create", { method: "POST", data, header: header(accessToken) });
}
export function updateReturnVendorDetail(accessToken: string, data: ReturnVendorDetail) {
  return request<boolean>("/mes/wm/return-vendor-detail/update", { method: "PUT", data, header: header(accessToken) });
}
export function deleteReturnVendorDetail(accessToken: string, id: number) {
  return request<boolean>(`/mes/wm/return-vendor-detail/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) });
}
export function getUserSimpleList(accessToken: string) {
  return request<UserSimple[]>("/system/user/simple-list", { header: header(accessToken) });
}
export function getMaterialSimpleList(accessToken: string) {
  return request<MaterialItem[]>("/mdm/item/simple-list", { header: header(accessToken) });
}
export function getWorkOrderPage(accessToken: string, params: { pageNo: number; pageSize: number; code?: string; name?: string; status?: number; type?: number }) {
  return request<PageResult<WlsWorkOrder>>(`/mes/pro/work-order/page${query(params)}`, { header: header(accessToken) });
}
export function getTaskPage(accessToken: string, params: { pageNo: number; pageSize: number; workOrderId?: number; code?: string; name?: string }) {
  return request<PageResult<WlsTask>>(`/mes/pro/task/page${query(params)}`, { header: header(accessToken) });
}
export function getWorkstationPage(accessToken: string, params: { pageNo: number; pageSize: number; code?: string; name?: string }) {
  return request<PageResult<WlsWorkstation>>(`/mes/md-workstation/page${query(params)}`, { header: header(accessToken) });
}
export function getProductIssuePage(accessToken: string, params: { pageNo: number; pageSize: number; code?: string }) {
  return request<PageResult<WlsDocBase>>(`/mes/wm/product-issue/page${query(params)}`, { header: header(accessToken) });
}
export function getProductIssue(accessToken: string, id: number) { return request<WlsDocBase>(`/mes/wm/product-issue/get${query({ id })}`, { header: header(accessToken) }); }
export function createProductIssue(accessToken: string, data: WlsDocBase) { return request<number>("/mes/wm/product-issue/create", { method: "POST", data, header: header(accessToken) }); }
export function updateProductIssue(accessToken: string, data: WlsDocBase) { return request<boolean>("/mes/wm/product-issue/update", { method: "PUT", data, header: header(accessToken) }); }
export function deleteProductIssue(accessToken: string, id: number) { return request<boolean>(`/mes/wm/product-issue/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) }); }
export function submitProductIssue(accessToken: string, id: number) { return request<boolean>(`/mes/wm/product-issue/submit${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function stockProductIssue(accessToken: string, id: number) { return request<boolean>(`/mes/wm/product-issue/stock${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function finishProductIssue(accessToken: string, id: number) { return request<boolean>(`/mes/wm/product-issue/finish${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function cancelProductIssue(accessToken: string, id: number) { return request<boolean>(`/mes/wm/product-issue/cancel${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function checkProductIssueQuantity(accessToken: string, id: number) { return request<boolean>(`/mes/wm/product-issue/check-quantity${query({ id })}`, { header: header(accessToken) }); }
export function getBomItemList(accessToken: string, issueId: number) { return request<WlsDocLine[]>(`/mes/wm/product-issue-line/bom-item-list${query({ issueId })}`, { header: header(accessToken) }); }
export function getReturnableIssueLines(accessToken: string, workOrderId: number) { return request<WlsDocLine[]>(`/mes/wm/product-issue-line/returnable-list${query({ workOrderId })}`, { header: header(accessToken) }); }
export function getProductReceiptPage(accessToken: string, params: { pageNo: number; pageSize: number; code?: string }) {
  return request<PageResult<WlsDocBase>>(`/mes/wm/product-receipt/page${query(params)}`, { header: header(accessToken) });
}
export function getProductReceipt(accessToken: string, id: number) { return request<WlsDocBase>(`/mes/wm/product-receipt/get${query({ id })}`, { header: header(accessToken) }); }
export function createProductReceipt(accessToken: string, data: WlsDocBase) { return request<number>("/mes/wm/product-receipt/create", { method: "POST", data, header: header(accessToken) }); }
export function updateProductReceipt(accessToken: string, data: WlsDocBase) { return request<boolean>("/mes/wm/product-receipt/update", { method: "PUT", data, header: header(accessToken) }); }
export function deleteProductReceipt(accessToken: string, id: number) { return request<boolean>(`/mes/wm/product-receipt/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) }); }
export function submitProductReceipt(accessToken: string, id: number) { return request<boolean>(`/mes/wm/product-receipt/submit${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function stockProductReceipt(accessToken: string, id: number) { return request<boolean>(`/mes/wm/product-receipt/stock${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function finishProductReceipt(accessToken: string, id: number) { return request<boolean>(`/mes/wm/product-receipt/finish${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function cancelProductReceipt(accessToken: string, id: number) { return request<boolean>(`/mes/wm/product-receipt/cancel${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function checkProductReceiptQuantity(accessToken: string, id: number) { return request<boolean>(`/mes/wm/product-receipt/check-quantity${query({ id })}`, { header: header(accessToken) }); }
export function getSalesNoticePage(accessToken: string, params: { pageNo: number; pageSize: number; code?: string; status?: number }) {
  return request<PageResult<WlsDocBase>>(`/mes/wm/sales-notice/page${query(params)}`, { header: header(accessToken) });
}
export function getSalesNotice(accessToken: string, id: number) { return request<WlsDocBase>(`/mes/wm/sales-notice/get${query({ id })}`, { header: header(accessToken) }); }
export function createSalesNotice(accessToken: string, data: WlsDocBase) { return request<number>("/mes/wm/sales-notice/create", { method: "POST", data, header: header(accessToken) }); }
export function updateSalesNotice(accessToken: string, data: WlsDocBase) { return request<boolean>("/mes/wm/sales-notice/update", { method: "PUT", data, header: header(accessToken) }); }
export function deleteSalesNotice(accessToken: string, id: number) { return request<boolean>(`/mes/wm/sales-notice/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) }); }
export function submitSalesNotice(accessToken: string, id: number) { return request<boolean>(`/mes/wm/sales-notice/submit${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function generateProductSalesFromNotice(accessToken: string, id: number) { return request<number>(`/mes/wm/sales-notice/generate-product-sales${query({ id })}`, { method: "POST", header: header(accessToken) }); }
export function getReturnIssuePage(accessToken: string, params: { pageNo: number; pageSize: number; code?: string }) {
  return request<PageResult<WlsDocBase>>(`/mes/wm/return-issue/page${query(params)}`, { header: header(accessToken) });
}
export function getReturnIssue(accessToken: string, id: number) { return request<WlsDocBase>(`/mes/wm/return-issue/get${query({ id })}`, { header: header(accessToken) }); }
export function createReturnIssue(accessToken: string, data: WlsDocBase) { return request<number>("/mes/wm/return-issue/create", { method: "POST", data, header: header(accessToken) }); }
export function updateReturnIssue(accessToken: string, data: WlsDocBase) { return request<boolean>("/mes/wm/return-issue/update", { method: "PUT", data, header: header(accessToken) }); }
export function deleteReturnIssue(accessToken: string, id: number) { return request<boolean>(`/mes/wm/return-issue/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) }); }
export function submitReturnIssue(accessToken: string, id: number) { return request<boolean>(`/mes/wm/return-issue/submit${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function stockReturnIssue(accessToken: string, id: number) { return request<boolean>(`/mes/wm/return-issue/stock${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function finishReturnIssue(accessToken: string, id: number) { return request<boolean>(`/mes/wm/return-issue/finish${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function cancelReturnIssue(accessToken: string, id: number) { return request<boolean>(`/mes/wm/return-issue/cancel${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function getProductSalesPage(accessToken: string, params: { pageNo: number; pageSize: number; code?: string }) {
  return request<PageResult<WlsDocBase>>(`/mes/wm/product-sales/page${query(params)}`, { header: header(accessToken) });
}
export function getProductSales(accessToken: string, id: number) { return request<WlsDocBase>(`/mes/wm/product-sales/get${query({ id })}`, { header: header(accessToken) }); }
export function createProductSales(accessToken: string, data: WlsDocBase) { return request<number>("/mes/wm/product-sales/create", { method: "POST", data, header: header(accessToken) }); }
export function updateProductSales(accessToken: string, data: WlsDocBase) { return request<boolean>("/mes/wm/product-sales/update", { method: "PUT", data, header: header(accessToken) }); }
export function deleteProductSales(accessToken: string, id: number) { return request<boolean>(`/mes/wm/product-sales/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) }); }
export function submitProductSales(accessToken: string, id: number) { return request<boolean>(`/mes/wm/product-sales/submit${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function stockProductSales(accessToken: string, id: number) { return request<boolean>(`/mes/wm/product-sales/stock${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function shippingProductSales(accessToken: string, data: WlsDocBase) { return request<boolean>("/mes/wm/product-sales/shipping", { method: "PUT", data, header: header(accessToken) }); }
export function finishProductSales(accessToken: string, id: number) { return request<boolean>(`/mes/wm/product-sales/finish${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function cancelProductSales(accessToken: string, id: number) { return request<boolean>(`/mes/wm/product-sales/cancel${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function checkProductSalesQuantity(accessToken: string, id: number) { return request<boolean>(`/mes/wm/product-sales/check-quantity${query({ id })}`, { header: header(accessToken) }); }
export function getReturnSalesPage(accessToken: string, params: { pageNo: number; pageSize: number; code?: string }) {
  return request<PageResult<WlsDocBase>>(`/mes/wm/return-sales/page${query(params)}`, { header: header(accessToken) });
}
export function getReturnSales(accessToken: string, id: number) { return request<WlsDocBase>(`/mes/wm/return-sales/get${query({ id })}`, { header: header(accessToken) }); }
export function createReturnSales(accessToken: string, data: WlsDocBase) { return request<number>("/mes/wm/return-sales/create", { method: "POST", data, header: header(accessToken) }); }
export function updateReturnSales(accessToken: string, data: WlsDocBase) { return request<boolean>("/mes/wm/return-sales/update", { method: "PUT", data, header: header(accessToken) }); }
export function deleteReturnSales(accessToken: string, id: number) { return request<boolean>(`/mes/wm/return-sales/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) }); }
export function submitReturnSales(accessToken: string, id: number) { return request<boolean>(`/mes/wm/return-sales/submit${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function stockReturnSales(accessToken: string, id: number) { return request<boolean>(`/mes/wm/return-sales/stock${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function finishReturnSales(accessToken: string, id: number) { return request<boolean>(`/mes/wm/return-sales/finish${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function cancelReturnSales(accessToken: string, id: number) { return request<boolean>(`/mes/wm/return-sales/cancel${query({ id })}`, { method: "PUT", header: header(accessToken) }); }

export function getMiscReceiptPage(accessToken: string, params: { pageNo: number; pageSize: number; code?: string }) { return request<PageResult<WlsDocBase>>(`/mes/wm/misc-receipt/page${query(params)}`, { header: header(accessToken) }); }
export function getMiscReceipt(accessToken: string, id: number) { return request<WlsDocBase>(`/mes/wm/misc-receipt/get${query({ id })}`, { header: header(accessToken) }); }
export function createMiscReceipt(accessToken: string, data: WlsDocBase) { return request<number>("/mes/wm/misc-receipt/create", { method: "POST", data, header: header(accessToken) }); }
export function updateMiscReceipt(accessToken: string, data: WlsDocBase) { return request<boolean>("/mes/wm/misc-receipt/update", { method: "PUT", data, header: header(accessToken) }); }
export function deleteMiscReceipt(accessToken: string, id: number) { return request<boolean>(`/mes/wm/misc-receipt/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) }); }
export function submitMiscReceipt(accessToken: string, id: number) { return request<boolean>(`/mes/wm/misc-receipt/submit${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function finishMiscReceipt(accessToken: string, id: number) { return request<boolean>(`/mes/wm/misc-receipt/finish${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function cancelMiscReceipt(accessToken: string, id: number) { return request<boolean>(`/mes/wm/misc-receipt/cancel${query({ id })}`, { method: "PUT", header: header(accessToken) }); }

export function getMiscIssuePage(accessToken: string, params: { pageNo: number; pageSize: number; code?: string }) { return request<PageResult<WlsDocBase>>(`/mes/wm/misc-issue/page${query(params)}`, { header: header(accessToken) }); }
export function getMiscIssue(accessToken: string, id: number) { return request<WlsDocBase>(`/mes/wm/misc-issue/get${query({ id })}`, { header: header(accessToken) }); }
export function createMiscIssue(accessToken: string, data: WlsDocBase) { return request<number>("/mes/wm/misc-issue/create", { method: "POST", data, header: header(accessToken) }); }
export function updateMiscIssue(accessToken: string, data: WlsDocBase) { return request<boolean>("/mes/wm/misc-issue/update", { method: "PUT", data, header: header(accessToken) }); }
export function deleteMiscIssue(accessToken: string, id: number) { return request<boolean>(`/mes/wm/misc-issue/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) }); }
export function submitMiscIssue(accessToken: string, id: number) { return request<boolean>(`/mes/wm/misc-issue/submit${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function finishMiscIssue(accessToken: string, id: number) { return request<boolean>(`/mes/wm/misc-issue/finish${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function cancelMiscIssue(accessToken: string, id: number) { return request<boolean>(`/mes/wm/misc-issue/cancel${query({ id })}`, { method: "PUT", header: header(accessToken) }); }

export function getOutsourceIssuePage(accessToken: string, params: { pageNo: number; pageSize: number; code?: string }) { return request<PageResult<WlsDocBase>>(`/mes/wm/outsource-issue/page${query(params)}`, { header: header(accessToken) }); }
export function getOutsourceIssue(accessToken: string, id: number) { return request<WlsDocBase>(`/mes/wm/outsource-issue/get${query({ id })}`, { header: header(accessToken) }); }
export function createOutsourceIssue(accessToken: string, data: WlsDocBase) { return request<number>("/mes/wm/outsource-issue/create", { method: "POST", data, header: header(accessToken) }); }
export function updateOutsourceIssue(accessToken: string, data: WlsDocBase) { return request<boolean>("/mes/wm/outsource-issue/update", { method: "PUT", data, header: header(accessToken) }); }
export function deleteOutsourceIssue(accessToken: string, id: number) { return request<boolean>(`/mes/wm/outsource-issue/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) }); }
export function submitOutsourceIssue(accessToken: string, id: number) { return request<boolean>(`/mes/wm/outsource-issue/submit${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function stockOutsourceIssue(accessToken: string, id: number) { return request<boolean>(`/mes/wm/outsource-issue/stock${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function finishOutsourceIssue(accessToken: string, id: number) { return request<boolean>(`/mes/wm/outsource-issue/finish${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function cancelOutsourceIssue(accessToken: string, id: number) { return request<boolean>(`/mes/wm/outsource-issue/cancel${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function checkOutsourceIssueQuantity(accessToken: string, id: number) { return request<boolean>(`/mes/wm/outsource-issue/check-quantity${query({ id })}`, { header: header(accessToken) }); }

export function getOutsourceReceiptPage(accessToken: string, params: { pageNo: number; pageSize: number; code?: string }) { return request<PageResult<WlsDocBase>>(`/mes/wm/outsource-receipt/page${query(params)}`, { header: header(accessToken) }); }
export function getOutsourceReceipt(accessToken: string, id: number) { return request<WlsDocBase>(`/mes/wm/outsource-receipt/get${query({ id })}`, { header: header(accessToken) }); }
export function createOutsourceReceipt(accessToken: string, data: WlsDocBase) { return request<number>("/mes/wm/outsource-receipt/create", { method: "POST", data, header: header(accessToken) }); }
export function updateOutsourceReceipt(accessToken: string, data: WlsDocBase) { return request<boolean>("/mes/wm/outsource-receipt/update", { method: "PUT", data, header: header(accessToken) }); }
export function deleteOutsourceReceipt(accessToken: string, id: number) { return request<boolean>(`/mes/wm/outsource-receipt/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) }); }
export function submitOutsourceReceipt(accessToken: string, id: number) { return request<boolean>(`/mes/wm/outsource-receipt/submit${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function stockOutsourceReceipt(accessToken: string, id: number) { return request<boolean>(`/mes/wm/outsource-receipt/stock${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function finishOutsourceReceipt(accessToken: string, id: number) { return request<boolean>(`/mes/wm/outsource-receipt/finish${query({ id })}`, { method: "PUT", header: header(accessToken) }); }
export function cancelOutsourceReceipt(accessToken: string, id: number) { return request<boolean>(`/mes/wm/outsource-receipt/cancel${query({ id })}`, { method: "PUT", header: header(accessToken) }); }

function linePage(accessToken: string, path: string, params: Record<string, QueryValue>) {
  return request<PageResult<WlsDocLine>>(`${path}/page${query(params)}`, { header: header(accessToken) });
}
function lineCreate(accessToken: string, path: string, data: WlsDocLine) { return request<number>(`${path}/create`, { method: "POST", data, header: header(accessToken) }); }
function lineUpdate(accessToken: string, path: string, data: WlsDocLine) { return request<boolean>(`${path}/update`, { method: "PUT", data, header: header(accessToken) }); }
function lineDelete(accessToken: string, path: string, id: number) { return request<boolean>(`${path}/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) }); }
function detailList(accessToken: string, path: string, lineId: number) { return request<WlsDocDetail[]>(`${path}/list-by-line${query({ lineId })}`, { header: header(accessToken) }); }
function detailCreate(accessToken: string, path: string, data: WlsDocDetail) { return request<number>(`${path}/create`, { method: "POST", data, header: header(accessToken) }); }
function detailUpdate(accessToken: string, path: string, data: WlsDocDetail) { return request<boolean>(`${path}/update`, { method: "PUT", data, header: header(accessToken) }); }
function detailDelete(accessToken: string, path: string, id: number) { return request<boolean>(`${path}/delete${query({ id })}`, { method: "DELETE", header: header(accessToken) }); }
type WlsLineModule = "product-issue" | "product-receipt" | "sales-notice" | "return-issue" | "product-sales" | "return-sales" | "misc-receipt" | "misc-issue" | "outsource-issue" | "outsource-receipt";
type WlsDetailModule = "product-issue" | "product-receipt" | "return-issue" | "product-sales" | "return-sales" | "outsource-issue" | "outsource-receipt";
export function getWlsLinePage(accessToken: string, module: WlsLineModule, params: Record<string, QueryValue>) {
  return linePage(accessToken, `/mes/wm/${module}-line`, params);
}
export function getMiscReceiptLineList(accessToken: string, receiptId: number) {
  return request<WlsDocLine[]>(`/mes/wm/misc-receipt-line/list-by-receipt-id${query({ receiptId })}`, { header: header(accessToken) });
}
export function createWlsLine(accessToken: string, module: WlsLineModule, data: WlsDocLine) {
  return lineCreate(accessToken, `/mes/wm/${module}-line`, data);
}
export function updateWlsLine(accessToken: string, module: WlsLineModule, data: WlsDocLine) {
  return lineUpdate(accessToken, `/mes/wm/${module}-line`, data);
}
export function deleteWlsLine(accessToken: string, module: WlsLineModule, id: number) {
  return lineDelete(accessToken, `/mes/wm/${module}-line`, id);
}
export function getWlsDetailList(accessToken: string, module: WlsDetailModule, lineId: number) {
  return detailList(accessToken, `/mes/wm/${module}-detail`, lineId);
}
export function createWlsDetail(accessToken: string, module: WlsDetailModule, data: WlsDocDetail) {
  return detailCreate(accessToken, `/mes/wm/${module}-detail`, data);
}
export function updateWlsDetail(accessToken: string, module: WlsDetailModule, data: WlsDocDetail) {
  return detailUpdate(accessToken, `/mes/wm/${module}-detail`, data);
}
export function deleteWlsDetail(accessToken: string, module: WlsDetailModule, id: number) {
  return detailDelete(accessToken, `/mes/wm/${module}-detail`, id);
}