@classytic/flow 0.1.4

package/dist/index-dtWUZr2a2.d.mts

@@ -0,0 +1,350 @@
+import { Connection, Document, Model, Types } from "mongoose";
+
+//#region src/models/cost-layer.model.d.ts
+interface CostLayerDocument extends Document {
+  organizationId: Types.ObjectId;
+  skuRef: string;
+  locationId: string;
+  lotId?: Types.ObjectId;
+  remainingQty: number;
+  unitCost: number;
+  receivedAt: Date;
+  expiresAt?: Date;
+  procurementRef?: string;
+  moveRef: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+declare function createCostLayerModel(connection: Connection): Model<CostLayerDocument>;
+//#endregion
+//#region src/models/count-line.model.d.ts
+interface CountLineDocument extends Document {
+  organizationId: Types.ObjectId;
+  countId: Types.ObjectId;
+  skuRef: string;
+  locationId: string;
+  lotId?: Types.ObjectId;
+  serialCode?: string;
+  expectedQuantity: number;
+  countedQuantity: number;
+  variance: number;
+  varianceReason?: string;
+  recountFlag: boolean;
+  createdAt: Date;
+  updatedAt: Date;
+}
+declare function createCountLineModel(connection: Connection): Model<CountLineDocument>;
+//#endregion
+//#region src/models/counters.model.d.ts
+interface CounterDocument extends Document {
+  organizationId: string;
+  prefix: string;
+  currentValue: number;
+}
+declare function createCounterModel(connection: Connection): Model<CounterDocument>;
+/**
+ * Atomically increments the counter for the given organization + prefix
+ * and returns the next sequence value.
+ */
+declare function getNextSequence(counterModel: Model<CounterDocument>, organizationId: string, prefix: string): Promise<number>;
+//#endregion
+//#region src/models/inventory-count.model.d.ts
+interface CountScope {
+  nodeId?: Types.ObjectId;
+  locationId?: Types.ObjectId;
+  skuRefs?: string[];
+}
+interface InventoryCountDocument extends Document {
+  organizationId: Types.ObjectId;
+  countNumber: string;
+  countType: 'full' | 'cycle' | 'spot';
+  scope?: CountScope;
+  status: string;
+  freezePolicy: string;
+  startedAt?: Date;
+  submittedAt?: Date;
+  reconciledAt?: Date;
+  createdBy?: string;
+  modifiedBy?: string;
+  approvedBy?: string;
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+declare function createInventoryCountModel(connection: Connection): Model<InventoryCountDocument>;
+//#endregion
+//#region src/models/inventory-node.model.d.ts
+interface InventoryNodeDocument extends Document {
+  organizationId: Types.ObjectId;
+  code: string;
+  name: string;
+  type: string;
+  status: 'active' | 'inactive';
+  timezone?: string;
+  currency?: string;
+  address?: {
+    street?: string;
+    city?: string;
+    state?: string;
+    postalCode?: string;
+    country?: string;
+    coordinates?: {
+      lat: number;
+      lng: number;
+    };
+  };
+  capabilities?: string[];
+  isDefault: boolean;
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+declare function createInventoryNodeModel(connection: Connection): Model<InventoryNodeDocument>;
+//#endregion
+//#region src/models/location.model.d.ts
+interface LocationDocument extends Document {
+  organizationId: Types.ObjectId;
+  nodeId: Types.ObjectId;
+  parentLocationId?: Types.ObjectId;
+  code: string;
+  name: string;
+  type: string;
+  status: 'active' | 'inactive';
+  barcode?: string;
+  capacity?: number;
+  sortOrder?: number;
+  coordinates?: {
+    zone?: string;
+    aisle?: number;
+    bay?: number;
+    level?: number;
+    bin?: string;
+  };
+  maxWeight?: number;
+  maxVolume?: number;
+  allowReservations: boolean;
+  allowNegativeStock: boolean;
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+declare function createLocationModel(connection: Connection): Model<LocationDocument>;
+//#endregion
+//#region src/models/procurement-order.model.d.ts
+interface ProcurementItemSubdoc {
+  skuRef: string;
+  quantity: number;
+  quantityReceived: number;
+  unitCost: number;
+  expectedAt?: Date;
+}
+interface ProcurementOrderDocument extends Document {
+  organizationId: Types.ObjectId;
+  orderNumber: string;
+  vendorRef: string;
+  destinationNodeId: Types.ObjectId;
+  destinationLocationId?: Types.ObjectId;
+  status: string;
+  items: ProcurementItemSubdoc[];
+  expectedAt?: Date;
+  receivedAt?: Date;
+  sourceDemandRefs?: string[];
+  createdBy?: string;
+  modifiedBy?: string;
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+declare function createProcurementOrderModel(connection: Connection): Model<ProcurementOrderDocument>;
+//#endregion
+//#region src/models/replenishment-rule.model.d.ts
+interface ReplenishmentRuleDocument extends Document {
+  organizationId: Types.ObjectId;
+  scopeType: string;
+  scopeRef: string;
+  skuRef: string;
+  locationId?: string;
+  triggerType: string;
+  reorderPoint: number;
+  targetLevel: number;
+  preferredSourceType?: string;
+  preferredSourceRef?: string;
+  procurementMode?: string;
+  leadTimeDays?: number;
+  minOrderQty?: number;
+  maxOrderQty?: number;
+  multipleOf?: number;
+  safetyStock?: number;
+  enabled: boolean;
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+declare function createReplenishmentRuleModel(connection: Connection): Model<ReplenishmentRuleDocument>;
+//#endregion
+//#region src/models/reservation.model.d.ts
+interface ReservationDocument extends Document {
+  organizationId: Types.ObjectId;
+  reservationType: 'soft' | 'hard';
+  ownerType: string;
+  ownerId: string;
+  skuRef: string;
+  locationId: string;
+  lotId?: Types.ObjectId;
+  quantity: number;
+  quantityConsumed: number;
+  status: string;
+  expiresAt?: Date;
+  allocationPolicy?: string;
+  createdBy?: string;
+  releasedAt?: Date;
+  createdAt: Date;
+  updatedAt: Date;
+}
+declare function createReservationModel(connection: Connection): Model<ReservationDocument>;
+//#endregion
+//#region src/models/stock-lot.model.d.ts
+interface StockLotDocument extends Document {
+  organizationId: Types.ObjectId;
+  skuRef: string;
+  trackingType: 'lot' | 'serial';
+  lotCode?: string;
+  serialCode?: string;
+  manufacturedAt?: Date;
+  receivedAt?: Date;
+  expiresAt?: Date;
+  vendorBatchRef?: string;
+  status: string;
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+declare function createStockLotModel(connection: Connection): Model<StockLotDocument>;
+//#endregion
+//#region src/models/stock-move.model.d.ts
+interface TrackingAssignment {
+  trackingMode: string;
+  lotId?: string;
+  lotCode?: string;
+  serialCode?: string;
+  quantity: number;
+  expiresAt?: Date;
+}
+interface StockMoveDocument extends Document {
+  organizationId: Types.ObjectId;
+  moveGroupId: Types.ObjectId;
+  referenceType?: string;
+  referenceId?: string;
+  operationType: string;
+  skuRef: string;
+  sourceLocationId: string;
+  destinationLocationId: string;
+  trackingAssignments?: TrackingAssignment[];
+  uom: string;
+  quantityPlanned: number;
+  quantityReserved: number;
+  quantityDone: number;
+  status: string;
+  scheduledAt?: Date;
+  executedAt?: Date;
+  cancelledAt?: Date;
+  reservationIds?: Types.ObjectId[];
+  policySnapshot?: Record<string, unknown>;
+  createdBy?: string;
+  modifiedBy?: string;
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+declare function createStockMoveModel(connection: Connection): Model<StockMoveDocument>;
+//#endregion
+//#region src/models/stock-move-group.model.d.ts
+interface StockMoveGroupDocument extends Document {
+  organizationId: Types.ObjectId;
+  groupType: string;
+  documentNumber: string;
+  sourceNodeId?: Types.ObjectId;
+  destinationNodeId?: Types.ObjectId;
+  status: string;
+  priority: number;
+  routePlanId?: Types.ObjectId;
+  counterparty?: {
+    type: string;
+    id: string;
+  };
+  requestedAt?: Date;
+  confirmedAt?: Date;
+  completedAt?: Date;
+  createdBy?: string;
+  modifiedBy?: string;
+  notes?: string;
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+declare function createStockMoveGroupModel(connection: Connection): Model<StockMoveGroupDocument>;
+//#endregion
+//#region src/models/stock-package.model.d.ts
+interface StockPackageDocument extends Document {
+  organizationId: Types.ObjectId;
+  name: string;
+  barcode: string;
+  packageTypeId?: Types.ObjectId;
+  parentPackageId?: Types.ObjectId;
+  locationId?: Types.ObjectId;
+  destinationLocationId?: Types.ObjectId;
+  baseWeight?: number;
+  maxWeight?: number;
+  packageUse: string;
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+declare function createStockPackageModel(connection: Connection): Model<StockPackageDocument>;
+//#endregion
+//#region src/models/stock-quant.model.d.ts
+interface StockQuantDocument extends Document {
+  organizationId: Types.ObjectId;
+  skuRef: string;
+  locationId: string;
+  lotId?: Types.ObjectId;
+  ownerRef?: string;
+  stockStatus: string;
+  quantityOnHand: number;
+  quantityReserved: number;
+  quantityAvailable: number;
+  quantityIncoming: number;
+  quantityOutgoing: number;
+  inDate: Date;
+  lotExpiresAt?: Date;
+  unitCost?: number;
+  lastMovementAt?: Date;
+  createdAt: Date;
+  updatedAt: Date;
+}
+declare function createStockQuantModel(connection: Connection): Model<StockQuantDocument>;
+//#endregion
+//#region src/models/index.d.ts
+interface FlowModels {
+  InventoryNode: Model<InventoryNodeDocument>;
+  Location: Model<LocationDocument>;
+  StockMove: Model<StockMoveDocument>;
+  StockMoveGroup: Model<StockMoveGroupDocument>;
+  StockQuant: Model<StockQuantDocument>;
+  Reservation: Model<ReservationDocument>;
+  StockLot: Model<StockLotDocument>;
+  CostLayer: Model<CostLayerDocument>;
+  ProcurementOrder: Model<ProcurementOrderDocument>;
+  InventoryCount: Model<InventoryCountDocument>;
+  CountLine: Model<CountLineDocument>;
+  ReplenishmentRule: Model<ReplenishmentRuleDocument>;
+  StockPackage: Model<StockPackageDocument>;
+  Counter: Model<CounterDocument>;
+}
+/**
+ * Creates all Flow inventory models on the given Mongoose connection.
+ * Designed for multi-tenant usage where each tenant gets its own connection.
+ */
+declare function createModels(connection: Connection): FlowModels;
+//#endregion
+export { getNextSequence as A, InventoryNodeDocument as C, createInventoryCountModel as D, InventoryCountDocument as E, createCountLineModel as M, CostLayerDocument as N, CounterDocument as O, createCostLayerModel as P, createLocationModel as S, CountScope as T, createReplenishmentRuleModel as _, StockPackageDocument as a, createProcurementOrderModel as b, createStockMoveGroupModel as c, createStockMoveModel as d, StockLotDocument as f, ReplenishmentRuleDocument as g, createReservationModel as h, createStockQuantModel as i, CountLineDocument as j, createCounterModel as k, StockMoveDocument as l, ReservationDocument as m, createModels as n, createStockPackageModel as o, createStockLotModel as p, StockQuantDocument as r, StockMoveGroupDocument as s, FlowModels as t, TrackingAssignment as u, ProcurementItemSubdoc as v, createInventoryNodeModel as w, LocationDocument as x, ProcurementOrderDocument as y };

package/dist/index.d.mts

@@ -0,0 +1,128 @@
+import { i as resolveVirtualLocations, n as VirtualLocationMap, r as buildVirtualSourceTypes, t as DEFAULT_VIRTUAL_LOCATIONS } from "./virtual-locations-B9zXqPdi.mjs";
+import { a as CountLine, i as InventoryCount, n as CountScope, r as CountStatus, t as CountPort } from "./count.port-BRqwGbi3.mjs";
+import { a as ReservationStatus, c as VIRTUAL_LOCATION_TYPES, d as MOVE_STATUS_TRANSITIONS, f as MoveStatus, i as StockStatus, l as GroupType, n as TrackingMode, o as LocationType, p as isValidMoveTransition, r as SELLABLE_STATUSES, s as STOCKABLE_LOCATION_TYPES, t as ValuationMethod, u as OperationType } from "./index-CulWO137.mjs";
+import { a as TrackingAssignment, i as assertMoveTransition, n as MovePort, r as StockMove, t as CreateMoveInput } from "./move.port-Qg1CYp7h.mjs";
+import { a as QueryOptions, i as PaginatedResult, n as FlowMode, r as ListQuery, t as FlowContext } from "./index-DFF0GJ4J.mjs";
+import { n as CostLayer, t as CostLayerPort } from "./cost-layer.port-iH9pvZqB.mjs";
+import { a as Address, i as Reservation, n as ReservationPort, o as InventoryNode, r as NodePort, t as CreateReservationInput } from "./reservation.port-l9NFQ0si.mjs";
+import { n as Location, t as LocationPort } from "./location.port-CValXIpb.mjs";
+import { a as ProcurementOrder, i as ProcurementItem, n as ProcurementPort, o as ProcurementStatus, r as ReplenishmentRule, t as ReplenishmentRulePort } from "./replenishment-rule.port-DnEYtbyD.mjs";
+import { n as StockLot, t as LotPort } from "./lot.port-ChsmvZqs.mjs";
+import { a as StockMoveGroup, i as MoveGroupStatus, n as MoveGroupPort, r as MOVE_GROUP_STATUS_TRANSITIONS, t as CreateMoveGroupInput } from "./move-group.port-DHGoQA3d.mjs";
+import { t as StockPackage } from "./stock-package-BIarxbDS.mjs";
+import { n as StockQuant, t as QuantIdentity } from "./stock-quant-CZhgvTu7.mjs";
+import { n as UnitOfWork, t as TransactionSession } from "./unit-of-work.port-CWEkrDKu.mjs";
+import { i as FlowEvents, n as FlowEventMap, r as FlowEventName, t as EventEmitterPort } from "./event-emitter.port-BFh2pasY.mjs";
+import { i as QuantUpdate, n as AvailabilityQuery, r as QuantPort, t as Availability } from "./quant.port-BBa66PBT.mjs";
+import { t as AuthContext } from "./index-DsE7lZdO.mjs";
+import { n as CatalogBridge, r as SkuDetails, t as AvailabilityUpdate } from "./catalog-bridge-K8bdkncJ.mjs";
+import { C as ReservationNotFoundError, D as FlowError, E as ValidationError, S as QuantMismatchError, T as StockFrozenError, _ as MoveAlreadyPostedError, a as SkuRef, b as NodeNotFoundError, c as ReservationExpiredError, d as InsufficientStockError, f as ConcurrencyConflictError, g as LotRequiredError, h as LocationNotStockableError, i as convertToBase, l as LocationCapacityExceededError, m as LocationNotFoundError, n as UoMQuantity, o as Quantity, p as DuplicateReservationError, r as convertFromBase, s as TenantIsolationError, t as UoMConversion, u as InvalidTransitionError, v as MoveGroupNotFoundError, w as SerialQuantityError, x as ProcurementNotApprovedError, y as NegativeStockError } from "./index-C_aEnozN.mjs";
+import { n as AllocationResult, t as AllocationPolicy } from "./allocation-policy-my_HfzdV.mjs";
+import { n as PutawayPolicy, t as RemovalPolicy } from "./removal-policy-BItBB8FD.mjs";
+import { t as ValuationPolicy } from "./valuation-policy-Dco8c9Vw.mjs";
+import { t as IdempotencyPort } from "./idempotency.port-CTC70JON.mjs";
+import { n as ScanResolution, t as GS1Resolution } from "./scan-token-CNM9QVLY.mjs";
+import { t as InProcessEventBus } from "./event-bus-Um_xrcMY.mjs";
+import { t as FlowModels } from "./index-dtWUZr2a2.mjs";
+import { n as RepositoryPlugins, t as FlowRepositories } from "./index-C5PciI9P.mjs";
+import { n as FlowServices } from "./index-CMTUKEK_.mjs";
+import { a as FefoStrategy, n as LifoStrategy, o as ExactLotStrategy, r as FifoStrategy, t as NearestStrategy } from "./index-Bia4m8d2.mjs";
+import { Connection } from "mongoose";
+
+//#region src/index.d.ts
+interface FlowConfig {
+  /** Mongoose connection instance. */
+  mongoose: Connection;
+  /** Deployment mode — controls which features are enabled. */
+  mode: FlowMode;
+  /** Multi-tenant settings. */
+  multiTenant?: {
+    orgField?: string;
+    orgRef?: string;
+  };
+  /** Inventory valuation settings. */
+  valuation?: Partial<ValuationPolicy>;
+  /** Allocation policy settings. */
+  allocation?: {
+    defaultPolicy?: 'fifo' | 'fefo' | 'lifo';
+  };
+  /** Enterprise routing features. */
+  routing?: {
+    putaway?: boolean;
+    removal?: boolean;
+    crossDock?: boolean;
+  };
+  /**
+   * Override virtual location sentinels to match your app's seeded locations.
+   * Defaults: `{ vendor: 'vendor', customer: 'customer', adjustment: 'inventory_loss', transit: 'transit', scrap: 'scrap' }`
+   *
+   * Example: `{ adjustment: 'adjustment' }` to align with be-prod's location conventions.
+   */
+  virtualLocations?: Partial<VirtualLocationMap>;
+  /** Required: how Flow resolves SKU details. */
+  catalog: CatalogBridge;
+  /** Event emitter configuration. */
+  events?: {
+    adapter?: EventEmitterPort;
+  };
+  /** Custom allocation policy. */
+  policies?: {
+    allocation?: AllocationPolicy;
+  };
+  /** Custom idempotency implementation. */
+  idempotency?: IdempotencyPort;
+  /**
+   * MongoKit plugins per repository. Only add plugins where you need them.
+   *
+   * ```typescript
+   * plugins: {
+   *   quant: [cachePlugin({ adapter: redis, ttl: 30 })],
+   *   move: [multiTenantPlugin({ tenantField: 'organizationId' }), auditTrailPlugin()],
+   *   reservation: [multiTenantPlugin({ tenantField: 'organizationId' })],
+   * }
+   * ```
+   */
+  plugins?: RepositoryPlugins;
+  /**
+   * Suppress MongoKit internal warnings (e.g. missing index hints for keyset pagination).
+   * Set `true` to silence all warnings, or provide a custom logger config.
+   *
+   * ```typescript
+   * silent: true                              // silence all mongokit warnings
+   * silent: { warn: (msg) => myLogger.warn(msg) }  // redirect to your logger
+   * ```
+   */
+  silent?: boolean | {
+    warn: (msg: string, ...args: unknown[]) => void;
+  };
+}
+interface FlowEngine {
+  models: FlowModels;
+  repositories: FlowRepositories;
+  services: FlowServices;
+  events: EventEmitterPort;
+  /** Register a named allocation policy (per-node, per-category, etc.). */
+  registerPolicy: (type: 'allocation', name: string, policy: AllocationPolicy) => void;
+  /**
+   * Gracefully tear down the engine — releases Flow-owned resources.
+   * Does NOT close the caller-owned Mongoose connection by default.
+   * Pass `{ closeConnection: true }` to also close the connection.
+   */
+  destroy: (options?: {
+    closeConnection?: boolean;
+  }) => Promise<void>;
+}
+/**
+ * Create a Flow inventory engine.
+ *
+ * ```typescript
+ * const flow = createFlowEngine({
+ *   mongoose: connection,
+ *   mode: 'standard',
+ *   catalog: myCatalogBridge,
+ * });
+ * ```
+ */
+declare function createFlowEngine(config: FlowConfig): FlowEngine;
+//#endregion
+export { Address, AllocationPolicy, AllocationResult, AuthContext, Availability, AvailabilityQuery, AvailabilityUpdate, CatalogBridge, ConcurrencyConflictError, CostLayer, CostLayerPort, CountLine, CountPort, CountScope, CountStatus, CreateMoveGroupInput, CreateMoveInput, CreateReservationInput, DEFAULT_VIRTUAL_LOCATIONS, DuplicateReservationError, EventEmitterPort, ExactLotStrategy, FefoStrategy, FifoStrategy, FlowConfig, type FlowContext, FlowEngine, FlowError, type FlowEventMap, type FlowEventName, FlowEvents, type FlowMode, type FlowModels, type FlowRepositories, type FlowServices, GS1Resolution, GroupType, IdempotencyPort, InProcessEventBus, InsufficientStockError, InvalidTransitionError, InventoryCount, InventoryNode, LifoStrategy, type ListQuery, Location, LocationCapacityExceededError, LocationNotFoundError, LocationNotStockableError, LocationPort, LocationType, LotPort, LotRequiredError, MOVE_GROUP_STATUS_TRANSITIONS, MOVE_STATUS_TRANSITIONS, MoveAlreadyPostedError, MoveGroupNotFoundError, MoveGroupPort, MoveGroupStatus, MovePort, MoveStatus, NearestStrategy, NegativeStockError, NodeNotFoundError, NodePort, OperationType, type PaginatedResult, ProcurementItem, ProcurementNotApprovedError, ProcurementOrder, ProcurementPort, ProcurementStatus, PutawayPolicy, QuantIdentity, QuantMismatchError, QuantPort, QuantUpdate, Quantity, type QueryOptions, RemovalPolicy, ReplenishmentRule, ReplenishmentRulePort, type RepositoryPlugins, Reservation, ReservationExpiredError, ReservationNotFoundError, ReservationPort, ReservationStatus, SELLABLE_STATUSES, STOCKABLE_LOCATION_TYPES, ScanResolution, SerialQuantityError, SkuDetails, SkuRef, StockFrozenError, StockLot, StockMove, StockMoveGroup, StockPackage, StockQuant, StockStatus, TenantIsolationError, TrackingAssignment, TrackingMode, TransactionSession, UnitOfWork, UoMConversion, UoMQuantity, VIRTUAL_LOCATION_TYPES, ValidationError, ValuationMethod, ValuationPolicy, VirtualLocationMap, assertMoveTransition, buildVirtualSourceTypes, convertFromBase, convertToBase, createFlowEngine, isValidMoveTransition, resolveVirtualLocations };

package/dist/index.mjs

@@ -0,0 +1,102 @@
+import { a as DEFAULT_VIRTUAL_LOCATIONS, i as InvalidTransitionError, n as assertMoveTransition, o as buildVirtualSourceTypes, r as ReservationExpiredError, s as resolveVirtualLocations, t as MOVE_GROUP_STATUS_TRANSITIONS } from "./stock-move-group-C0DqUfPY.mjs";
+import { t as InProcessEventBus } from "./event-bus-BNmyoJb4.mjs";
+import { m as getNextSequence, t as createModels } from "./models-CHTMbp-G.mjs";
+import { t as createRepositories } from "./repositories-nZXJKvLW.mjs";
+import { t as FlowError } from "./base-MWBqRFM2.mjs";
+import { a as LotRequiredError, c as NegativeStockError, d as QuantMismatchError, f as ReservationNotFoundError, h as ValidationError, i as LocationNotStockableError, l as NodeNotFoundError, m as StockFrozenError, n as DuplicateReservationError, o as MoveAlreadyPostedError, p as SerialQuantityError, r as LocationNotFoundError, s as MoveGroupNotFoundError, t as ConcurrencyConflictError, u as ProcurementNotApprovedError } from "./domain-errors-D7S9ydNF.mjs";
+import { t as InsufficientStockError } from "./insufficient-stock.error-Dyr4BYaV.mjs";
+import { a as LocationCapacityExceededError, i as Quantity, n as convertToBase, r as SkuRef, t as convertFromBase } from "./domain-D5cpMpR0.mjs";
+import { t as TenantIsolationError } from "./tenant-isolation.error-D3OcKUdx.mjs";
+import { a as FifoStrategy, i as FefoStrategy, n as ExactLotStrategy, r as LifoStrategy, t as NearestStrategy } from "./reservations-Cg4wN0QB.mjs";
+import { t as createServices } from "./services-_lLO4Xbl.mjs";
+import { t as FlowEvents } from "./event-types-BSqQOvXv.mjs";
+import { n as MoveStatus, r as isValidMoveTransition, t as MOVE_STATUS_TRANSITIONS } from "./move-status-DkaFp2GD.mjs";
+import { n as GroupType, t as ReservationStatus } from "./reservation-status-ZfuTaWG0.mjs";
+import { a as OperationType, c as VIRTUAL_LOCATION_TYPES, i as StockStatus, n as TrackingMode, o as LocationType, r as SELLABLE_STATUSES, s as STOCKABLE_LOCATION_TYPES, t as ValuationMethod } from "./enums-C3_z6aHC.mjs";
+import { configureLogger } from "@classytic/mongokit";
+//#region src/index.ts
+var MongoUnitOfWork = class {
+	constructor(connection) {
+		this.connection = connection;
+	}
+	async withTransaction(fn) {
+		const session = await this.connection.startSession();
+		try {
+			let result;
+			let assigned = false;
+			await session.withTransaction(async () => {
+				result = await fn(session);
+				assigned = true;
+			});
+			if (!assigned) throw new Error("Transaction callback was never executed");
+			return result;
+		} finally {
+			await session.endSession();
+		}
+	}
+};
+/**
+* Create a Flow inventory engine.
+*
+* ```typescript
+* const flow = createFlowEngine({
+*   mongoose: connection,
+*   mode: 'standard',
+*   catalog: myCatalogBridge,
+* });
+* ```
+*/
+function createFlowEngine(config) {
+	const { mongoose: connection, catalog } = config;
+	const mode = config.mode ?? "standard";
+	if (config.silent === true) configureLogger(false);
+	else if (config.silent && typeof config.silent === "object") configureLogger({ warn: config.silent.warn });
+	const models = createModels(connection);
+	const repositories = createRepositories(models, config.plugins);
+	const unitOfWork = new MongoUnitOfWork(connection);
+	const eventEmitter = config.events?.adapter ?? new InProcessEventBus();
+	const idempotency = config.idempotency ?? null;
+	const allocationPolicy = config.policies?.allocation ?? resolveAllocationPolicy(config);
+	const boundGetNextSequence = async (prefix, organizationId) => {
+		return getNextSequence(models.Counter, organizationId, prefix);
+	};
+	const virtualLocations = resolveVirtualLocations(config.virtualLocations);
+	const services = createServices({
+		repositories,
+		unitOfWork,
+		eventEmitter,
+		idempotency,
+		catalogBridge: catalog,
+		allocationPolicy,
+		getNextSequence: boundGetNextSequence,
+		mode,
+		routing: mode === "enterprise" ? config.routing : void 0,
+		valuation: config.valuation,
+		virtualLocations,
+		packageModel: models.StockPackage
+	});
+	const registerPolicy = (_type, _name, policy) => {
+		services.allocation.registerPolicy(policy);
+	};
+	const destroy = async (options) => {
+		if (options?.closeConnection) await connection.close();
+	};
+	return {
+		models,
+		repositories,
+		services,
+		events: eventEmitter,
+		registerPolicy,
+		destroy
+	};
+}
+/** Resolve the default allocation policy from config shorthand. */
+function resolveAllocationPolicy(config) {
+	switch (config.allocation?.defaultPolicy ?? "fifo") {
+		case "fefo": return new FefoStrategy();
+		case "lifo": return new LifoStrategy();
+		default: return new FifoStrategy();
+	}
+}
+//#endregion
+export { ConcurrencyConflictError, DEFAULT_VIRTUAL_LOCATIONS, DuplicateReservationError, ExactLotStrategy, FefoStrategy, FifoStrategy, FlowError, FlowEvents, GroupType, InProcessEventBus, InsufficientStockError, InvalidTransitionError, LifoStrategy, LocationCapacityExceededError, LocationNotFoundError, LocationNotStockableError, LocationType, LotRequiredError, MOVE_GROUP_STATUS_TRANSITIONS, MOVE_STATUS_TRANSITIONS, MoveAlreadyPostedError, MoveGroupNotFoundError, MoveStatus, NearestStrategy, NegativeStockError, NodeNotFoundError, OperationType, ProcurementNotApprovedError, QuantMismatchError, Quantity, ReservationExpiredError, ReservationNotFoundError, ReservationStatus, SELLABLE_STATUSES, STOCKABLE_LOCATION_TYPES, SerialQuantityError, SkuRef, StockFrozenError, StockStatus, TenantIsolationError, TrackingMode, VIRTUAL_LOCATION_TYPES, ValidationError, ValuationMethod, assertMoveTransition, buildVirtualSourceTypes, convertFromBase, convertToBase, createFlowEngine, isValidMoveTransition, resolveVirtualLocations };

package/dist/insufficient-stock.error-Dyr4BYaV.mjs

@@ -0,0 +1,15 @@
+import { t as FlowError } from "./base-MWBqRFM2.mjs";
+//#region src/domain/errors/insufficient-stock.error.ts
+var InsufficientStockError = class extends FlowError {
+	code = "INSUFFICIENT_STOCK";
+	httpStatus = 409;
+	constructor(skuRef, requested, available, locationId) {
+		super(`Insufficient stock for ${skuRef}: requested ${requested}, available ${available}${locationId ? ` at location ${locationId}` : ""}`);
+		this.skuRef = skuRef;
+		this.requested = requested;
+		this.available = available;
+		this.locationId = locationId;
+	}
+};
+//#endregion
+export { InsufficientStockError as t };

package/dist/location.port-CValXIpb.d.mts

@@ -0,0 +1,52 @@
+import { o as LocationType } from "./index-CulWO137.mjs";
+import { t as FlowContext } from "./index-DFF0GJ4J.mjs";
+import { t as TransactionSession } from "./unit-of-work.port-CWEkrDKu.mjs";
+
+//#region src/domain/entities/location.d.ts
+interface Location {
+  _id: string;
+  organizationId: string;
+  nodeId: string;
+  parentLocationId?: string;
+  code: string;
+  name: string;
+  type: LocationType;
+  status: 'active' | 'inactive';
+  barcode?: string;
+  capacity?: number;
+  sortOrder?: number;
+  /**
+   * 3D warehouse coordinates for pick-path optimization.
+   * Tuple: [zone, aisle, bay, level, bin] — sorted lexicographically for snake-path.
+   * Example: { zone: 'A', aisle: 3, bay: 12, level: 2, bin: 'L' }
+   */
+  coordinates?: {
+    zone?: string;
+    aisle?: number;
+    bay?: number;
+    level?: number;
+    bin?: string;
+  };
+  /** Maximum weight capacity in grams */
+  maxWeight?: number;
+  /** Maximum volume capacity in cm³ */
+  maxVolume?: number;
+  allowReservations?: boolean;
+  allowNegativeStock?: boolean;
+  metadata?: Record<string, unknown>;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+//#endregion
+//#region src/domain/ports/location.port.d.ts
+interface LocationPort {
+  findById(id: string, ctx: FlowContext, session?: TransactionSession): Promise<Location | null>;
+  findByNode(nodeId: string, ctx: FlowContext, session?: TransactionSession): Promise<Location[]>;
+  findByBarcode(barcode: string, ctx: FlowContext, session?: TransactionSession): Promise<Location | null>;
+  findByCode(code: string, nodeId: string, ctx: FlowContext, session?: TransactionSession): Promise<Location | null>;
+  getTree(nodeId: string, ctx: FlowContext, session?: TransactionSession): Promise<Location[]>;
+  create(input: Omit<Location, '_id' | 'createdAt' | 'updatedAt'>, session?: TransactionSession): Promise<Location>;
+  update(id: string, updates: Partial<Location>, ctx: FlowContext, session?: TransactionSession): Promise<Location>;
+}
+//#endregion
+export { Location as n, LocationPort as t };

package/dist/lot.port-ChsmvZqs.d.mts

@@ -0,0 +1,32 @@
+import { a as QueryOptions, t as FlowContext } from "./index-DFF0GJ4J.mjs";
+import { t as TransactionSession } from "./unit-of-work.port-CWEkrDKu.mjs";
+
+//#region src/domain/entities/stock-lot.d.ts
+interface StockLot {
+  _id: string;
+  organizationId: string;
+  skuRef: string;
+  trackingType: 'lot' | 'serial';
+  lotCode?: string;
+  serialCode?: string;
+  manufacturedAt?: Date;
+  receivedAt?: Date;
+  expiresAt?: Date;
+  vendorBatchRef?: string;
+  status: 'active' | 'recalled' | 'expired';
+  metadata?: Record<string, unknown>;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+//#endregion
+//#region src/domain/ports/lot.port.d.ts
+interface LotPort {
+  findById(id: string, ctx: FlowContext, session?: TransactionSession): Promise<StockLot | null>;
+  findByCode(lotCode: string, skuRef: string, ctx: FlowContext, session?: TransactionSession): Promise<StockLot | null>;
+  findBySerial(serialCode: string, skuRef: string, ctx: FlowContext, session?: TransactionSession): Promise<StockLot | null>;
+  findMany(filter: Record<string, unknown>, ctx: FlowContext, session?: TransactionSession, options?: QueryOptions): Promise<StockLot[]>;
+  create(input: Omit<StockLot, '_id' | 'createdAt' | 'updatedAt'>, session?: TransactionSession): Promise<StockLot>;
+  update(id: string, updates: Partial<StockLot>, ctx: FlowContext, session?: TransactionSession): Promise<StockLot>;
+}
+//#endregion
+export { StockLot as n, LotPort as t };