@rytass/wms-module-core 0.1.0

package/lib/models/metadata/loader-unit.entity.js

@@ -0,0 +1,21 @@
+import { __decorate, __metadata } from 'tslib';
+import { PrimaryColumn, Entity } from 'typeorm';
+
+const LoaderUnitEntity = Symbol('LoaderUnitEntity');
+let LoaderUnitEntityClass = class LoaderUnitEntityClass {
+    id;
+    type;
+};
+__decorate([
+    PrimaryColumn('varchar'),
+    __metadata("design:type", String)
+], LoaderUnitEntityClass.prototype, "id", void 0);
+__decorate([
+    PrimaryColumn('varchar'),
+    __metadata("design:type", String)
+], LoaderUnitEntityClass.prototype, "type", void 0);
+LoaderUnitEntityClass = __decorate([
+    Entity('loader_units')
+], LoaderUnitEntityClass);
+
+export { LoaderUnitEntity, LoaderUnitEntityClass };

package/lib/models/metadata/loader.entity.d.ts

@@ -0,0 +1,21 @@
+import { LoaderTypeEntityClass } from './loader-type.entity';
+import { LocationEntity } from '@rytass/wms-base-nestjs-module';
+export declare const LoadersEntity: unique symbol;
+export declare class LoadersEntityClass {
+    id: string;
+    typeId: string;
+    serialId: string;
+    locationId: string;
+    length: number | null;
+    width: number | null;
+    height: number | null;
+    sizeUnit: string | null;
+    volume: number | null;
+    volumeUnit: string | null;
+    note: string | null;
+    isActive: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    type: LoaderTypeEntityClass;
+    location: LocationEntity;
+}

package/lib/models/metadata/loader.entity.js

@@ -0,0 +1,98 @@
+import { __decorate, __metadata } from 'tslib';
+import { PrimaryGeneratedColumn, Column, Index, CreateDateColumn, UpdateDateColumn, ManyToOne, JoinColumn, Entity, TableInheritance } from 'typeorm';
+import { LoaderTypeEntityClass } from './loader-type.entity.js';
+import { LocationEntity } from '@rytass/wms-base-nestjs-module';
+
+const LoadersEntity = Symbol('LoadersEntity');
+let LoadersEntityClass = class LoadersEntityClass {
+    id;
+    typeId;
+    serialId;
+    locationId;
+    length;
+    width;
+    height;
+    sizeUnit;
+    volume;
+    volumeUnit;
+    note;
+    isActive;
+    createdAt;
+    updatedAt;
+    type;
+    location;
+};
+__decorate([
+    PrimaryGeneratedColumn('uuid'),
+    __metadata("design:type", String)
+], LoadersEntityClass.prototype, "id", void 0);
+__decorate([
+    Column({ type: 'uuid' }),
+    Index(),
+    __metadata("design:type", String)
+], LoadersEntityClass.prototype, "typeId", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], LoadersEntityClass.prototype, "serialId", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    Index(),
+    __metadata("design:type", String)
+], LoadersEntityClass.prototype, "locationId", void 0);
+__decorate([
+    Column({ type: 'numeric', nullable: true }),
+    __metadata("design:type", Object)
+], LoadersEntityClass.prototype, "length", void 0);
+__decorate([
+    Column({ type: 'numeric', nullable: true }),
+    __metadata("design:type", Object)
+], LoadersEntityClass.prototype, "width", void 0);
+__decorate([
+    Column({ type: 'numeric', nullable: true }),
+    __metadata("design:type", Object)
+], LoadersEntityClass.prototype, "height", void 0);
+__decorate([
+    Column({ type: 'varchar', nullable: true }),
+    __metadata("design:type", Object)
+], LoadersEntityClass.prototype, "sizeUnit", void 0);
+__decorate([
+    Column({ type: 'numeric', nullable: true }),
+    __metadata("design:type", Object)
+], LoadersEntityClass.prototype, "volume", void 0);
+__decorate([
+    Column({ type: 'varchar', nullable: true }),
+    __metadata("design:type", Object)
+], LoadersEntityClass.prototype, "volumeUnit", void 0);
+__decorate([
+    Column({ type: 'text', nullable: true }),
+    __metadata("design:type", Object)
+], LoadersEntityClass.prototype, "note", void 0);
+__decorate([
+    Column({ type: 'boolean', default: true }),
+    __metadata("design:type", Boolean)
+], LoadersEntityClass.prototype, "isActive", void 0);
+__decorate([
+    CreateDateColumn({ type: 'timestamptz' }),
+    __metadata("design:type", Date)
+], LoadersEntityClass.prototype, "createdAt", void 0);
+__decorate([
+    UpdateDateColumn({ type: 'timestamptz' }),
+    __metadata("design:type", Date)
+], LoadersEntityClass.prototype, "updatedAt", void 0);
+__decorate([
+    ManyToOne('loader_types'),
+    JoinColumn({ name: 'typeId', referencedColumnName: 'id' }),
+    __metadata("design:type", LoaderTypeEntityClass)
+], LoadersEntityClass.prototype, "type", void 0);
+__decorate([
+    ManyToOne('locations'),
+    JoinColumn({ name: 'locationId', referencedColumnName: 'id' }),
+    __metadata("design:type", LocationEntity)
+], LoadersEntityClass.prototype, "location", void 0);
+LoadersEntityClass = __decorate([
+    Entity('loaders'),
+    TableInheritance({ column: { type: 'varchar', name: 'entityName' } })
+], LoadersEntityClass);
+
+export { LoadersEntity, LoadersEntityClass };

package/lib/models/metadata/location.entity.d.ts

@@ -0,0 +1,8 @@
+import { LocationEntity as BaseLocationEntity } from '@rytass/wms-base-nestjs-module';
+export declare const LocationEntity: unique symbol;
+export declare const WarehouseMapEntity: unique symbol;
+export declare class LocationEntityClass extends BaseLocationEntity {
+    description: string;
+    isActive?: boolean;
+    parentId?: string | null;
+}

package/lib/models/metadata/location.entity.js

@@ -0,0 +1,28 @@
+import { __decorate, __metadata } from 'tslib';
+import { LocationEntity as LocationEntity$1 } from '@rytass/wms-base-nestjs-module';
+import { Column, RelationId, ChildEntity } from 'typeorm';
+
+const LocationEntity = Symbol('LocationEntity');
+const WarehouseMapEntity = Symbol('WarehouseMapEntity');
+let LocationEntityClass = class LocationEntityClass extends LocationEntity$1 {
+    description;
+    isActive;
+    parentId;
+};
+__decorate([
+    Column({ type: 'text' }),
+    __metadata("design:type", String)
+], LocationEntityClass.prototype, "description", void 0);
+__decorate([
+    Column({ type: 'bool', default: true }),
+    __metadata("design:type", Boolean)
+], LocationEntityClass.prototype, "isActive", void 0);
+__decorate([
+    RelationId((location) => location.parent),
+    __metadata("design:type", Object)
+], LocationEntityClass.prototype, "parentId", void 0);
+LocationEntityClass = __decorate([
+    ChildEntity()
+], LocationEntityClass);
+
+export { LocationEntity, LocationEntityClass, WarehouseMapEntity };

package/lib/models/metadata/material-unit.entity.d.ts

@@ -0,0 +1,11 @@
+import { MaterialEntityClass } from './material.entity';
+export declare const MaterialUnitEntity: unique symbol;
+export declare class MaterialUnitEntityClass {
+    id: string;
+    materialId: string;
+    unit: string;
+    conversionFactor: number;
+    isActive: boolean;
+    createdAt: Date;
+    material: MaterialEntityClass;
+}

package/lib/models/metadata/material-unit.entity.js

@@ -0,0 +1,51 @@
+import { __decorate, __metadata } from 'tslib';
+import { PrimaryGeneratedColumn, Column, Index, CreateDateColumn, ManyToOne, JoinColumn, Entity, Unique, TableInheritance } from 'typeorm';
+import { MaterialEntityClass } from './material.entity.js';
+
+const MaterialUnitEntity = Symbol('MaterialUnitEntity');
+let MaterialUnitEntityClass = class MaterialUnitEntityClass {
+    id;
+    materialId;
+    unit;
+    conversionFactor;
+    isActive;
+    createdAt;
+    material;
+};
+__decorate([
+    PrimaryGeneratedColumn('uuid'),
+    __metadata("design:type", String)
+], MaterialUnitEntityClass.prototype, "id", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    Index(),
+    __metadata("design:type", String)
+], MaterialUnitEntityClass.prototype, "materialId", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], MaterialUnitEntityClass.prototype, "unit", void 0);
+__decorate([
+    Column({ type: 'numeric' }),
+    __metadata("design:type", Number)
+], MaterialUnitEntityClass.prototype, "conversionFactor", void 0);
+__decorate([
+    Column({ type: 'boolean', default: true }),
+    __metadata("design:type", Boolean)
+], MaterialUnitEntityClass.prototype, "isActive", void 0);
+__decorate([
+    CreateDateColumn({ type: 'timestamptz' }),
+    __metadata("design:type", Date)
+], MaterialUnitEntityClass.prototype, "createdAt", void 0);
+__decorate([
+    ManyToOne('materials'),
+    JoinColumn({ name: 'materialId', referencedColumnName: 'id' }),
+    __metadata("design:type", MaterialEntityClass)
+], MaterialUnitEntityClass.prototype, "material", void 0);
+MaterialUnitEntityClass = __decorate([
+    Entity('material_units'),
+    Unique(['materialId', 'unit']),
+    TableInheritance({ column: { type: 'varchar', name: 'entityName' } })
+], MaterialUnitEntityClass);
+
+export { MaterialUnitEntity, MaterialUnitEntityClass };

package/lib/models/metadata/material.entity.d.ts

@@ -0,0 +1,7 @@
+import { MaterialEntity as BaseMaterialEntity } from '@rytass/wms-base-nestjs-module';
+export declare const MaterialEntity: unique symbol;
+export declare class MaterialEntityClass extends BaseMaterialEntity {
+    description: string;
+    baseUnit: string;
+    isActive: boolean;
+}

package/lib/models/metadata/material.entity.js

@@ -0,0 +1,28 @@
+import { __decorate, __metadata } from 'tslib';
+import { Column, Index, ChildEntity } from 'typeorm';
+import { MaterialEntity as MaterialEntity$1 } from '@rytass/wms-base-nestjs-module';
+
+const MaterialEntity = Symbol('MaterialEntity');
+let MaterialEntityClass = class MaterialEntityClass extends MaterialEntity$1 {
+    description;
+    baseUnit;
+    isActive;
+};
+__decorate([
+    Column({ type: 'text' }),
+    Index(),
+    __metadata("design:type", String)
+], MaterialEntityClass.prototype, "description", void 0);
+__decorate([
+    Column({ type: 'varchar' }),
+    __metadata("design:type", String)
+], MaterialEntityClass.prototype, "baseUnit", void 0);
+__decorate([
+    Column({ type: 'boolean', default: true }),
+    __metadata("design:type", Boolean)
+], MaterialEntityClass.prototype, "isActive", void 0);
+MaterialEntityClass = __decorate([
+    ChildEntity()
+], MaterialEntityClass);
+
+export { MaterialEntity, MaterialEntityClass };

package/lib/models/metadata/sale-order.entity.d.ts

@@ -0,0 +1,5 @@
+export declare const SaleOrderEntity: unique symbol;
+export declare class SaleOrderEntityClass {
+    id: string;
+    serialId: string;
+}

package/lib/models/metadata/sale-order.entity.js

@@ -0,0 +1,21 @@
+import { __decorate, __metadata } from 'tslib';
+import { PrimaryColumn, Entity } from 'typeorm';
+
+const SaleOrderEntity = Symbol('SaleOrderEntity');
+let SaleOrderEntityClass = class SaleOrderEntityClass {
+    id;
+    serialId;
+};
+__decorate([
+    PrimaryColumn('varchar'),
+    __metadata("design:type", String)
+], SaleOrderEntityClass.prototype, "id", void 0);
+__decorate([
+    PrimaryColumn('varchar'),
+    __metadata("design:type", String)
+], SaleOrderEntityClass.prototype, "serialId", void 0);
+SaleOrderEntityClass = __decorate([
+    Entity('sale_orders')
+], SaleOrderEntityClass);
+
+export { SaleOrderEntity, SaleOrderEntityClass };

package/lib/models/metadata/stock.entity.d.ts

@@ -0,0 +1,8 @@
+import { StockEntity as BaseStockEntity } from '@rytass/wms-base-nestjs-module';
+import { StockStatus } from '../../constants/stock-status';
+export declare const StockEntity: unique symbol;
+export declare class StockEntityClass extends BaseStockEntity {
+    loaderId: string;
+    rollbackedAt: Date | null;
+    status: StockStatus;
+}

package/lib/models/metadata/stock.entity.js

@@ -0,0 +1,29 @@
+import { __decorate, __metadata } from 'tslib';
+import { StockEntity as StockEntity$1 } from '@rytass/wms-base-nestjs-module';
+import { Column, Index, JoinColumn, ChildEntity } from 'typeorm';
+import '../../constants/stock-status.js';
+
+const StockEntity = Symbol('StockEntity');
+let StockEntityClass = class StockEntityClass extends StockEntity$1 {
+    loaderId;
+    rollbackedAt;
+    status;
+};
+__decorate([
+    Column({ type: 'varchar' }),
+    Index(),
+    __metadata("design:type", String)
+], StockEntityClass.prototype, "loaderId", void 0);
+__decorate([
+    Column({ type: 'timestamptz', nullable: true }),
+    __metadata("design:type", Object)
+], StockEntityClass.prototype, "rollbackedAt", void 0);
+__decorate([
+    JoinColumn(),
+    __metadata("design:type", String)
+], StockEntityClass.prototype, "status", void 0);
+StockEntityClass = __decorate([
+    ChildEntity()
+], StockEntityClass);
+
+export { StockEntity, StockEntityClass };

package/lib/models/metadata/unit.entity.d.ts

@@ -0,0 +1,5 @@
+export declare const UnitEntity: unique symbol;
+export declare class UnitEntityClass {
+    id: string;
+    key: string;
+}

package/lib/models/metadata/unit.entity.js

@@ -0,0 +1,21 @@
+import { __decorate, __metadata } from 'tslib';
+import { PrimaryGeneratedColumn, Column, Entity } from 'typeorm';
+
+const UnitEntity = Symbol('UnitEntity');
+let UnitEntityClass = class UnitEntityClass {
+    id;
+    key;
+};
+__decorate([
+    PrimaryGeneratedColumn('uuid'),
+    __metadata("design:type", String)
+], UnitEntityClass.prototype, "id", void 0);
+__decorate([
+    Column({ type: 'varchar', unique: true }),
+    __metadata("design:type", String)
+], UnitEntityClass.prototype, "key", void 0);
+UnitEntityClass = __decorate([
+    Entity('units')
+], UnitEntityClass);
+
+export { UnitEntity, UnitEntityClass };

package/lib/models/models.module.d.ts

@@ -0,0 +1,6 @@
+export declare const ResolvedEntitiesProviders: {
+    provide: symbol;
+    useValue: new () => object;
+}[];
+export declare class ModelsModule {
+}

package/lib/models/models.module.js

@@ -0,0 +1,122 @@
+import { __decorate } from 'tslib';
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { WarehouseMapEntity as WarehouseMapEntity$1 } from '@rytass/wms-base-nestjs-module/models/warehouse-map.entity';
+import { BatchEntity, BatchEntityClass } from './metadata/batch.entity.js';
+import { BatchGroupEntity, BatchGroupEntityClass } from './metadata/batch-group.entity.js';
+import { LoadersEntity, LoadersEntityClass } from './metadata/loader.entity.js';
+import { LoaderTypeEntity, LoaderTypeEntityClass } from './metadata/loader-type.entity.js';
+import { LoaderUnitEntity, LoaderUnitEntityClass } from './metadata/loader-unit.entity.js';
+import { LocationEntity, LocationEntityClass, WarehouseMapEntity } from './metadata/location.entity.js';
+import { MaterialEntity, MaterialEntityClass } from './metadata/material.entity.js';
+import { MaterialUnitEntity, MaterialUnitEntityClass } from './metadata/material-unit.entity.js';
+import { SaleOrderEntity, SaleOrderEntityClass } from './metadata/sale-order.entity.js';
+import { StockEntity, StockEntityClass } from './metadata/stock.entity.js';
+import { UnitEntity, UnitEntityClass } from './metadata/unit.entity.js';
+import { ReceiveInventoryOrderItemEntity, ReceiveInventoryOrderItemEntityClass } from './extensions/receive-inventory-order/receive-inventory-order-item.entity.js';
+import { ReceiveInventoryOrderEntity, ReceiveInventoryOrderEntityClass } from './extensions/receive-inventory-order/receive-inventory-order.entity.js';
+import { ReceiveInventoryOrderChangeEntity, ReceiveInventoryOrderChangeEntityClass } from './extensions/receive-inventory-order/receive-inventory-order-change.entity.js';
+import { ShipInventoryOrderItemEntity, ShipInventoryOrderItemEntityClass } from './extensions/ship-inventory-order/ship-inventory-order-item.entity.js';
+import { ShipInventoryOrderEntity, ShipInventoryOrderEntityClass } from './extensions/ship-inventory-order/ship-inventory-order.entity.js';
+import { ShipInventoryOrderReferenceEntity, ShipInventoryOrderReferenceEntityClass } from './extensions/ship-inventory-order/ship-inventory-order-reference.entity.js';
+import { ShipInventoryOrderChangeEntity, ShipInventoryOrderChangeEntityClass } from './extensions/ship-inventory-order/ship-inventory-order-change.entity.js';
+import { TransferOrderEntity, TransferOrderEntityClass } from './extensions/transfer-order/transfer-order.entity.js';
+import { TransferOrderItemEntity, TransferOrderItemEntityClass } from './extensions/transfer-order/transfer-order-item.entity.js';
+import { TransferOrderChangeEntity, TransferOrderChangeEntityClass } from './extensions/transfer-order/transfer-order-change.entity.js';
+import { HoldInventoryOrderEntity, HoldInventoryOrderEntityClass } from './extensions/hold-inventory-order/hold-inventory-order.entity.js';
+import { HoldInventoryOrderItemEntity, HoldInventoryOrderItemEntityClass } from './extensions/hold-inventory-order/hold-inventory-order-item.entity.js';
+import { HoldInventoryOrderChangeEntity, HoldInventoryOrderChangeEntityClass } from './extensions/hold-inventory-order/hold-inventory-order-change.entity.js';
+import { AllocateInventoryOrderEntity, AllocateInventoryOrderEntityClass } from './extensions/allocate-inventory-order/allocate-inventory-order.entity.js';
+import { AllocateInventoryOrderItemEntity, AllocateInventoryOrderItemEntityClass } from './extensions/allocate-inventory-order/allocate-inventory-order-item.entity.js';
+import { AllocateInventoryOrderChangeEntity, AllocateInventoryOrderChangeEntityClass } from './extensions/allocate-inventory-order/allocate-inventory-order-change.entity.js';
+import { SplitBatchOrderEntity, SplitBatchOrderEntityClass } from './extensions/split-batch-order/split-batch-order.entity.js';
+import { SplitBatchOrderItemEntity, SplitBatchOrderItemEntityClass } from './extensions/split-batch-order/split-batch-order-item.entity.js';
+import { SplitBatchOrderChangeEntity, SplitBatchOrderChangeEntityClass } from './extensions/split-batch-order/split-batch-order-change.entity.js';
+import { MergeBatchOrderEntity, MergeBatchOrderEntityClass } from './extensions/merge-batch-order/merge-batch-order.entity.js';
+import { MergeBatchOrderItemEntity, MergeBatchOrderItemEntityClass } from './extensions/merge-batch-order/merge-batch-order-item.entity.js';
+import { MergeBatchOrderChangeEntity, MergeBatchOrderChangeEntityClass } from './extensions/merge-batch-order/merge-batch-order-change.entity.js';
+import { ReclassifyInventoryOrderEntity, ReclassifyInventoryOrderEntityClass } from './extensions/reclassify-inventory-order/reclassify-inventory-order.entity.js';
+import { ReclassifyInventoryOrderItemEntity, ReclassifyInventoryOrderItemEntityClass } from './extensions/reclassify-inventory-order/reclassify-inventory-order-item.entity.js';
+import { ReclassifyInventoryOrderChangeEntity, ReclassifyInventoryOrderChangeEntityClass } from './extensions/reclassify-inventory-order/reclassify-inventory-order-change.entity.js';
+import { TransferVendorOrderEntity, TransferVendorOrderEntityClass } from './extensions/transfer-vendor-order/transfer-vendor-order.entity.js';
+import { TransferVendorOrderItemEntity, TransferVendorOrderItemEntityClass } from './extensions/transfer-vendor-order/transfer-vendor-order-item.entity.js';
+import { TransferVendorOrderChangeEntity, TransferVendorOrderChangeEntityClass } from './extensions/transfer-vendor-order/transfer-vendor-order-change.entity.js';
+import { QualityInspectionOrderEntity, QualityInspectionOrderEntityClass } from './extensions/quality-inspection-order/quality-inspection-order.entity.js';
+import { QualityInspectionOrderItemEntity, QualityInspectionOrderItemEntityClass } from './extensions/quality-inspection-order/quality-inspection-order-item.entity.js';
+import { QualityInspectionOrderChangeEntity, QualityInspectionOrderChangeEntityClass } from './extensions/quality-inspection-order/quality-inspection-order-change.entity.js';
+import { TransferCustomerOrderEntity, TransferCustomerOrderEntityClass } from './extensions/transfer-customer-order/transfer-customer-order.entity.js';
+import { TransferCustomerOrderItemEntity, TransferCustomerOrderItemEntityClass } from './extensions/transfer-customer-order/transfer-customer-order-item.entity.js';
+import { TransferCustomerOrderChangeEntity, TransferCustomerOrderChangeEntityClass } from './extensions/transfer-customer-order/transfer-customer-order-change.entity.js';
+import { ScrapeOrderEntity, ScrapeOrderEntityClass } from './extensions/scrape-order/scrape-order.entity.js';
+import { ScrapeOrderItemEntity, ScrapeOrderItemEntityClass } from './extensions/scrape-order/scrape-order-item.entity.js';
+import { ScrapeOrderChangeEntity, ScrapeOrderChangeEntityClass } from './extensions/scrape-order/scrape-order-change.entity.js';
+
+const entities = [
+    [UnitEntity, UnitEntityClass],
+    [MaterialEntity, MaterialEntityClass],
+    [BatchEntity, BatchEntityClass],
+    [BatchGroupEntity, BatchGroupEntityClass],
+    [MaterialUnitEntity, MaterialUnitEntityClass],
+    [LoadersEntity, LoadersEntityClass],
+    [LoaderTypeEntity, LoaderTypeEntityClass],
+    [LoaderUnitEntity, LoaderUnitEntityClass],
+    [StockEntity, StockEntityClass],
+    [LocationEntity, LocationEntityClass],
+    [WarehouseMapEntity, WarehouseMapEntity$1],
+    [SaleOrderEntity, SaleOrderEntityClass],
+    [ReceiveInventoryOrderEntity, ReceiveInventoryOrderEntityClass],
+    [ReceiveInventoryOrderItemEntity, ReceiveInventoryOrderItemEntityClass],
+    [ReceiveInventoryOrderChangeEntity, ReceiveInventoryOrderChangeEntityClass],
+    [ShipInventoryOrderEntity, ShipInventoryOrderEntityClass],
+    [ShipInventoryOrderItemEntity, ShipInventoryOrderItemEntityClass],
+    [ShipInventoryOrderReferenceEntity, ShipInventoryOrderReferenceEntityClass],
+    [ShipInventoryOrderChangeEntity, ShipInventoryOrderChangeEntityClass],
+    [TransferOrderEntity, TransferOrderEntityClass],
+    [TransferOrderItemEntity, TransferOrderItemEntityClass],
+    [TransferOrderChangeEntity, TransferOrderChangeEntityClass],
+    [HoldInventoryOrderEntity, HoldInventoryOrderEntityClass],
+    [HoldInventoryOrderItemEntity, HoldInventoryOrderItemEntityClass],
+    [HoldInventoryOrderChangeEntity, HoldInventoryOrderChangeEntityClass],
+    [AllocateInventoryOrderEntity, AllocateInventoryOrderEntityClass],
+    [AllocateInventoryOrderItemEntity, AllocateInventoryOrderItemEntityClass],
+    [AllocateInventoryOrderChangeEntity, AllocateInventoryOrderChangeEntityClass],
+    [SplitBatchOrderEntity, SplitBatchOrderEntityClass],
+    [SplitBatchOrderItemEntity, SplitBatchOrderItemEntityClass],
+    [SplitBatchOrderChangeEntity, SplitBatchOrderChangeEntityClass],
+    [MergeBatchOrderEntity, MergeBatchOrderEntityClass],
+    [MergeBatchOrderItemEntity, MergeBatchOrderItemEntityClass],
+    [MergeBatchOrderChangeEntity, MergeBatchOrderChangeEntityClass],
+    [ReclassifyInventoryOrderEntity, ReclassifyInventoryOrderEntityClass],
+    [ReclassifyInventoryOrderItemEntity, ReclassifyInventoryOrderItemEntityClass],
+    [
+        ReclassifyInventoryOrderChangeEntity,
+        ReclassifyInventoryOrderChangeEntityClass,
+    ],
+    [TransferVendorOrderEntity, TransferVendorOrderEntityClass],
+    [TransferVendorOrderItemEntity, TransferVendorOrderItemEntityClass],
+    [TransferVendorOrderChangeEntity, TransferVendorOrderChangeEntityClass],
+    [QualityInspectionOrderEntity, QualityInspectionOrderEntityClass],
+    [QualityInspectionOrderItemEntity, QualityInspectionOrderItemEntityClass],
+    [QualityInspectionOrderChangeEntity, QualityInspectionOrderChangeEntityClass],
+    [TransferCustomerOrderEntity, TransferCustomerOrderEntityClass],
+    [TransferCustomerOrderItemEntity, TransferCustomerOrderItemEntityClass],
+    [TransferCustomerOrderChangeEntity, TransferCustomerOrderChangeEntityClass],
+    [ScrapeOrderEntity, ScrapeOrderEntityClass],
+    [ScrapeOrderItemEntity, ScrapeOrderItemEntityClass],
+    [ScrapeOrderChangeEntity, ScrapeOrderChangeEntityClass],
+];
+const ResolvedEntitiesProviders = entities.map(([token, entity]) => ({
+    provide: token,
+    useValue: entity,
+}));
+let ModelsModule = class ModelsModule {
+};
+ModelsModule = __decorate([
+    Module({
+        imports: [TypeOrmModule.forFeature(entities.map(([_, entity]) => entity))],
+        providers: ResolvedEntitiesProviders,
+        exports: [TypeOrmModule, ...ResolvedEntitiesProviders],
+    })
+], ModelsModule);
+
+export { ModelsModule, ResolvedEntitiesProviders };

package/lib/services/allocate-inventory-order.service.d.ts

@@ -0,0 +1,29 @@
+import { AllocateInventoryOrderEntityClass, AllocateInventoryOrderItemEntityClass, StockEntityClass } from '../models';
+import { DataSource, EntityManager, EntityTarget } from 'typeorm';
+import { CreateAllocateInventoryOrderInput, UpdateAllocateInventoryOrderInput } from '../typings/create-allocate-inventory-order.input';
+import { HelperService } from './helper.service';
+import { DeallocateInventoryOrderItemInput } from '../typings/deallocate-inventory-order';
+import { MaterialService } from './material.service';
+import { FindAllocateInventoryOrderInput } from '../typings/find-allocate-inventory-order.input';
+import { BatchService } from './batch.service';
+import { StockService } from './stock.service';
+export declare class AllocateInventoryOrderService<T extends AllocateInventoryOrderEntityClass = AllocateInventoryOrderEntityClass, K extends AllocateInventoryOrderItemEntityClass = AllocateInventoryOrderItemEntityClass> {
+    private readonly dataSource;
+    private readonly helperService;
+    private readonly materialService;
+    private readonly batchService;
+    private readonly stockService;
+    readonly allocateInventoryOrderEntity: EntityTarget<T>;
+    readonly allocateInventoryOrderItemEntity: EntityTarget<K>;
+    readonly stockEntity: EntityTarget<StockEntityClass>;
+    private readonly seqPrefix;
+    constructor(dataSource: DataSource, helperService: HelperService, materialService: MaterialService, batchService: BatchService, stockService: StockService, allocateInventoryOrderEntity: EntityTarget<T>, allocateInventoryOrderItemEntity: EntityTarget<K>, stockEntity: EntityTarget<StockEntityClass>);
+    private getRepositories;
+    private processAllocateInventoryOrderItems;
+    createAllocateInventoryOrder(options: CreateAllocateInventoryOrderInput, manager?: EntityManager): Promise<T>;
+    updateAllocateInventoryOrder({ id, manager, ...options }: UpdateAllocateInventoryOrderInput & {
+        manager?: EntityManager;
+    }): Promise<T>;
+    deallocate(options: DeallocateInventoryOrderItemInput | DeallocateInventoryOrderItemInput[], manager?: EntityManager): Promise<T>;
+    findMany(options: FindAllocateInventoryOrderInput): Promise<[T[], number]>;
+}