@zensoftbr/zenerpclient 1.0.4 → 1.0.6

package/dist/types/api/material/MaterialService.d.ts

@@ -38,19 +38,19 @@ export declare class MaterialService {
     #private;
     constructor(client: Client);
     addressCreate(bean: Address): Promise<Address>;
-    addressDelete(id: number): Promise<void>;
+    addressDelete(id: number): Promise<Address>;
     addressRead(search: any): Promise<Address[]>;
     addressReadById(id: number): Promise<Address>;
     addressUpdate(bean: Address): Promise<Address>;
     handlingUnitCreate(bean: HandlingUnit): Promise<HandlingUnit>;
-    handlingUnitDelete(id: number): Promise<void>;
+    handlingUnitDelete(id: number): Promise<HandlingUnit>;
     handlingUnitRead(search: any): Promise<HandlingUnit[]>;
     handlingUnitReadById(id: number): Promise<HandlingUnit>;
     handlingUnitUpdate(bean: HandlingUnit): Promise<HandlingUnit>;
     incomingListCreate(bean: IncomingList): Promise<IncomingList>;
-    incomingListDelete(id: number): Promise<void>;
+    incomingListDelete(id: number): Promise<IncomingList>;
     incomingListItemCreate(bean: IncomingListItem): Promise<IncomingListItem>;
-    incomingListItemDelete(id: number): Promise<void>;
+    incomingListItemDelete(id: number): Promise<IncomingListItem>;
     incomingListItemRead(search: any): Promise<IncomingListItem[]>;
     incomingListItemReadById(id: number): Promise<IncomingListItem>;
     incomingListItemUpdate(bean: IncomingListItem): Promise<IncomingListItem>;
@@ -66,18 +66,18 @@ export declare class MaterialService {
     incomingRequestRead(search: any): Promise<IncomingRequest[]>;
     incomingRequestReadById(id: number): Promise<IncomingRequest>;
     inventoryAdjustmentCreate(bean: InventoryAdjustment): Promise<InventoryAdjustment>;
-    inventoryAdjustmentDelete(id: number): Promise<void>;
+    inventoryAdjustmentDelete(id: number): Promise<InventoryAdjustment>;
     inventoryAdjustmentOpCreate(id: number, stockId: number, quantity: number): Promise<InventoryAdjustment>;
     inventoryAdjustmentRead(search: any): Promise<InventoryAdjustment[]>;
     inventoryAdjustmentReadById(id: number): Promise<InventoryAdjustment>;
     inventoryAdjustmentUpdate(bean: InventoryAdjustment): Promise<InventoryAdjustment>;
     inventoryCheckCreate(bean: InventoryCheck): Promise<InventoryCheck>;
-    inventoryCheckDelete(id: number): Promise<void>;
+    inventoryCheckDelete(id: number): Promise<InventoryCheck>;
     inventoryCheckRead(search: any): Promise<InventoryCheck[]>;
     inventoryCheckReadById(id: number): Promise<InventoryCheck>;
     inventoryCheckUpdate(bean: InventoryCheck): Promise<InventoryCheck>;
     inventoryCreate(bean: Inventory): Promise<Inventory>;
-    inventoryDelete(id: number): Promise<void>;
+    inventoryDelete(id: number): Promise<Inventory>;
     inventoryOpApprove(id: number): Promise<Inventory>;
     inventoryOpApproveRevert(id: number): Promise<Inventory>;
     inventoryOpFinish(id: number): Promise<Inventory>;
@@ -91,20 +91,20 @@ export declare class MaterialService {
     inventoryRead(search: any): Promise<Inventory[]>;
     inventoryReadById(id: number): Promise<Inventory>;
     inventoryStockCreate(bean: InventoryStock): Promise<InventoryStock>;
-    inventoryStockDelete(id: number): Promise<void>;
+    inventoryStockDelete(id: number): Promise<InventoryStock>;
     inventoryStockOpCreate(id: number, stockId: number): Promise<InventoryStock>;
     inventoryStockRead(search: any): Promise<InventoryStock[]>;
     inventoryStockReadById(id: number): Promise<InventoryStock>;
     inventoryStockUpdate(bean: InventoryStock): Promise<InventoryStock>;
     inventoryUpdate(bean: Inventory): Promise<Inventory>;
     lotCreate(bean: Lot): Promise<Lot>;
-    lotDelete(id: number): Promise<void>;
+    lotDelete(id: number): Promise<Lot>;
     lotRead(search: any): Promise<Lot[]>;
     lotReadById(id: number): Promise<Lot>;
     lotUpdate(bean: Lot): Promise<Lot>;
     movingOrderCreate(bean: MovingOrder): Promise<MovingOrder>;
-    movingOrderDelete(id: number): Promise<void>;
-    movingOrderItemDelete(id: number): Promise<void>;
+    movingOrderDelete(id: number): Promise<MovingOrder>;
+    movingOrderItemDelete(id: number): Promise<MovingOrderItem>;
     movingOrderItemOpFinish(id: number): Promise<MovingOrderItem>;
     movingOrderItemOpLoad(id: number, args: any): Promise<MovingOrderItem>;
     movingOrderItemOpStart(id: number): Promise<MovingOrderItem>;
@@ -124,7 +124,7 @@ export declare class MaterialService {
     movingOrderRead(search: any): Promise<MovingOrder[]>;
     movingOrderReadById(id: number): Promise<MovingOrder>;
     movingOrderUpdate(bean: MovingOrder): Promise<MovingOrder>;
-    outgoingListDelete(id: number): Promise<void>;
+    outgoingListDelete(id: number): Promise<OutgoingList>;
     outgoingListOpCreateFromReservation(id: number, args: any): Promise<OutgoingList>;
     outgoingListOpMerge(ids: any): Promise<OutgoingList>;
     outgoingListOpOutgoingInvoiceCreate(id: number, args: any): Promise<OutgoingInvoice>;
@@ -135,9 +135,9 @@ export declare class MaterialService {
     outgoingListRead(search: any): Promise<OutgoingList[]>;
     outgoingListReadById(id: number): Promise<OutgoingList>;
     outgoingRequestCreate(bean: OutgoingRequest): Promise<OutgoingRequest>;
-    outgoingRequestDelete(id: number): Promise<void>;
+    outgoingRequestDelete(id: number): Promise<OutgoingRequest>;
     outgoingRequestItemCreate(bean: OutgoingRequestItem): Promise<OutgoingRequestItem>;
-    outgoingRequestItemDelete(id: number): Promise<void>;
+    outgoingRequestItemDelete(id: number): Promise<OutgoingRequestItem>;
     outgoingRequestItemRead(search: any): Promise<OutgoingRequestItem[]>;
     outgoingRequestItemReadById(id: number): Promise<OutgoingRequestItem>;
     outgoingRequestItemUpdate(bean: OutgoingRequestItem): Promise<OutgoingRequestItem>;
@@ -152,9 +152,9 @@ export declare class MaterialService {
     outgoingRequestReadById(id: number): Promise<OutgoingRequest>;
     outgoingRequestUpdate(bean: OutgoingRequest): Promise<OutgoingRequest>;
     pickingOrderCreate(bean: PickingOrder): Promise<PickingOrder>;
-    pickingOrderDelete(id: number): Promise<void>;
+    pickingOrderDelete(id: number): Promise<PickingOrder>;
     pickingOrderItemCreate(bean: PickingOrderItem): Promise<PickingOrderItem>;
-    pickingOrderItemDelete(id: number): Promise<void>;
+    pickingOrderItemDelete(id: number): Promise<PickingOrderItem>;
     pickingOrderItemRead(search: any): Promise<PickingOrderItem[]>;
     pickingOrderItemReadById(id: number): Promise<PickingOrderItem>;
     pickingOrderOpApprove(id: number): Promise<PickingOrder>;
@@ -175,17 +175,17 @@ export declare class MaterialService {
     pickingOrderReadById(id: number): Promise<PickingOrder>;
     pickingOrderUpdate(bean: PickingOrder): Promise<PickingOrder>;
     pickingProfileCreate(bean: PickingProfile): Promise<PickingProfile>;
-    pickingProfileDelete(id: number): Promise<void>;
+    pickingProfileDelete(id: number): Promise<PickingProfile>;
     pickingProfileRead(search: any): Promise<PickingProfile[]>;
     pickingProfileReadById(id: number): Promise<PickingProfile>;
     pickingProfileUpdate(bean: PickingProfile): Promise<PickingProfile>;
     qualityCreate(bean: Quality): Promise<Quality>;
-    qualityDelete(id: number): Promise<void>;
+    qualityDelete(id: number): Promise<Quality>;
     qualityRead(search: any): Promise<Quality[]>;
     qualityReadById(id: number): Promise<Quality>;
     qualityUpdate(bean: Quality): Promise<Quality>;
     reservationCreate(bean: Reservation): Promise<Reservation>;
-    reservationDelete(id: number): Promise<void>;
+    reservationDelete(id: number): Promise<Reservation>;
     reservationItemRead(search: any): Promise<ReservationItem[]>;
     reservationItemReadById(id: number): Promise<ReservationItem>;
     reservationOpAllocate(id: number, args: any): Promise<Reservation>;
@@ -206,26 +206,26 @@ export declare class MaterialService {
     reservationRead(search: any): Promise<Reservation[]>;
     reservationReadById(id: number): Promise<Reservation>;
     reservationTargetCreate(bean: ReservationTarget): Promise<ReservationTarget>;
-    reservationTargetDelete(id: number): Promise<void>;
+    reservationTargetDelete(id: number): Promise<ReservationTarget>;
     reservationTargetRead(search: any): Promise<ReservationTarget[]>;
     reservationTargetReadById(id: number): Promise<ReservationTarget>;
     reservationTargetUpdate(bean: ReservationTarget): Promise<ReservationTarget>;
     reservationUpdate(bean: Reservation): Promise<Reservation>;
     serialCreate(bean: Serial): Promise<Serial>;
-    serialDelete(id: number): Promise<void>;
+    serialDelete(id: number): Promise<Serial>;
     serialRead(search: any): Promise<Serial[]>;
     serialReadById(id: number): Promise<Serial>;
     serialUpdate(bean: Serial): Promise<Serial>;
     stockAvailabilityRead(search: any): Promise<StockAvailability[]>;
     stockClusterCreate(bean: StockCluster): Promise<StockCluster>;
-    stockClusterDelete(id: number): Promise<void>;
+    stockClusterDelete(id: number): Promise<StockCluster>;
     stockClusterRead(search: any): Promise<StockCluster[]>;
     stockClusterReadById(id: number): Promise<StockCluster>;
     stockClusterUpdate(bean: StockCluster): Promise<StockCluster>;
     stockManagementCreate(bean: StockManagement): Promise<StockManagement>;
-    stockManagementDelete(id: number): Promise<void>;
+    stockManagementDelete(id: number): Promise<StockManagement>;
     stockManagementItemCreate(bean: StockManagementItem): Promise<StockManagementItem>;
-    stockManagementItemDelete(id: number): Promise<void>;
+    stockManagementItemDelete(id: number): Promise<StockManagementItem>;
     stockManagementItemRead(search: any): Promise<StockManagementItem[]>;
     stockManagementItemReadById(id: number): Promise<StockManagementItem>;
     stockManagementItemUpdate(bean: StockManagementItem): Promise<StockManagementItem>;
@@ -244,9 +244,9 @@ export declare class MaterialService {
     stockTransactionRead(search: any): Promise<StockTransaction[]>;
     stockTransactionReadById(id: number): Promise<StockTransaction>;
     volumeCreate(bean: Volume): Promise<Volume>;
-    volumeDelete(id: number): Promise<void>;
+    volumeDelete(id: number): Promise<Volume>;
     volumeItemCreate(bean: VolumeItem): Promise<VolumeItem>;
-    volumeItemDelete(id: number): Promise<void>;
+    volumeItemDelete(id: number): Promise<VolumeItem>;
     volumeItemRead(search: any): Promise<VolumeItem[]>;
     volumeItemReadById(id: number): Promise<VolumeItem>;
     volumeOpCheck(id: number, args: any): Promise<Volume>;
@@ -257,7 +257,7 @@ export declare class MaterialService {
     volumeReadById(id: number): Promise<Volume>;
     volumeUpdate(bean: Volume): Promise<Volume>;
     warehouseCreate(bean: Warehouse): Promise<Warehouse>;
-    warehouseDelete(id: number): Promise<void>;
+    warehouseDelete(id: number): Promise<Warehouse>;
     warehouseRead(search: any): Promise<Warehouse[]>;
     warehouseReadById(id: number): Promise<Warehouse>;
     warehouseUpdate(bean: Warehouse): Promise<Warehouse>;

package/dist/types/api/production/ProductionService.d.ts

@@ -14,9 +14,9 @@ export declare class ProductionService {
     #private;
     constructor(client: Client);
     bomCreate(bean: Bom): Promise<Bom>;
-    bomDelete(id: number): Promise<void>;
+    bomDelete(id: number): Promise<Bom>;
     bomItemCreate(bean: BomItem): Promise<BomItem>;
-    bomItemDelete(id: number): Promise<void>;
+    bomItemDelete(id: number): Promise<BomItem>;
     bomItemRead(search: any): Promise<BomItem[]>;
     bomItemReadById(id: number): Promise<BomItem>;
     bomItemUpdate(bean: BomItem): Promise<BomItem>;
@@ -25,22 +25,22 @@ export declare class ProductionService {
     bomReadById(id: number): Promise<Bom>;
     bomUpdate(bean: Bom): Promise<Bom>;
     operationCreate(bean: Operation): Promise<Operation>;
-    operationDelete(id: number): Promise<void>;
+    operationDelete(id: number): Promise<Operation>;
     operationRead(search: any): Promise<Operation[]>;
     operationReadById(id: number): Promise<Operation>;
     operationTypeAccountCreate(bean: OperationTypeAccount): Promise<OperationTypeAccount>;
-    operationTypeAccountDelete(id: number): Promise<void>;
+    operationTypeAccountDelete(id: number): Promise<OperationTypeAccount>;
     operationTypeAccountRead(search: any): Promise<OperationTypeAccount[]>;
     operationTypeAccountReadById(id: number): Promise<OperationTypeAccount>;
     operationTypeAccountUpdate(bean: OperationTypeAccount): Promise<OperationTypeAccount>;
     operationTypeCreate(bean: OperationType): Promise<OperationType>;
-    operationTypeDelete(id: number): Promise<void>;
+    operationTypeDelete(id: number): Promise<OperationType>;
     operationTypeRead(search: any): Promise<OperationType[]>;
     operationTypeReadById(id: number): Promise<OperationType>;
     operationTypeUpdate(bean: OperationType): Promise<OperationType>;
     operationUpdate(bean: Operation): Promise<Operation>;
     productionBatchCreate(bean: ProductionBatch): Promise<ProductionBatch>;
-    productionBatchDelete(id: number): Promise<void>;
+    productionBatchDelete(id: number): Promise<ProductionBatch>;
     productionBatchOpApprove(id: number): Promise<ProductionBatch>;
     productionBatchOpApproveRevert(id: number): Promise<ProductionBatch>;
     productionBatchOpPrepare(id: number): Promise<ProductionBatch>;
@@ -49,7 +49,7 @@ export declare class ProductionService {
     productionBatchReadById(id: number): Promise<ProductionBatch>;
     productionBatchUpdate(bean: ProductionBatch): Promise<ProductionBatch>;
     productionOrderCreate(bean: ProductionOrder): Promise<ProductionOrder>;
-    productionOrderDelete(id: number): Promise<void>;
+    productionOrderDelete(id: number): Promise<ProductionOrder>;
     productionOrderOpApprove(id: number): Promise<ProductionOrder>;
     productionOrderOpApproveRevert(id: number): Promise<ProductionOrder>;
     productionOrderOpCreate(args: any): Promise<ProductionOrder>;
@@ -61,19 +61,20 @@ export declare class ProductionService {
     productionOrderReadById(id: number): Promise<ProductionOrder>;
     productionOrderUpdate(bean: ProductionOrder): Promise<ProductionOrder>;
     productionProfileCreate(bean: ProductionProfile): Promise<ProductionProfile>;
-    productionProfileDelete(id: number): Promise<void>;
+    productionProfileDelete(id: number): Promise<ProductionProfile>;
     productionProfileRead(search: any): Promise<ProductionProfile[]>;
     productionProfileReadById(id: number): Promise<ProductionProfile>;
     productionProfileUpdate(bean: ProductionProfile): Promise<ProductionProfile>;
     productionStepCreate(bean: ProductionStep): Promise<ProductionStep>;
-    productionStepDelete(id: number): Promise<void>;
+    productionStepDelete(id: number): Promise<ProductionStep>;
     productionStepInputCreate(bean: ProductionStepInput): Promise<ProductionStepInput>;
-    productionStepInputDelete(id: number): Promise<void>;
+    productionStepInputDelete(id: number): Promise<ProductionStepInput>;
     productionStepInputRead(search: any): Promise<ProductionStepInput[]>;
     productionStepInputReadById(id: number): Promise<ProductionStepInput>;
     productionStepInputUpdate(bean: ProductionStepInput): Promise<ProductionStepInput>;
+    productionStepOpCalculateInput(id: number): Promise<ProductionStep>;
     productionStepOutputCreate(bean: ProductionStepOutput): Promise<ProductionStepOutput>;
-    productionStepOutputDelete(id: number): Promise<void>;
+    productionStepOutputDelete(id: number): Promise<ProductionStepOutput>;
     productionStepOutputRead(search: any): Promise<ProductionStepOutput[]>;
     productionStepOutputReadById(id: number): Promise<ProductionStepOutput>;
     productionStepOutputUpdate(bean: ProductionStepOutput): Promise<ProductionStepOutput>;

package/dist/types/api/purchase/PurchaseService.d.ts

@@ -13,9 +13,9 @@ export declare class PurchaseService {
     #private;
     constructor(client: Client);
     priceListCreate(bean: PriceList): Promise<PriceList>;
-    priceListDelete(id: number): Promise<void>;
+    priceListDelete(id: number): Promise<PriceList>;
     priceListItemCreate(bean: PriceListItem): Promise<PriceListItem>;
-    priceListItemDelete(id: number): Promise<void>;
+    priceListItemDelete(id: number): Promise<PriceListItem>;
     priceListItemRead(search: any): Promise<PriceListItem[]>;
     priceListItemReadById(id: number): Promise<PriceListItem>;
     priceListItemUpdate(bean: PriceListItem): Promise<PriceListItem>;
@@ -23,9 +23,9 @@ export declare class PurchaseService {
     priceListReadById(id: number): Promise<PriceList>;
     priceListUpdate(bean: PriceList): Promise<PriceList>;
     proposalCreate(bean: Proposal): Promise<Proposal>;
-    proposalDelete(id: number): Promise<void>;
+    proposalDelete(id: number): Promise<Proposal>;
     proposalItemCreate(bean: ProposalItem): Promise<ProposalItem>;
-    proposalItemDelete(id: number): Promise<void>;
+    proposalItemDelete(id: number): Promise<ProposalItem>;
     proposalItemOpApprove(id: number, args: any): Promise<ProposalItem>;
     proposalItemOpApproveRevert(id: number): Promise<ProposalItem>;
     proposalItemOpDisapprove(id: number, args: any): Promise<ProposalItem>;
@@ -41,9 +41,9 @@ export declare class PurchaseService {
     proposalReadById(id: number): Promise<Proposal>;
     proposalUpdate(bean: Proposal): Promise<Proposal>;
     purchaseCreate(bean: Purchase): Promise<Purchase>;
-    purchaseDelete(id: number): Promise<void>;
+    purchaseDelete(id: number): Promise<Purchase>;
     purchaseItemCreate(bean: PurchaseItem): Promise<PurchaseItem>;
-    purchaseItemDelete(id: number): Promise<void>;
+    purchaseItemDelete(id: number): Promise<PurchaseItem>;
     purchaseItemRead(search: any): Promise<PurchaseItem[]>;
     purchaseItemReadById(id: number): Promise<PurchaseItem>;
     purchaseItemUpdate(bean: PurchaseItem): Promise<PurchaseItem>;
@@ -58,12 +58,12 @@ export declare class PurchaseService {
     purchaseOpPrepare(id: number): Promise<Purchase>;
     purchaseOpPrepareRevert(id: number): Promise<Purchase>;
     purchasePaymentCreate(bean: PurchasePayment): Promise<PurchasePayment>;
-    purchasePaymentDelete(id: number): Promise<void>;
+    purchasePaymentDelete(id: number): Promise<PurchasePayment>;
     purchasePaymentRead(search: any): Promise<PurchasePayment[]>;
     purchasePaymentReadById(id: number): Promise<PurchasePayment>;
     purchasePaymentUpdate(bean: PurchasePayment): Promise<PurchasePayment>;
     purchaseProfileCreate(bean: PurchaseProfile): Promise<PurchaseProfile>;
-    purchaseProfileDelete(id: number): Promise<void>;
+    purchaseProfileDelete(id: number): Promise<PurchaseProfile>;
     purchaseProfileRead(search: any): Promise<PurchaseProfile[]>;
     purchaseProfileReadById(id: number): Promise<PurchaseProfile>;
     purchaseProfileUpdate(bean: PurchaseProfile): Promise<PurchaseProfile>;
@@ -71,9 +71,9 @@ export declare class PurchaseService {
     purchaseReadById(id: number): Promise<Purchase>;
     purchaseUpdate(bean: Purchase): Promise<Purchase>;
     quoteCreate(bean: Quote): Promise<Quote>;
-    quoteDelete(id: number): Promise<void>;
+    quoteDelete(id: number): Promise<Quote>;
     quoteItemCreate(bean: QuoteItem): Promise<QuoteItem>;
-    quoteItemDelete(id: number): Promise<void>;
+    quoteItemDelete(id: number): Promise<QuoteItem>;
     quoteItemRead(search: any): Promise<QuoteItem[]>;
     quoteItemReadById(id: number): Promise<QuoteItem>;
     quoteItemUpdate(bean: QuoteItem): Promise<QuoteItem>;

package/dist/types/api/sale/SaleService.d.ts

@@ -16,9 +16,9 @@ export declare class SaleService {
     #private;
     constructor(client: Client);
     priceFormationCreate(bean: PriceFormation): Promise<PriceFormation>;
-    priceFormationDelete(id: number): Promise<void>;
+    priceFormationDelete(id: number): Promise<PriceFormation>;
     priceFormationItemCreate(bean: PriceFormationItem): Promise<PriceFormationItem>;
-    priceFormationItemDelete(id: number): Promise<void>;
+    priceFormationItemDelete(id: number): Promise<PriceFormationItem>;
     priceFormationItemRead(search: any): Promise<PriceFormationItem[]>;
     priceFormationItemReadById(id: number): Promise<PriceFormationItem>;
     priceFormationItemUpdate(bean: PriceFormationItem): Promise<PriceFormationItem>;
@@ -29,9 +29,9 @@ export declare class SaleService {
     priceFormationReadById(id: number): Promise<PriceFormation>;
     priceFormationUpdate(bean: PriceFormation): Promise<PriceFormation>;
     priceListCreate(bean: PriceList): Promise<PriceList>;
-    priceListDelete(id: number): Promise<void>;
+    priceListDelete(id: number): Promise<PriceList>;
     priceListItemCreate(bean: PriceListItem): Promise<PriceListItem>;
-    priceListItemDelete(id: number): Promise<void>;
+    priceListItemDelete(id: number): Promise<PriceListItem>;
     priceListItemRead(search: any): Promise<PriceListItem[]>;
     priceListItemReadById(id: number): Promise<PriceListItem>;
     priceListItemUpdate(bean: PriceListItem): Promise<PriceListItem>;
@@ -39,9 +39,9 @@ export declare class SaleService {
     priceListReadById(id: number): Promise<PriceList>;
     priceListUpdate(bean: PriceList): Promise<PriceList>;
     quoteCreate(bean: Quote): Promise<Quote>;
-    quoteDelete(id: number): Promise<void>;
+    quoteDelete(id: number): Promise<Quote>;
     quoteItemCreate(bean: QuoteItem): Promise<QuoteItem>;
-    quoteItemDelete(id: number): Promise<void>;
+    quoteItemDelete(id: number): Promise<QuoteItem>;
     quoteItemOpFill(id: number, args: any): Promise<QuoteItem>;
     quoteItemRead(search: any): Promise<QuoteItem[]>;
     quoteItemReadById(id: number): Promise<QuoteItem>;
@@ -63,9 +63,9 @@ export declare class SaleService {
     quoteReadById(id: number): Promise<Quote>;
     quoteUpdate(bean: Quote): Promise<Quote>;
     saleCreate(bean: Sale): Promise<Sale>;
-    saleDelete(id: number): Promise<void>;
+    saleDelete(id: number): Promise<Sale>;
     saleItemCreate(bean: SaleItem): Promise<SaleItem>;
-    saleItemDelete(id: number): Promise<void>;
+    saleItemDelete(id: number): Promise<SaleItem>;
     saleItemRead(search: any): Promise<SaleItem[]>;
     saleItemReadById(id: number): Promise<SaleItem>;
     saleItemUpdate(bean: SaleItem): Promise<SaleItem>;
@@ -87,12 +87,12 @@ export declare class SaleService {
     saleOpShipmentAssignRevert(id: number): Promise<Sale>;
     saleOpUpdate(bean: Sale): Promise<Sale>;
     salePaymentCreate(bean: SalePayment): Promise<SalePayment>;
-    salePaymentDelete(id: number): Promise<void>;
+    salePaymentDelete(id: number): Promise<SalePayment>;
     salePaymentRead(search: any): Promise<SalePayment[]>;
     salePaymentReadById(id: number): Promise<SalePayment>;
     salePaymentUpdate(bean: SalePayment): Promise<SalePayment>;
     saleProfileCreate(bean: SaleProfile): Promise<SaleProfile>;
-    saleProfileDelete(id: number): Promise<void>;
+    saleProfileDelete(id: number): Promise<SaleProfile>;
     saleProfileRead(search: any): Promise<SaleProfile[]>;
     saleProfileReadById(id: number): Promise<SaleProfile>;
     saleProfileUpdate(bean: SaleProfile): Promise<SaleProfile>;
@@ -100,7 +100,7 @@ export declare class SaleService {
     saleReadById(id: number): Promise<Sale>;
     saleUpdate(bean: Sale): Promise<Sale>;
     salesCommissionCreate(bean: SalesCommission): Promise<SalesCommission>;
-    salesCommissionDelete(id: number): Promise<void>;
+    salesCommissionDelete(id: number): Promise<SalesCommission>;
     salesCommissionRead(search: any): Promise<SalesCommission[]>;
     salesCommissionReadById(id: number): Promise<SalesCommission>;
     salesCommissionUpdate(bean: SalesCommission): Promise<SalesCommission>;

package/dist/types/api/shipping/ShippingService.d.ts

@@ -4,7 +4,7 @@ export declare class ShippingService {
     #private;
     constructor(client: Client);
     shipmentCreate(bean: Shipment): Promise<Shipment>;
-    shipmentDelete(id: number): Promise<void>;
+    shipmentDelete(id: number): Promise<Shipment>;
     shipmentOpApprove(id: number): Promise<Shipment>;
     shipmentOpApproveRevert(id: number): Promise<Shipment>;
     shipmentOpCheckFinish(id: number): Promise<Shipment>;

package/dist/types/api/supply/reservation/ReservationService.d.ts

@@ -4,7 +4,7 @@ export declare class ReservationService {
     #private;
     constructor(client: Client);
     reservationCreate(args: any): Promise<Reservation>;
-    reservationDelete(id: number): Promise<void>;
+    reservationDelete(id: number): Promise<Reservation>;
     reservationRead(search: any): Promise<Reservation[]>;
     reservationReadById(id: number): Promise<Reservation>;
     reservationUpdate(bean: Reservation): Promise<Reservation>;

package/dist/types/api/system/SystemService.d.ts

@@ -12,9 +12,10 @@ export declare class SystemService {
     lockOpAcquire(id: string, waitTime: string, leaseTime: string): Promise<string>;
     lockOpExtend(id: string, lockToken: string, leaseTime: string): Promise<void>;
     lockOpRelease(id: string, lockToken: string): Promise<void>;
+    metricsRead(): Promise<Object>;
     resourcesRead(): Promise<Object>;
     statusCreate(bean: Status): Promise<Status>;
-    statusDelete(id: number): Promise<void>;
+    statusDelete(id: number): Promise<Status>;
     statusRead(search: any): Promise<Status[]>;
     statusReadById(id: number): Promise<Status>;
     statusUpdate(bean: Status): Promise<Status>;

package/dist/types/api/system/audit/AuditService.d.ts

@@ -12,7 +12,7 @@ export declare class AuditService {
     sourceRead(search: any): Promise<Source[]>;
     sourceReadById(id: number): Promise<Source>;
     userLogCreate(args: any): Promise<Log>;
-    userLogDelete(id: number): Promise<void>;
+    userLogDelete(id: number): Promise<Log>;
     userLogRead(search: any): Promise<Log[]>;
     userLogReadById(id: number): Promise<Log>;
     userLogUpdate(bean: Log): Promise<Log>;

package/dist/types/api/system/automation/AutomationService.d.ts

@@ -6,19 +6,19 @@ export declare class AutomationService {
     #private;
     constructor(client: Client);
     agentCreate(bean: Agent): Promise<Agent>;
-    agentDelete(id: number): Promise<void>;
+    agentDelete(id: number): Promise<Agent>;
     agentOpExecute(id: number, parameters: Object): Promise<void>;
     agentRead(search: any): Promise<Agent[]>;
     agentReadById(id: number): Promise<Agent>;
     agentUpdate(bean: Agent): Promise<Agent>;
     scheduleCreate(bean: Schedule): Promise<Schedule>;
-    scheduleDelete(id: number): Promise<void>;
+    scheduleDelete(id: number): Promise<Schedule>;
     scheduleOpExecute(id: number): Promise<Schedule>;
     scheduleRead(search: any): Promise<Schedule[]>;
     scheduleReadById(id: number): Promise<Schedule>;
     scheduleUpdate(bean: Schedule): Promise<Schedule>;
     watcherCreate(bean: Watcher): Promise<Watcher>;
-    watcherDelete(id: number): Promise<void>;
+    watcherDelete(id: number): Promise<Watcher>;
     watcherRead(search: any): Promise<Watcher[]>;
     watcherReadById(id: number): Promise<Watcher>;
     watcherUpdate(bean: Watcher): Promise<Watcher>;

package/dist/types/api/system/data/DataService.d.ts

@@ -5,10 +5,10 @@ export declare class DataService {
     #private;
     constructor(client: Client);
     dataSourceCreate(bean: DataSource): Promise<DataSource>;
-    dataSourceDelete(id: number): Promise<void>;
+    dataSourceDelete(id: number): Promise<DataSource>;
     dataSourceOpRead(args: any): Promise<string[]>;
     dataSourceParameterCreate(bean: DataSourceParameter): Promise<DataSourceParameter>;
-    dataSourceParameterDelete(id: number): Promise<void>;
+    dataSourceParameterDelete(id: number): Promise<DataSourceParameter>;
     dataSourceParameterRead(search: any): Promise<DataSourceParameter[]>;
     dataSourceParameterReadById(id: number): Promise<DataSourceParameter>;
     dataSourceParameterUpdate(bean: DataSourceParameter): Promise<DataSourceParameter>;

package/dist/types/api/system/file/FileService.d.ts

@@ -3,8 +3,8 @@ import { File } from "./File.js";
 export declare class FileService {
     #private;
     constructor(client: Client);
-    fileCreate(args: File): Promise<File>;
-    fileDelete(id: number): Promise<void>;
+    fileCreate(bean: File): Promise<File>;
+    fileDelete(id: number): Promise<File>;
     fileOpReadContent(id: number): Promise<any>;
     fileRead(search: any): Promise<File[]>;
     fileReadById(id: number): Promise<File>;

package/dist/types/api/system/image/ImageService.d.ts

@@ -4,7 +4,7 @@ export declare class ImageService {
     #private;
     constructor(client: Client);
     imageCreate(bean: Image): Promise<Image>;
-    imageDelete(id: number): Promise<void>;
+    imageDelete(id: number): Promise<Image>;
     imageRead(search: any): Promise<Image[]>;
     imageReadById(id: number): Promise<Image>;
     imageUpdate(bean: Image): Promise<Image>;

package/dist/types/api/system/integration/IntegrationService.d.ts

@@ -6,13 +6,13 @@ import { Topic } from "./Topic.js";
 export declare class IntegrationService {
     #private;
     constructor(client: Client);
-    messageDelete(id: number): Promise<void>;
+    messageDelete(id: number): Promise<Message>;
     messageOpPost(args: any): Promise<Message>;
     messageOpTransfer(id: number, queueCode: string): Promise<Message>;
     messageRead(search: any): Promise<Message[]>;
     messageReadById(id: number): Promise<Message>;
     queueCreate(bean: Queue): Promise<Queue>;
-    queueDelete(id: number): Promise<void>;
+    queueDelete(id: number): Promise<Queue>;
     queueOpDeleteExpiredMessages(queueCode: string): Promise<void>;
     queueOpReadMessage(queueCode: string, maxMessages: any): Promise<Message[]>;
     queueOpReadMessageTimeout(queueCode: string, maxMessages: any, timeoutS: any): Promise<Message[]>;
@@ -20,12 +20,12 @@ export declare class IntegrationService {
     queueReadById(id: number): Promise<Queue>;
     queueUpdate(bean: Queue): Promise<Queue>;
     subscriptionCreate(bean: Subscription): Promise<Subscription>;
-    subscriptionDelete(id: number): Promise<void>;
+    subscriptionDelete(id: number): Promise<Subscription>;
     subscriptionRead(search: any): Promise<Subscription[]>;
     subscriptionReadById(id: number): Promise<Subscription>;
     subscriptionUpdate(bean: Subscription): Promise<Subscription>;
     topicCreate(bean: Topic): Promise<Topic>;
-    topicDelete(id: number): Promise<void>;
+    topicDelete(id: number): Promise<Topic>;
     topicOpPublish(args: any): Promise<void>;
     topicRead(search: any): Promise<Topic[]>;
     topicReadById(id: number): Promise<Topic>;

package/dist/types/api/system/mail/MailService.d.ts

@@ -5,7 +5,7 @@ export declare class MailService {
     #private;
     constructor(client: Client);
     mailerConfigCreate(bean: MailerConfig): Promise<MailerConfig>;
-    mailerConfigDelete(id: number): Promise<void>;
+    mailerConfigDelete(id: number): Promise<MailerConfig>;
     mailerConfigRead(search: any): Promise<MailerConfig[]>;
     mailerConfigReadById(id: number): Promise<MailerConfig>;
     mailerConfigUpdate(bean: MailerConfig): Promise<MailerConfig>;

package/dist/types/api/system/plugin/PluginService.d.ts

@@ -4,6 +4,6 @@ export declare class PluginService {
     #private;
     constructor(client: Client);
     pluginCreate(bean: any): Promise<Plugin>;
-    pluginDelete(id: number): Promise<void>;
+    pluginDelete(id: number): Promise<Plugin>;
     pluginRead(search: any): Promise<Plugin[]>;
 }

package/dist/types/api/system/printing/PrintingService.d.ts

@@ -6,10 +6,10 @@ export declare class PrintingService {
     #private;
     constructor(client: Client);
     printerCreate(bean: Printer): Promise<Printer>;
-    printerDelete(id: number): Promise<void>;
-    printerJobCreate(bean: any): Promise<PrinterJob>;
+    printerDelete(id: number): Promise<Printer>;
+    printerJobCreate(args: any): Promise<PrinterJob>;
     printerJobDataReadById(id: number): Promise<PrinterJobData>;
-    printerJobDelete(id: number): Promise<void>;
+    printerJobDelete(id: number): Promise<PrinterJob>;
     printerJobOpFetch(id: number): Promise<PrinterJobData>;
     printerJobOpPrinted(id: number): Promise<void>;
     printerJobOpUnlock(id: number): Promise<void>;

package/dist/types/api/system/report/ReportService.d.ts

@@ -5,7 +5,7 @@ export declare class ReportService {
     #private;
     constructor(client: Client);
     reportCreate(bean: Report): Promise<Report>;
-    reportDelete(id: number): Promise<void>;
+    reportDelete(id: number): Promise<Report>;
     reportOpClone(id: number, newCode: string): Promise<Report>;
     reportOpGenerate(args: any): Promise<any>;
     reportOpPrint(args: any): Promise<any>;

package/dist/types/api/system/security/SecurityService.d.ts

@@ -13,39 +13,39 @@ export declare class SecurityService {
     #private;
     constructor(client: Client);
     accessPointCreate(bean: AccessPoint): Promise<AccessPoint>;
-    accessPointDelete(id: number): Promise<void>;
+    accessPointDelete(id: number): Promise<AccessPoint>;
     accessPointOpValidate(code: string): Promise<boolean>;
     accessPointRead(search: any): Promise<AccessPoint[]>;
     accessPointReadById(id: number): Promise<AccessPoint>;
     accessPointUpdate(bean: AccessPoint): Promise<AccessPoint>;
     accessProfileCreate(bean: AccessProfile): Promise<AccessProfile>;
-    accessProfileDelete(id: number): Promise<void>;
+    accessProfileDelete(id: number): Promise<AccessProfile>;
     accessProfileRead(search: any): Promise<AccessProfile[]>;
     accessProfileReadById(id: number): Promise<AccessProfile>;
     accessProfileUpdate(bean: AccessProfile): Promise<AccessProfile>;
     grantCreate(bean: Grant): Promise<Grant>;
-    grantDelete(id: number): Promise<void>;
+    grantDelete(id: number): Promise<Grant>;
     grantRead(search: any): Promise<Grant[]>;
     grantReadById(id: number): Promise<Grant>;
     groupCreate(bean: Group): Promise<Group>;
-    groupDelete(id: number): Promise<void>;
+    groupDelete(id: number): Promise<Group>;
     groupOpClone(id: number, args: any): Promise<Group>;
     groupRead(search: any): Promise<Group[]>;
     groupReadById(id: number): Promise<Group>;
     groupUpdate(bean: Group): Promise<Group>;
     keyStoreCreate(bean: KeyStore): Promise<KeyStore>;
-    keyStoreDelete(id: number): Promise<void>;
+    keyStoreDelete(id: number): Promise<KeyStore>;
     keyStoreOpReadContent(id: number): Promise<any>;
     keyStoreRead(search: any): Promise<KeyStore[]>;
     keyStoreReadById(id: number): Promise<KeyStore>;
     keyStoreUpdate(bean: KeyStore): Promise<KeyStore>;
     roleAccessPointCreate(bean: RoleAccessPoint): Promise<RoleAccessPoint>;
-    roleAccessPointDelete(id: number): Promise<void>;
+    roleAccessPointDelete(id: number): Promise<RoleAccessPoint>;
     roleAccessPointRead(search: any): Promise<RoleAccessPoint[]>;
     roleAccessPointReadById(id: number): Promise<RoleAccessPoint>;
     roleRead(search: any): Promise<Role[]>;
     roleReadById(id: number): Promise<Role>;
-    sessionDelete(id: any): Promise<void>;
+    sessionDelete(id: any): Promise<Session>;
     sessionOpGetCurrent(): Promise<Session>;
     sessionRead(search: any): Promise<Session[]>;
     sessionReadById(id: any): Promise<Session>;
@@ -55,7 +55,7 @@ export declare class SecurityService {
     tokenOpRequest(args: any): Promise<string>;
     tokenOpRequestPermanent(args: any): Promise<string>;
     userCreate(bean: User): Promise<User>;
-    userDelete(id: number): Promise<void>;
+    userDelete(id: number): Promise<User>;
     userOpActivate(id: number): Promise<void>;
     userOpAuthenticate(args: any): Promise<boolean>;
     userOpChangeEmail(args: any): Promise<void>;