@tailor-platform/erp-kit 0.4.0 → 0.5.0

package/src/modules/inventory/lib/errors.generated.ts

@@ -0,0 +1,317 @@
+// @generated — do not edit
+import { createDomainError } from "@tailor-platform/erp-kit/module";
+
+export const CountLineNotFoundError = createDomainError(
+  "CountLineNotFoundError", "INVENTORY_COUNT_LINE_NOT_FOUND",
+  (identifier: string) => `Referenced count line does not exist: ${identifier}`,
+);
+
+export const CountLineNotPendingError = createDomainError(
+  "CountLineNotPendingError", "INVENTORY_COUNT_LINE_NOT_PENDING",
+  (identifier: string) => `Count line is not in PENDING status: ${identifier}`,
+);
+
+export const AdjustmentNotFoundError = createDomainError(
+  "AdjustmentNotFoundError", "INVENTORY_ADJUSTMENT_NOT_FOUND",
+  (identifier: string) => `Referenced adjustment does not exist: ${identifier}`,
+);
+
+export const AdjustmentNotPendingApprovalError = createDomainError(
+  "AdjustmentNotPendingApprovalError", "INVENTORY_ADJUSTMENT_NOT_PENDING_APPROVAL",
+  (identifier: string) => `Adjustment is not in PENDING_APPROVAL status: ${identifier}`,
+);
+
+export const ItemNotFoundError = createDomainError(
+  "ItemNotFoundError", "INVENTORY_ITEM_NOT_FOUND",
+  (identifier: string) => `Referenced item does not exist: ${identifier}`,
+);
+
+export const StorageLocationNotFoundError = createDomainError(
+  "StorageLocationNotFoundError", "INVENTORY_STORAGE_LOCATION_NOT_FOUND",
+  (identifier: string) => `Referenced storage location does not exist: ${identifier}`,
+);
+
+export const DuplicateSerialNumberError = createDomainError(
+  "DuplicateSerialNumberError", "INVENTORY_DUPLICATE_SERIAL_NUMBER",
+  (identifier: string) => `A serial number with the same value already exists for this item: ${identifier}`,
+);
+
+export const CountNotFoundError = createDomainError(
+  "CountNotFoundError", "INVENTORY_COUNT_NOT_FOUND",
+  (identifier: string) => `Referenced inventory count does not exist: ${identifier}`,
+);
+
+export const CountAlreadyCompletedError = createDomainError(
+  "CountAlreadyCompletedError", "INVENTORY_COUNT_ALREADY_COMPLETED",
+  (identifier: string) => `Inventory count has already been completed and cannot be cancelled: ${identifier}`,
+);
+
+export const CountAlreadyCancelledError = createDomainError(
+  "CountAlreadyCancelledError", "INVENTORY_COUNT_ALREADY_CANCELLED",
+  (identifier: string) => `Inventory count has already been cancelled: ${identifier}`,
+);
+
+export const StockMovementNotFoundError = createDomainError(
+  "StockMovementNotFoundError", "INVENTORY_STOCK_MOVEMENT_NOT_FOUND",
+  (identifier: string) => `Referenced stock movement does not exist: ${identifier}`,
+);
+
+export const StockMovementAlreadyDoneError = createDomainError(
+  "StockMovementAlreadyDoneError", "INVENTORY_STOCK_MOVEMENT_ALREADY_DONE",
+  (identifier: string) => `Stock movement has already been executed and cannot be cancelled: ${identifier}`,
+);
+
+export const StockMovementAlreadyCancelledError = createDomainError(
+  "StockMovementAlreadyCancelledError", "INVENTORY_STOCK_MOVEMENT_ALREADY_CANCELLED",
+  (identifier: string) => `Stock movement has already been cancelled: ${identifier}`,
+);
+
+export const CountNotInProgressError = createDomainError(
+  "CountNotInProgressError", "INVENTORY_COUNT_NOT_IN_PROGRESS",
+  (identifier: string) => `Count is not in IN_PROGRESS status: ${identifier}`,
+);
+
+export const UnresolvedCountLinesError = createDomainError(
+  "UnresolvedCountLinesError", "INVENTORY_UNRESOLVED_COUNT_LINES",
+  (identifier: string) => `One or more count lines are not in a terminal status (APPROVED or REJECTED): ${identifier}`,
+);
+
+export const AdjustmentInvalidStatusError = createDomainError(
+  "AdjustmentInvalidStatusError", "INVENTORY_ADJUSTMENT_INVALID_STATUS",
+  (identifier: string) => `Adjustment is not in DRAFT or APPROVED status: ${identifier}`,
+);
+
+export const InsufficientOnHandError = createDomainError(
+  "InsufficientOnHandError", "INVENTORY_INSUFFICIENT_ON_HAND",
+  (identifier: string) => `Negative adjustment would reduce on-hand below zero: ${identifier}`,
+);
+
+export const StockMovementNotDraftError = createDomainError(
+  "StockMovementNotDraftError", "INVENTORY_STOCK_MOVEMENT_NOT_DRAFT",
+  (identifier: string) => `Stock movement is not in DRAFT status: ${identifier}`,
+);
+
+export const ReasonCodeRequiredError = createDomainError(
+  "ReasonCodeRequiredError", "INVENTORY_REASON_CODE_REQUIRED",
+  (identifier: string) => `No reason code was provided: ${identifier}`,
+);
+
+export const ScrapQuantityMustBeNegativeError = createDomainError(
+  "ScrapQuantityMustBeNegativeError", "INVENTORY_SCRAP_QUANTITY_MUST_BE_NEGATIVE",
+  (identifier: string) => `SCRAP type adjustment must have a negative quantityDelta: ${identifier}`,
+);
+
+export const LotNotFoundError = createDomainError(
+  "LotNotFoundError", "INVENTORY_LOT_NOT_FOUND",
+  (identifier: string) => `Referenced lot does not exist: ${identifier}`,
+);
+
+export const SerialNumberNotFoundError = createDomainError(
+  "SerialNumberNotFoundError", "INVENTORY_SERIAL_NUMBER_NOT_FOUND",
+  (identifier: string) => `Referenced serial number does not exist: ${identifier}`,
+);
+
+export const WarehouseNotFoundError = createDomainError(
+  "WarehouseNotFoundError", "INVENTORY_WAREHOUSE_NOT_FOUND",
+  (identifier: string) => `Referenced warehouse does not exist: ${identifier}`,
+);
+
+export const InvalidCountTypeError = createDomainError(
+  "InvalidCountTypeError", "INVENTORY_INVALID_COUNT_TYPE",
+  (identifier: string) => `countType is not FULL or CYCLE: ${identifier}`,
+);
+
+export const DuplicateLotNumberError = createDomainError(
+  "DuplicateLotNumberError", "INVENTORY_DUPLICATE_LOT_NUMBER",
+  (identifier: string) => `A lot with the same number already exists for this item: ${identifier}`,
+);
+
+export const InvalidMovementTypeError = createDomainError(
+  "InvalidMovementTypeError", "INVENTORY_INVALID_MOVEMENT_TYPE",
+  (identifier: string) => `movementType is not a recognized value: ${identifier}`,
+);
+
+export const EmptyMoveLinesError = createDomainError(
+  "EmptyMoveLinesError", "INVENTORY_EMPTY_MOVE_LINES",
+  (identifier: string) => `No move lines were provided: ${identifier}`,
+);
+
+export const ItemNotActiveError = createDomainError(
+  "ItemNotActiveError", "INVENTORY_ITEM_NOT_ACTIVE",
+  (identifier: string) => `Referenced item is not in ACTIVE status: ${identifier}`,
+);
+
+export const InvalidQuantityError = createDomainError(
+  "InvalidQuantityError", "INVENTORY_INVALID_QUANTITY",
+  (identifier: string) => `Move line quantity is zero or negative: ${identifier}`,
+);
+
+export const SameSourceDestinationError = createDomainError(
+  "SameSourceDestinationError", "INVENTORY_SAME_SOURCE_DESTINATION",
+  (identifier: string) => `Source and destination locations are the same: ${identifier}`,
+);
+
+export const LotRequiredForTrackedItemError = createDomainError(
+  "LotRequiredForTrackedItemError", "INVENTORY_LOT_REQUIRED_FOR_TRACKED_ITEM",
+  (identifier: string) => `Move line references a lot-tracked item but no lotId was provided: ${identifier}`,
+);
+
+export const WarehouseInactiveError = createDomainError(
+  "WarehouseInactiveError", "INVENTORY_WAREHOUSE_INACTIVE",
+  (identifier: string) => `Referenced warehouse is not in ACTIVE status: ${identifier}`,
+);
+
+export const InvalidLocationTypeError = createDomainError(
+  "InvalidLocationTypeError", "INVENTORY_INVALID_LOCATION_TYPE",
+  (identifier: string) => `locationType is not 'zone' or 'bin': ${identifier}`,
+);
+
+export const ParentZoneNotFoundError = createDomainError(
+  "ParentZoneNotFoundError", "INVENTORY_PARENT_ZONE_NOT_FOUND",
+  (identifier: string) => `Bin's parent zone does not exist: ${identifier}`,
+);
+
+export const ParentNotAZoneError = createDomainError(
+  "ParentNotAZoneError", "INVENTORY_PARENT_NOT_A_ZONE",
+  (identifier: string) => `Parent location is a bin, not a zone: ${identifier}`,
+);
+
+export const ParentInDifferentWarehouseError = createDomainError(
+  "ParentInDifferentWarehouseError", "INVENTORY_PARENT_IN_DIFFERENT_WAREHOUSE",
+  (identifier: string) => `Parent zone belongs to a different warehouse: ${identifier}`,
+);
+
+export const DuplicateLocationNameError = createDomainError(
+  "DuplicateLocationNameError", "INVENTORY_DUPLICATE_LOCATION_NAME",
+  (identifier: string) => `A location with the same name or code already exists in the warehouse: ${identifier}`,
+);
+
+export const InvalidCostingMethodError = createDomainError(
+  "InvalidCostingMethodError", "INVENTORY_INVALID_COSTING_METHOD",
+  (identifier: string) => `costingMethod is not a recognized value (must be FIFO, AVCO, or STANDARD_COST): ${identifier}`,
+);
+
+export const StandardCostRateRequiredError = createDomainError(
+  "StandardCostRateRequiredError", "INVENTORY_STANDARD_COST_RATE_REQUIRED",
+  (identifier: string) => `costingMethod is STANDARD_COST but no standardCostRate was provided: ${identifier}`,
+);
+
+export const SiteNotFoundError = createDomainError(
+  "SiteNotFoundError", "INVENTORY_SITE_NOT_FOUND",
+  (identifier: string) => `Referenced site does not exist: ${identifier}`,
+);
+
+export const SiteInactiveError = createDomainError(
+  "SiteInactiveError", "INVENTORY_SITE_INACTIVE",
+  (identifier: string) => `Referenced site exists but is not in ACTIVE status: ${identifier}`,
+);
+
+export const DuplicateWarehouseNameError = createDomainError(
+  "DuplicateWarehouseNameError", "INVENTORY_DUPLICATE_WAREHOUSE_NAME",
+  (identifier: string) => `A warehouse with the same name already exists at the given site: ${identifier}`,
+);
+
+export const StorageLocationNotActiveError = createDomainError(
+  "StorageLocationNotActiveError", "INVENTORY_STORAGE_LOCATION_NOT_ACTIVE",
+  (identifier: string) => `Storage location is not in ACTIVE status: ${identifier}`,
+);
+
+export const WarehouseNotActiveError = createDomainError(
+  "WarehouseNotActiveError", "INVENTORY_WAREHOUSE_NOT_ACTIVE",
+  (identifier: string) => `Warehouse is not in ACTIVE status: ${identifier}`,
+);
+
+export const StockMovementNotConfirmedError = createDomainError(
+  "StockMovementNotConfirmedError", "INVENTORY_STOCK_MOVEMENT_NOT_CONFIRMED",
+  (identifier: string) => `Stock movement is not in CONFIRMED status: ${identifier}`,
+);
+
+export const InsufficientStockError = createDomainError(
+  "InsufficientStockError", "INVENTORY_INSUFFICIENT_STOCK",
+  (identifier: string) => `Source location does not have enough available stock for goods issue or block: ${identifier}`,
+);
+
+export const InsufficientBlockedStockError = createDomainError(
+  "InsufficientBlockedStockError", "INVENTORY_INSUFFICIENT_BLOCKED_STOCK",
+  (identifier: string) => `Source location does not have enough blocked stock for unblock: ${identifier}`,
+);
+
+export const LotStockInsufficientError = createDomainError(
+  "LotStockInsufficientError", "INVENTORY_LOT_STOCK_INSUFFICIENT",
+  (identifier: string) => `Lot does not have sufficient stock at the location: ${identifier}`,
+);
+
+export const SerialInvalidStateError = createDomainError(
+  "SerialInvalidStateError", "INVENTORY_SERIAL_INVALID_STATE",
+  (identifier: string) => `Serial number is not in a valid state for the movement type: ${identifier}`,
+);
+
+export const StorageLocationNotInactiveError = createDomainError(
+  "StorageLocationNotInactiveError", "INVENTORY_STORAGE_LOCATION_NOT_INACTIVE",
+  (identifier: string) => `Storage location is not in INACTIVE status: ${identifier}`,
+);
+
+export const WarehouseNotInactiveError = createDomainError(
+  "WarehouseNotInactiveError", "INVENTORY_WAREHOUSE_NOT_INACTIVE",
+  (identifier: string) => `Warehouse is not in INACTIVE status: ${identifier}`,
+);
+
+export const CountLineInvalidStatusError = createDomainError(
+  "CountLineInvalidStatusError", "INVENTORY_COUNT_LINE_INVALID_STATUS",
+  (identifier: string) => `Count line is not in PENDING, RECOUNT, or REJECTED status: ${identifier}`,
+);
+
+export const StockLevelNotFoundError = createDomainError(
+  "StockLevelNotFoundError", "INVENTORY_STOCK_LEVEL_NOT_FOUND",
+  (identifier: string) => `No stock level record exists for the item-location pair: ${identifier}`,
+);
+
+export const InsufficientReservedStockError = createDomainError(
+  "InsufficientReservedStockError", "INVENTORY_INSUFFICIENT_RESERVED_STOCK",
+  (identifier: string) => `Release amount exceeds the currently reserved quantity: ${identifier}`,
+);
+
+export const InsufficientAvailableStockError = createDomainError(
+  "InsufficientAvailableStockError", "INVENTORY_INSUFFICIENT_AVAILABLE_STOCK",
+  (identifier: string) => `Available stock is less than the requested reservation quantity: ${identifier}`,
+);
+
+export const AdjustmentNotRejectedError = createDomainError(
+  "AdjustmentNotRejectedError", "INVENTORY_ADJUSTMENT_NOT_REJECTED",
+  (identifier: string) => `Adjustment is not in REJECTED status: ${identifier}`,
+);
+
+export const CountNotPlannedError = createDomainError(
+  "CountNotPlannedError", "INVENTORY_COUNT_NOT_PLANNED",
+  (identifier: string) => `Count is not in PLANNED status: ${identifier}`,
+);
+
+export const AdjustmentNotDraftError = createDomainError(
+  "AdjustmentNotDraftError", "INVENTORY_ADJUSTMENT_NOT_DRAFT",
+  (identifier: string) => `Adjustment is not in DRAFT status: ${identifier}`,
+);
+
+export const LotFullyConsumedError = createDomainError(
+  "LotFullyConsumedError", "INVENTORY_LOT_FULLY_CONSUMED",
+  (identifier: string) => `Lot is in FULLY_CONSUMED status and cannot be updated: ${identifier}`,
+);
+
+export const ValuationPolicyNotFoundError = createDomainError(
+  "ValuationPolicyNotFoundError", "INVENTORY_VALUATION_POLICY_NOT_FOUND",
+  (identifier: string) => `Referenced valuation policy does not exist: ${identifier}`,
+);
+
+export const InventoryAdjustmentNotFoundError = createDomainError(
+  "InventoryAdjustmentNotFoundError", "INVENTORY_INVENTORY_ADJUSTMENT_NOT_FOUND",
+  (identifier: string) => `No adjustment matches the given id — caller receives null: ${identifier}`,
+);
+
+export const ItemValuationNotFoundError = createDomainError(
+  "ItemValuationNotFoundError", "INVENTORY_ITEM_VALUATION_NOT_FOUND",
+  (identifier: string) => `No valuation record exists for the specified item: ${identifier}`,
+);
+
+export const NoFilterProvidedError = createDomainError(
+  "NoFilterProvidedError", "INVENTORY_NO_FILTER_PROVIDED",
+  (identifier: string) => `At least one filter must be specified: ${identifier}`,
+);

package/src/modules/inventory/lib/permissions.generated.ts

@@ -0,0 +1,38 @@
+// @generated — do not edit
+import { definePermissions } from "@tailor-platform/erp-kit/module";
+
+export const { permissions, own, all } = definePermissions("inventory", [
+  "approveCountLine",
+  "approveInventoryAdjustment",
+  "assignSerialNumber",
+  "cancelInventoryCount",
+  "cancelStockMovement",
+  "completeInventoryCount",
+  "confirmInventoryAdjustment",
+  "confirmStockMovement",
+  "createInventoryAdjustment",
+  "createInventoryCount",
+  "createLot",
+  "createStockMovement",
+  "createStorageLocation",
+  "createValuationPolicy",
+  "createWarehouse",
+  "deactivateStorageLocation",
+  "deactivateWarehouse",
+  "executeStockMovement",
+  "reactivateStorageLocation",
+  "reactivateWarehouse",
+  "recordCountLine",
+  "rejectCountLine",
+  "rejectInventoryAdjustment",
+  "releaseReservation",
+  "reserveStock",
+  "reviseInventoryAdjustment",
+  "startInventoryCount",
+  "submitInventoryAdjustment",
+  "updateLot",
+  "updateStockMovement",
+  "updateStorageLocation",
+  "updateValuationPolicy",
+  "updateWarehouse",
+] as const);

package/src/modules/inventory/lib/types.ts

@@ -0,0 +1,92 @@
+import type { DB } from "../generated/kysely-tailordb";
+import type {
+  InferSchema,
+  Selectable,
+  Insertable,
+  Updateable,
+} from "@tailor-platform/erp-kit/module";
+
+export type Schema = InferSchema<DB>;
+
+export type Warehouse<T extends { Warehouse: object }> = Selectable<T["Warehouse"]>;
+export type WarehouseCreate<T extends { Warehouse: object }> = Insertable<T["Warehouse"]>;
+export type WarehouseUpdate<T extends { Warehouse: object }> = Updateable<T["Warehouse"]>;
+
+export type StorageLocation<T extends { StorageLocation: object }> = Selectable<
+  T["StorageLocation"]
+>;
+export type StorageLocationCreate<T extends { StorageLocation: object }> = Insertable<
+  T["StorageLocation"]
+>;
+export type StorageLocationUpdate<T extends { StorageLocation: object }> = Updateable<
+  T["StorageLocation"]
+>;
+
+export type ValuationPolicy<T extends { ValuationPolicy: object }> = Selectable<
+  T["ValuationPolicy"]
+>;
+export type ValuationPolicyCreate<T extends { ValuationPolicy: object }> = Insertable<
+  T["ValuationPolicy"]
+>;
+export type ValuationPolicyUpdate<T extends { ValuationPolicy: object }> = Updateable<
+  T["ValuationPolicy"]
+>;
+
+export type StockLevel<T extends { StockLevel: object }> = Selectable<T["StockLevel"]>;
+export type StockLevelCreate<T extends { StockLevel: object }> = Insertable<T["StockLevel"]>;
+export type StockLevelUpdate<T extends { StockLevel: object }> = Updateable<T["StockLevel"]>;
+
+export type StockMovement<T extends { StockMovement: object }> = Selectable<T["StockMovement"]>;
+export type StockMovementCreate<T extends { StockMovement: object }> = Insertable<
+  T["StockMovement"]
+>;
+export type StockMovementUpdate<T extends { StockMovement: object }> = Updateable<
+  T["StockMovement"]
+>;
+
+export type StockMoveLine<T extends { StockMoveLine: object }> = Selectable<T["StockMoveLine"]>;
+export type StockMoveLineCreate<T extends { StockMoveLine: object }> = Insertable<
+  T["StockMoveLine"]
+>;
+
+export type Lot<T extends { Lot: object }> = Selectable<T["Lot"]>;
+export type LotCreate<T extends { Lot: object }> = Insertable<T["Lot"]>;
+export type LotUpdate<T extends { Lot: object }> = Updateable<T["Lot"]>;
+
+export type LotStockLevel<T extends { LotStockLevel: object }> = Selectable<T["LotStockLevel"]>;
+export type LotStockLevelCreate<T extends { LotStockLevel: object }> = Insertable<
+  T["LotStockLevel"]
+>;
+
+export type SerialNumber<T extends { SerialNumber: object }> = Selectable<T["SerialNumber"]>;
+export type SerialNumberCreate<T extends { SerialNumber: object }> = Insertable<T["SerialNumber"]>;
+
+export type InventoryCount<T extends { InventoryCount: object }> = Selectable<T["InventoryCount"]>;
+export type InventoryCountCreate<T extends { InventoryCount: object }> = Insertable<
+  T["InventoryCount"]
+>;
+
+export type InventoryCountLine<T extends { InventoryCountLine: object }> = Selectable<
+  T["InventoryCountLine"]
+>;
+export type InventoryCountLineCreate<T extends { InventoryCountLine: object }> = Insertable<
+  T["InventoryCountLine"]
+>;
+
+export type InventoryAdjustment<T extends { InventoryAdjustment: object }> = Selectable<
+  T["InventoryAdjustment"]
+>;
+export type InventoryAdjustmentCreate<T extends { InventoryAdjustment: object }> = Insertable<
+  T["InventoryAdjustment"]
+>;
+export type InventoryAdjustmentUpdate<T extends { InventoryAdjustment: object }> = Updateable<
+  T["InventoryAdjustment"]
+>;
+
+export type ItemValuation<T extends { ItemValuation: object }> = Selectable<T["ItemValuation"]>;
+export type ItemValuationCreate<T extends { ItemValuation: object }> = Insertable<
+  T["ItemValuation"]
+>;
+
+export type CostLayer<T extends { CostLayer: object }> = Selectable<T["CostLayer"]>;
+export type CostLayerCreate<T extends { CostLayer: object }> = Insertable<T["CostLayer"]>;

package/src/modules/inventory/module.ts

@@ -0,0 +1,202 @@
+import { type TailorAnyDBField } from "@tailor-platform/sdk";
+import type { defineModule as defineOrganizationModule } from "../organization";
+import type { defineModule as defineItemManagementModule } from "../item-management";
+import { createWarehouseType, type CreateWarehouseTypeParams } from "./db/warehouse";
+import { createStorageLocationType } from "./db/storageLocation";
+import { createValuationPolicyType } from "./db/valuationPolicy";
+import { createStockLevelType } from "./db/stockLevel";
+import { createStockMovementType } from "./db/stockMovement";
+import { createStockMoveLineType } from "./db/stockMoveLine";
+import { createLotType } from "./db/lot";
+import { createLotStockLevelType } from "./db/lotStockLevel";
+import { createSerialNumberType } from "./db/serialNumber";
+import { createInventoryCountType } from "./db/inventoryCount";
+import { createInventoryCountLineType } from "./db/inventoryCountLine";
+import { createInventoryAdjustmentType } from "./db/inventoryAdjustment";
+import { createItemValuationType } from "./db/itemValuation";
+import { createCostLayerType } from "./db/costLayer";
+import { createWarehouse } from "./command/createWarehouse.generated";
+import { updateWarehouse } from "./command/updateWarehouse.generated";
+import { deactivateWarehouse } from "./command/deactivateWarehouse.generated";
+import { reactivateWarehouse } from "./command/reactivateWarehouse.generated";
+import { createStorageLocation } from "./command/createStorageLocation.generated";
+import { updateStorageLocation } from "./command/updateStorageLocation.generated";
+import { deactivateStorageLocation } from "./command/deactivateStorageLocation.generated";
+import { reactivateStorageLocation } from "./command/reactivateStorageLocation.generated";
+import { createValuationPolicy } from "./command/createValuationPolicy.generated";
+import { updateValuationPolicy } from "./command/updateValuationPolicy.generated";
+import { createLot } from "./command/createLot.generated";
+import { updateLot } from "./command/updateLot.generated";
+import { assignSerialNumber } from "./command/assignSerialNumber.generated";
+import { createStockMovement } from "./command/createStockMovement.generated";
+import { updateStockMovement } from "./command/updateStockMovement.generated";
+import { confirmStockMovement } from "./command/confirmStockMovement.generated";
+import { executeStockMovement } from "./command/executeStockMovement.generated";
+import { cancelStockMovement } from "./command/cancelStockMovement.generated";
+import { reserveStock } from "./command/reserveStock.generated";
+import { releaseReservation } from "./command/releaseReservation.generated";
+import { createInventoryCount } from "./command/createInventoryCount.generated";
+import { startInventoryCount } from "./command/startInventoryCount.generated";
+import { recordCountLine } from "./command/recordCountLine.generated";
+import { approveCountLine } from "./command/approveCountLine.generated";
+import { rejectCountLine } from "./command/rejectCountLine.generated";
+import { completeInventoryCount } from "./command/completeInventoryCount.generated";
+import { cancelInventoryCount } from "./command/cancelInventoryCount.generated";
+import { createInventoryAdjustment } from "./command/createInventoryAdjustment.generated";
+import { submitInventoryAdjustment } from "./command/submitInventoryAdjustment.generated";
+import { approveInventoryAdjustment } from "./command/approveInventoryAdjustment.generated";
+import { rejectInventoryAdjustment } from "./command/rejectInventoryAdjustment.generated";
+import { reviseInventoryAdjustment } from "./command/reviseInventoryAdjustment.generated";
+import { confirmInventoryAdjustment } from "./command/confirmInventoryAdjustment.generated";
+import { getWarehouse } from "./query/getWarehouse.generated";
+import { getStorageLocation } from "./query/getStorageLocation.generated";
+import { getValuationPolicy } from "./query/getValuationPolicy.generated";
+import { getStockLevel } from "./query/getStockLevel.generated";
+import { getStockMovement } from "./query/getStockMovement.generated";
+import { getLot } from "./query/getLot.generated";
+import { getSerialNumber } from "./query/getSerialNumber.generated";
+import { getSerialNumberHistory } from "./query/getSerialNumberHistory.generated";
+import { getInventoryCount } from "./query/getInventoryCount.generated";
+import { getInventoryAdjustment } from "./query/getInventoryAdjustment.generated";
+import { getItemValuation } from "./query/getItemValuation.generated";
+import { getWarehouseStockSummary } from "./query/getWarehouseStockSummary.generated";
+import { listWarehouses } from "./query/listWarehouses.generated";
+import { listStorageLocations } from "./query/listStorageLocations.generated";
+import { listValuationPolicies } from "./query/listValuationPolicies.generated";
+import { listStockLevels } from "./query/listStockLevels.generated";
+import { listStockMovements } from "./query/listStockMovements.generated";
+import { listLots } from "./query/listLots.generated";
+import { listSerialNumbers } from "./query/listSerialNumbers.generated";
+import { listInventoryCounts } from "./query/listInventoryCounts.generated";
+import { listInventoryAdjustments } from "./query/listInventoryAdjustments.generated";
+import { listItemValuations } from "./query/listItemValuations.generated";
+import { listCostLayers } from "./query/listCostLayers.generated";
+import { listExpiringLots } from "./query/listExpiringLots.generated";
+import { traceLotForward } from "./query/traceLotForward.generated";
+import { traceLotBackward } from "./query/traceLotBackward.generated";
+import { type EmptyFields, type FieldsToInsertable } from "@tailor-platform/erp-kit/module";
+
+type OrganizationModule = ReturnType<typeof defineOrganizationModule>;
+type OrganizationDB = OrganizationModule["db"];
+type OrganizationQueries = OrganizationModule["queries"];
+
+type ItemManagementModule = ReturnType<typeof defineItemManagementModule>;
+type ItemManagementQueries = ItemManagementModule["queries"];
+
+export interface DefineModuleParams<WF extends Record<string, TailorAnyDBField>> {
+  warehouse?: Omit<CreateWarehouseTypeParams<WF>, "siteType">;
+  organization: {
+    db: { site: OrganizationDB["site"] };
+    queries: { getSite: OrganizationQueries["getSite"] };
+  };
+  itemManagement: {
+    queries: { getItem: ItemManagementQueries["getItem"] };
+  };
+}
+
+export const defineModule = <const WF extends Record<string, TailorAnyDBField> = EmptyFields>(
+  params: DefineModuleParams<WF>,
+) => {
+  const warehouse = createWarehouseType({
+    ...params.warehouse,
+    siteType: params.organization.db.site,
+  });
+  const storageLocation = createStorageLocationType({});
+  const valuationPolicy = createValuationPolicyType({});
+  const stockLevel = createStockLevelType({});
+  const stockMovement = createStockMovementType({});
+  const stockMoveLine = createStockMoveLineType({});
+  const lot = createLotType({});
+  const lotStockLevel = createLotStockLevelType({});
+  const serialNumber = createSerialNumberType({});
+  const inventoryCount = createInventoryCountType({});
+  const inventoryCountLine = createInventoryCountLineType({});
+  const inventoryAdjustment = createInventoryAdjustmentType({});
+  const itemValuation = createItemValuationType({});
+  const costLayer = createCostLayerType({});
+
+  const orgQueries = params.organization.queries;
+  const itemQueries = params.itemManagement.queries;
+
+  return {
+    db: {
+      warehouse,
+      storageLocation,
+      valuationPolicy,
+      stockLevel,
+      stockMovement,
+      stockMoveLine,
+      lot,
+      lotStockLevel,
+      serialNumber,
+      inventoryCount,
+      inventoryCountLine,
+      inventoryAdjustment,
+      itemValuation,
+      costLayer,
+    },
+    queries: {
+      getWarehouse,
+      getStorageLocation,
+      getValuationPolicy,
+      getStockLevel,
+      getStockMovement,
+      getLot,
+      getSerialNumber,
+      getSerialNumberHistory,
+      getInventoryCount,
+      getInventoryAdjustment,
+      getItemValuation,
+      getWarehouseStockSummary,
+      listWarehouses,
+      listStorageLocations,
+      listValuationPolicies,
+      listStockLevels,
+      listStockMovements,
+      listLots,
+      listSerialNumbers,
+      listInventoryCounts,
+      listInventoryAdjustments,
+      listItemValuations,
+      listCostLayers,
+      listExpiringLots,
+      traceLotForward,
+      traceLotBackward,
+    },
+    commands: {
+      createWarehouse: createWarehouse<FieldsToInsertable<WF>>(orgQueries),
+      updateWarehouse: updateWarehouse(),
+      deactivateWarehouse: deactivateWarehouse(),
+      reactivateWarehouse: reactivateWarehouse(orgQueries),
+      createStorageLocation: createStorageLocation(),
+      updateStorageLocation: updateStorageLocation(),
+      deactivateStorageLocation: deactivateStorageLocation(),
+      reactivateStorageLocation: reactivateStorageLocation(),
+      createValuationPolicy: createValuationPolicy(),
+      updateValuationPolicy: updateValuationPolicy(),
+      createLot: createLot(itemQueries),
+      updateLot: updateLot(),
+      assignSerialNumber: assignSerialNumber(itemQueries),
+      createStockMovement: createStockMovement(itemQueries),
+      updateStockMovement: updateStockMovement(itemQueries),
+      confirmStockMovement: confirmStockMovement(itemQueries),
+      executeStockMovement: executeStockMovement(),
+      cancelStockMovement: cancelStockMovement(),
+      reserveStock: reserveStock(itemQueries),
+      releaseReservation: releaseReservation(),
+      createInventoryCount: createInventoryCount(),
+      startInventoryCount: startInventoryCount(),
+      recordCountLine: recordCountLine(),
+      approveCountLine: approveCountLine(),
+      rejectCountLine: rejectCountLine(),
+      completeInventoryCount: completeInventoryCount(),
+      cancelInventoryCount: cancelInventoryCount(),
+      createInventoryAdjustment: createInventoryAdjustment(itemQueries),
+      submitInventoryAdjustment: submitInventoryAdjustment(),
+      approveInventoryAdjustment: approveInventoryAdjustment(),
+      rejectInventoryAdjustment: rejectInventoryAdjustment(),
+      reviseInventoryAdjustment: reviseInventoryAdjustment(),
+      confirmInventoryAdjustment: confirmInventoryAdjustment(),
+    },
+  };
+};

package/src/modules/inventory/permissions.ts

@@ -0,0 +1,3 @@
+import { definePermissions } from "@tailor-platform/erp-kit/module";
+
+export const { permissions, own, all } = definePermissions("inventory", [] as const);

package/src/modules/inventory/query/getInventoryAdjustment.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { run } from "./getInventoryAdjustment";
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+
+export const getInventoryAdjustment = defineQuery(run);