@classytic/flow 0.1.4

package/dist/index-C5PciI9P.d.mts

@@ -0,0 +1,203 @@
+import { a as CountLine, i as InventoryCount, r as CountStatus, t as CountPort } from "./count.port-BRqwGbi3.mjs";
+import { a as ReservationStatus, f as MoveStatus } from "./index-CulWO137.mjs";
+import { n as MovePort, r as StockMove, t as CreateMoveInput } from "./move.port-Qg1CYp7h.mjs";
+import { a as QueryOptions, i as PaginatedResult, r as ListQuery, t as FlowContext } from "./index-DFF0GJ4J.mjs";
+import { n as CostLayer, t as CostLayerPort } from "./cost-layer.port-iH9pvZqB.mjs";
+import { 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, 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, t as CreateMoveGroupInput } from "./move-group.port-DHGoQA3d.mjs";
+import { n as StockQuant, t as QuantIdentity } from "./stock-quant-CZhgvTu7.mjs";
+import { t as TransactionSession } from "./unit-of-work.port-CWEkrDKu.mjs";
+import { i as QuantUpdate, n as AvailabilityQuery, r as QuantPort, t as Availability } from "./quant.port-BBa66PBT.mjs";
+import { C as InventoryNodeDocument, E as InventoryCountDocument, N as CostLayerDocument, f as StockLotDocument, g as ReplenishmentRuleDocument, j as CountLineDocument, l as StockMoveDocument, m as ReservationDocument, r as StockQuantDocument, s as StockMoveGroupDocument, t as FlowModels, x as LocationDocument, y as ProcurementOrderDocument } from "./index-dtWUZr2a2.mjs";
+import { OffsetPaginationResult, PaginationResult, PluginType } from "@classytic/mongokit";
+import { ClientSession, Model, Types } from "mongoose";
+
+//#region src/repositories/cost-layer.repository.d.ts
+declare class CostLayerRepository implements CostLayerPort {
+  private repo;
+  constructor(model: Model<CostLayerDocument>, plugins?: PluginType[]);
+  create(input: Omit<CostLayer, '_id' | 'createdAt' | 'updatedAt'>, session?: TransactionSession): Promise<CostLayer>;
+  drain(id: string, quantity: number, ctx: FlowContext, session?: TransactionSession): Promise<CostLayer>;
+  findBySkuRef(skuRef: string, locationId: string, ctx: FlowContext, session?: TransactionSession): Promise<CostLayer[]>;
+  findMany(filter: Record<string, unknown>, ctx: FlowContext, session?: TransactionSession, options?: QueryOptions): Promise<CostLayer[]>;
+  findOrderedForConsumption(skuRef: string, locationId: string, method: 'fifo' | 'fefo', ctx: FlowContext, session?: TransactionSession): Promise<CostLayer[]>;
+}
+//#endregion
+//#region src/repositories/count.repository.d.ts
+declare class CountRepository implements CountPort {
+  private countRepo;
+  private lineRepo;
+  constructor(countModel: Model<InventoryCountDocument>, lineModel: Model<CountLineDocument>, plugins?: PluginType[]);
+  create(input: Omit<InventoryCount, '_id' | 'createdAt' | 'updatedAt'>, session?: TransactionSession): Promise<InventoryCount>;
+  findById(id: string, ctx: FlowContext, session?: TransactionSession): Promise<InventoryCount | null>;
+  updateStatus(id: string, status: CountStatus, updates: Partial<InventoryCount>, session?: TransactionSession): Promise<InventoryCount>;
+  submitLines(countId: string, lines: Omit<CountLine, '_id' | 'createdAt' | 'updatedAt'>[], session?: TransactionSession): Promise<CountLine[]>;
+  getLines(countId: string, ctx: FlowContext, session?: TransactionSession): Promise<CountLine[]>;
+}
+//#endregion
+//#region src/repositories/location.repository.d.ts
+declare class LocationRepository implements LocationPort {
+  private repo;
+  constructor(model: Model<LocationDocument>, plugins?: PluginType[]);
+  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
+//#region src/repositories/lot.repository.d.ts
+declare class LotRepository implements LotPort {
+  private repo;
+  constructor(model: Model<StockLotDocument>, plugins?: PluginType[]);
+  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
+//#region src/repositories/move.repository.d.ts
+declare class MoveRepository implements MovePort {
+  private repo;
+  constructor(model: Model<StockMoveDocument>, plugins?: PluginType[]);
+  create(input: CreateMoveInput & {
+    organizationId: string;
+    createdBy: string;
+  }, session?: TransactionSession): Promise<StockMove>;
+  findById(id: string, ctx: FlowContext, session?: TransactionSession): Promise<StockMove | null>;
+  findByGroupId(groupId: string, ctx: FlowContext, session?: TransactionSession): Promise<StockMove[]>;
+  updateStatus(id: string, status: MoveStatus, updates: Partial<StockMove>, session?: TransactionSession): Promise<StockMove>;
+  findMany(filter: Record<string, unknown>, ctx: FlowContext, session?: TransactionSession, options?: QueryOptions): Promise<StockMove[]>;
+}
+//#endregion
+//#region src/repositories/move-group.repository.d.ts
+declare class MoveGroupRepository implements MoveGroupPort {
+  private repo;
+  constructor(model: Model<StockMoveGroupDocument>, plugins?: PluginType[]);
+  create(input: CreateMoveGroupInput, session?: TransactionSession): Promise<StockMoveGroup>;
+  findById(id: string, ctx: FlowContext, session?: TransactionSession): Promise<StockMoveGroup | null>;
+  updateStatus(id: string, status: MoveGroupStatus, updates: Partial<StockMoveGroup>, session?: TransactionSession): Promise<StockMoveGroup>;
+  list(query: ListQuery, ctx: FlowContext, session?: TransactionSession): Promise<PaginatedResult<StockMoveGroup>>;
+}
+//#endregion
+//#region src/repositories/node.repository.d.ts
+declare class NodeRepository implements NodePort {
+  private repo;
+  constructor(model: Model<InventoryNodeDocument>, plugins?: PluginType[]);
+  findById(id: string, ctx: FlowContext, session?: TransactionSession): Promise<InventoryNode | null>;
+  findDefault(ctx: FlowContext, session?: TransactionSession): Promise<InventoryNode | null>;
+  list(ctx: FlowContext, session?: TransactionSession): Promise<InventoryNode[]>;
+  create(input: Omit<InventoryNode, '_id' | 'createdAt' | 'updatedAt'>, session?: TransactionSession): Promise<InventoryNode>;
+  update(id: string, updates: Partial<InventoryNode>, ctx: FlowContext, session?: TransactionSession): Promise<InventoryNode>;
+}
+//#endregion
+//#region src/repositories/procurement.repository.d.ts
+declare class ProcurementRepository implements ProcurementPort {
+  private repo;
+  constructor(model: Model<ProcurementOrderDocument>, plugins?: PluginType[]);
+  create(input: Omit<ProcurementOrder, '_id' | 'createdAt' | 'updatedAt'>, session?: TransactionSession): Promise<ProcurementOrder>;
+  findById(id: string, ctx: FlowContext, session?: TransactionSession): Promise<ProcurementOrder | null>;
+  updateStatus(id: string, status: ProcurementStatus, updates: Partial<ProcurementOrder>, session?: TransactionSession): Promise<ProcurementOrder>;
+  findMany(filter: Record<string, unknown>, ctx: FlowContext, session?: TransactionSession, options?: QueryOptions): Promise<ProcurementOrder[]>;
+  list(query: ListQuery, ctx: FlowContext, session?: TransactionSession): Promise<PaginatedResult<ProcurementOrder>>;
+}
+//#endregion
+//#region src/repositories/quant.repository.d.ts
+declare class QuantRepository implements QuantPort {
+  private repo;
+  constructor(model: Model<StockQuantDocument>, plugins?: PluginType[]);
+  getAvailability(query: AvailabilityQuery, ctx: FlowContext, session?: TransactionSession): Promise<Availability>;
+  upsert(update: QuantUpdate, session?: TransactionSession): Promise<StockQuant>;
+  batchUpsert(updates: QuantUpdate[], session?: TransactionSession): Promise<void>;
+  findByIdentity(identity: QuantIdentity, session?: TransactionSession): Promise<StockQuant | null>;
+  findMany(filter: Record<string, unknown>, ctx: FlowContext, session?: TransactionSession, options?: QueryOptions): Promise<StockQuant[]>;
+  deleteAll(ctx: FlowContext, session?: TransactionSession): Promise<void>;
+}
+//#endregion
+//#region src/repositories/replenishment-rule.repository.d.ts
+declare class ReplenishmentRuleRepository implements ReplenishmentRulePort {
+  private repo;
+  constructor(model: Model<ReplenishmentRuleDocument>, plugins?: PluginType[]);
+  findByNode(nodeId: string, ctx: FlowContext, session?: TransactionSession): Promise<ReplenishmentRule[]>;
+  findBySkuRef(skuRef: string, ctx: FlowContext, session?: TransactionSession): Promise<ReplenishmentRule[]>;
+  list(ctx: FlowContext, session?: TransactionSession): Promise<ReplenishmentRule[]>;
+  findById(id: string, ctx: FlowContext, session?: TransactionSession): Promise<ReplenishmentRule | null>;
+  delete(id: string, ctx: FlowContext, session?: TransactionSession): Promise<void>;
+  findMany(filter: Record<string, unknown>, ctx: FlowContext, session?: TransactionSession, options?: QueryOptions): Promise<ReplenishmentRule[]>;
+  create(input: Omit<ReplenishmentRule, '_id' | 'createdAt' | 'updatedAt'>, session?: TransactionSession): Promise<ReplenishmentRule>;
+  update(id: string, updates: Partial<ReplenishmentRule>, ctx: FlowContext, session?: TransactionSession): Promise<ReplenishmentRule>;
+}
+//#endregion
+//#region src/repositories/reservation.repository.d.ts
+declare class ReservationRepository implements ReservationPort {
+  private repo;
+  constructor(model: Model<ReservationDocument>, plugins?: PluginType[]);
+  create(input: CreateReservationInput, session?: TransactionSession): Promise<Reservation>;
+  findById(id: string, ctx: FlowContext, session?: TransactionSession): Promise<Reservation | null>;
+  findByOwner(ownerType: string, ownerId: string, ctx: FlowContext, session?: TransactionSession): Promise<Reservation[]>;
+  updateStatus(id: string, status: ReservationStatus, updates: Partial<Reservation>, session?: TransactionSession): Promise<Reservation>;
+  findExpired(asOf: Date, ctx: FlowContext, session?: TransactionSession): Promise<Reservation[]>;
+}
+//#endregion
+//#region src/repositories/types.d.ts
+/**
+ * Cast the opaque TransactionSession to Mongoose ClientSession.
+ * This is the one unavoidable branded-type cast in the repo layer — the port
+ * uses an opaque type so services never touch mongoose directly.
+ */
+declare function toSession(session?: TransactionSession): ClientSession | undefined;
+/** Convert FlowContext organizationId (string) to ObjectId for MongoDB queries. */
+declare function toOrgId(ctx: FlowContext): Types.ObjectId;
+/**
+ * Extract docs from MongoKit's PaginationResult or raw array.
+ * - Paginated result (offset, keyset, aggregate): returns `.docs`
+ * - Raw array (from noPagination: true / findAll): returns as-is
+ */
+declare function extractDocs<T>(result: PaginationResult<T> | T[]): T[];
+/**
+ * Narrow a PaginationResult to its offset variant with full metadata.
+ * Safe to call when you know the query used offset pagination (page param).
+ */
+declare function asOffsetResult<T>(result: PaginationResult<T>): OffsetPaginationResult<T>;
+//#endregion
+//#region src/repositories/index.d.ts
+interface FlowRepositories {
+  quant: QuantPort;
+  move: MovePort;
+  moveGroup: MoveGroupPort;
+  reservation: ReservationPort;
+  location: LocationPort;
+  node: NodePort;
+  lot: LotPort;
+  costLayer: CostLayerPort;
+  procurement: ProcurementPort;
+  count: CountPort;
+  replenishmentRule: ReplenishmentRulePort;
+}
+/**
+ * Per-repository plugin overrides.
+ * Only specify plugins for repos that need them — others get no plugins (lean).
+ */
+interface RepositoryPlugins {
+  quant?: PluginType[];
+  move?: PluginType[];
+  moveGroup?: PluginType[];
+  reservation?: PluginType[];
+  location?: PluginType[];
+  node?: PluginType[];
+  lot?: PluginType[];
+  costLayer?: PluginType[];
+  procurement?: PluginType[];
+  count?: PluginType[];
+  replenishmentRule?: PluginType[];
+}
+declare function createRepositories(models: FlowModels, plugins?: RepositoryPlugins): FlowRepositories;
+//#endregion
+export { CountRepository as _, extractDocs as a, ReservationRepository as c, ProcurementRepository as d, NodeRepository as f, LocationRepository as g, LotRepository as h, asOffsetResult as i, ReplenishmentRuleRepository as l, MoveRepository as m, RepositoryPlugins as n, toOrgId as o, MoveGroupRepository as p, createRepositories as r, toSession as s, FlowRepositories as t, QuantRepository as u, CostLayerRepository as v };

package/dist/index-CMTUKEK_.d.mts

@@ -0,0 +1,308 @@
+import { n as VirtualLocationMap } from "./virtual-locations-B9zXqPdi.mjs";
+import { t as CountPort } from "./count.port-BRqwGbi3.mjs";
+import { n as MovePort, r as StockMove, t as CreateMoveInput } from "./move.port-Qg1CYp7h.mjs";
+import { i as PaginatedResult, n as FlowMode, r as ListQuery, t as FlowContext } from "./index-DFF0GJ4J.mjs";
+import { t as CostLayerPort } from "./cost-layer.port-iH9pvZqB.mjs";
+import { i as Reservation, n as ReservationPort, r as NodePort } from "./reservation.port-l9NFQ0si.mjs";
+import { t as LocationPort } from "./location.port-CValXIpb.mjs";
+import { n as ProcurementPort, t as ReplenishmentRulePort } from "./replenishment-rule.port-DnEYtbyD.mjs";
+import { t as LotPort } from "./lot.port-ChsmvZqs.mjs";
+import { a as StockMoveGroup, n as MoveGroupPort } from "./move-group.port-DHGoQA3d.mjs";
+import { n as StockQuant } from "./stock-quant-CZhgvTu7.mjs";
+import { n as UnitOfWork } from "./unit-of-work.port-CWEkrDKu.mjs";
+import { t as EventEmitterPort } from "./event-emitter.port-BFh2pasY.mjs";
+import { n as AvailabilityQuery, r as QuantPort, t as Availability } from "./quant.port-BBa66PBT.mjs";
+import { t as RuntimeConfig } from "./runtime-config-CQLtPPqY.mjs";
+import { n as CountingService } from "./counting.service-CpAxU2G0.mjs";
+import { n as CatalogBridge } from "./catalog-bridge-K8bdkncJ.mjs";
+import { n as AllocationResult, t as AllocationPolicy } from "./allocation-policy-my_HfzdV.mjs";
+import { t as ValuationPolicy } from "./valuation-policy-Dco8c9Vw.mjs";
+import { t as IdempotencyPort } from "./idempotency.port-CTC70JON.mjs";
+import { n as ScanResolution } from "./scan-token-CNM9QVLY.mjs";
+import { i as StockAgingReport, o as HealthMetricsReport, t as TurnoverReport, u as AvailabilityReport } from "./index-BmNm3oNU2.mjs";
+import { r as TraceService } from "./trace.service-B9vAh-l-.mjs";
+import { t as CostLayerService } from "./cost-layer.service-DWmo9dQz.mjs";
+import { r as PackageService } from "./package.service-C605NaBQ.mjs";
+import { o as ProcurementService, r as ReplenishmentService } from "./replenishment.service-HO0sDhB_.mjs";
+import { Model } from "mongoose";
+
+//#region src/services/allocation.service.d.ts
+interface AllocateInput {
+  skuRef: string;
+  quantity: number;
+  nodeId?: string;
+  locationId?: string;
+  policy?: string;
+}
+interface AvailabilityCheckItem {
+  skuRef: string;
+  quantity: number;
+}
+interface AvailabilityCheckResult {
+  items: Array<{
+    skuRef: string;
+    requested: number;
+    available: number;
+    fulfilled: boolean;
+  }>;
+  allFulfilled: boolean;
+}
+declare class AllocationService {
+  private quantPort;
+  private defaultPolicy;
+  private policyRegistry;
+  constructor(quantPort: QuantPort, defaultPolicy: AllocationPolicy);
+  /**
+   * Register a named allocation policy.
+   * Consumers can register per-node or per-category policies.
+   */
+  registerPolicy(policy: AllocationPolicy): void;
+  /**
+   * Get a policy by name. Falls back to default.
+   */
+  getPolicy(name?: string): AllocationPolicy;
+  allocate(input: AllocateInput, ctx: FlowContext): Promise<AllocationResult>;
+  checkAvailability(items: AvailabilityCheckItem[], nodeId: string, ctx: FlowContext): Promise<AvailabilityCheckResult>;
+}
+//#endregion
+//#region src/services/posting.service.d.ts
+interface PostResult {
+  move: StockMove;
+  sourceQuant: StockQuant;
+  destinationQuant: StockQuant;
+}
+declare class PostingService {
+  private unitOfWork;
+  private movePort;
+  private quantPort;
+  private eventEmitter;
+  private locationPort;
+  private runtimeConfig;
+  constructor(unitOfWork: UnitOfWork, movePort: MovePort, quantPort: QuantPort, eventEmitter: EventEmitterPort, locationPort: LocationPort | undefined, runtimeConfig: RuntimeConfig);
+  postMove(moveId: string, payload: {
+    quantityDone: number;
+    executedAt?: Date;
+    forceAllowNegative?: boolean;
+  }, ctx: FlowContext): Promise<PostResult>;
+}
+//#endregion
+//#region src/services/move.service.d.ts
+declare class MoveService {
+  private movePort;
+  private postingService;
+  private unitOfWork;
+  private eventEmitter;
+  private idempotency;
+  constructor(movePort: MovePort, postingService: PostingService, unitOfWork: UnitOfWork, eventEmitter: EventEmitterPort, idempotency: IdempotencyPort | null);
+  create(input: CreateMoveInput, ctx: FlowContext): Promise<StockMove>;
+  commit(moveId: string, payload: {
+    quantityDone: number;
+    trackingAssignments?: Array<Record<string, unknown>>;
+    executedAt?: Date;
+  }, ctx: FlowContext): Promise<StockMove>;
+  private executeCommit;
+  cancel(moveId: string, ctx: FlowContext): Promise<StockMove>;
+}
+//#endregion
+//#region src/services/move-group.service.d.ts
+type GroupAction = 'confirm' | 'allocate' | 'dispatch' | 'receive' | 'cancel';
+interface CreateMoveGroupServiceInput {
+  groupType: string;
+  sourceNodeId?: string;
+  destinationNodeId?: string;
+  priority?: number;
+  counterparty?: {
+    type: string;
+    id: string;
+  };
+  notes?: string;
+  metadata?: Record<string, unknown>;
+  items: Array<CreateMoveInput>;
+}
+declare class MoveGroupService {
+  private moveGroupPort;
+  private movePort;
+  private quantPort;
+  private reservationPort;
+  private unitOfWork;
+  private eventEmitter;
+  private getNextSequence;
+  private runtimeConfig;
+  private virtualLocations;
+  private postingService;
+  private procurementPort?;
+  constructor(moveGroupPort: MoveGroupPort, movePort: MovePort, quantPort: QuantPort, reservationPort: ReservationPort, _locationPort: LocationPort, _nodePort: NodePort, unitOfWork: UnitOfWork, eventEmitter: EventEmitterPort, _idempotency: IdempotencyPort | null, _catalogBridge: CatalogBridge, getNextSequence: (prefix: string, organizationId: string) => Promise<number>, runtimeConfig: RuntimeConfig, virtualLocations: VirtualLocationMap, postingService: PostingService, procurementPort?: ProcurementPort | undefined);
+  create(input: CreateMoveGroupServiceInput, ctx: FlowContext): Promise<StockMoveGroup>;
+  createFromProcurement(orderId: string, ctx: FlowContext): Promise<StockMoveGroup>;
+  executeAction(id: string, action: GroupAction, payload: Record<string, unknown>, ctx: FlowContext): Promise<StockMoveGroup>;
+  getById(id: string, ctx: FlowContext): Promise<StockMoveGroup | null>;
+  list(query: ListQuery, ctx: FlowContext): Promise<PaginatedResult<StockMoveGroup>>;
+  private confirmGroup;
+  private allocateGroup;
+  private dispatchGroup;
+  private receiveGroup;
+  /**
+   * Consume and release a reservation after its move has been fulfilled.
+   * Consumes the fulfilled quantity, then releases the full reserved amount from the quant.
+   */
+  private releaseReservation;
+  private cancelGroup;
+  private requireGroup;
+  private assertGroupTransition;
+}
+//#endregion
+//#region src/services/quant.service.d.ts
+interface ProjectedAvailability extends Availability {
+  projectedIncoming: number;
+  projectedOutgoing: number;
+  projectedAvailable: number;
+}
+interface RebuildScope {
+  skuRef?: string;
+  locationId?: string;
+  nodeId?: string;
+}
+interface RebuildResult {
+  quantsRebuilt: number;
+  discrepancies: Array<{
+    skuRef: string;
+    locationId: string;
+    previousOnHand: number;
+    rebuiltOnHand: number;
+    delta: number;
+  }>;
+}
+declare class QuantService {
+  private quantPort;
+  private movePort;
+  private unitOfWork;
+  private locationPort?;
+  constructor(quantPort: QuantPort, movePort: MovePort, _eventEmitter: EventEmitterPort, unitOfWork: UnitOfWork, locationPort?: LocationPort | undefined);
+  getAvailability(query: AvailabilityQuery, ctx: FlowContext): Promise<Availability>;
+  getProjectedAvailability(query: AvailabilityQuery, ctx: FlowContext): Promise<ProjectedAvailability>;
+  rebuildFromMoveHistory(scope: RebuildScope, ctx: FlowContext): Promise<RebuildResult>;
+}
+//#endregion
+//#region src/services/reservation.service.d.ts
+interface ReserveInput {
+  reservationType: 'soft' | 'hard';
+  ownerType: string;
+  ownerId: string;
+  skuRef: string;
+  locationId: string;
+  lotId?: string;
+  quantity: number;
+  expiresAt?: Date;
+  allocationPolicy?: string;
+}
+declare class ReservationService {
+  private reservationPort;
+  private quantPort;
+  private unitOfWork;
+  private eventEmitter;
+  private movePort?;
+  private idempotency?;
+  constructor(reservationPort: ReservationPort, quantPort: QuantPort, unitOfWork: UnitOfWork, eventEmitter: EventEmitterPort, movePort?: MovePort | undefined, idempotency?: (IdempotencyPort | null) | undefined);
+  reserve(input: ReserveInput, ctx: FlowContext): Promise<Reservation>;
+  private executeReserve;
+  /**
+   * Bulk-reserve for all move lines in a move group.
+   * Creates one reservation per move line, all within a single transaction.
+   */
+  reserveForMoveGroup(moveGroupId: string, ctx: FlowContext): Promise<Reservation[]>;
+  private _reserveInSession;
+  release(reservationId: string, ctx: FlowContext): Promise<Reservation>;
+  consume(reservationId: string, quantity: number, ctx: FlowContext): Promise<Reservation>;
+  expire(reservationId: string, ctx: FlowContext): Promise<Reservation>;
+  /**
+   * Cleanup job — find and expire all reservations past their expiresAt.
+   * Call this from a cron job or scheduled worker.
+   */
+  cleanupExpired(ctx: FlowContext): Promise<{
+    expired: number;
+  }>;
+}
+//#endregion
+//#region src/services/scan.service.d.ts
+declare class ScanService {
+  private locationPort;
+  private lotPort;
+  private catalogBridge;
+  constructor(locationPort: LocationPort, lotPort: LotPort, catalogBridge: CatalogBridge);
+  resolve(token: string, ctx: FlowContext): Promise<ScanResolution>;
+}
+//#endregion
+//#region src/services/index.d.ts
+/** Aggregated reporting facade for the FlowEngine. */
+interface ReportingServices {
+  stockAging: StockAgingReport;
+  turnover: TurnoverReport;
+  availability: AvailabilityReport;
+  healthMetrics: HealthMetricsReport;
+}
+interface FlowServices {
+  move: MoveService;
+  moveGroup: MoveGroupService;
+  quant: QuantService;
+  posting: PostingService;
+  reservation: ReservationService;
+  allocation: AllocationService;
+  scan: ScanService;
+  procurement: ProcurementService;
+  replenishment: ReplenishmentService;
+  counting: CountingService;
+  package: PackageService;
+  costLayer: CostLayerService;
+  trace: TraceService;
+  reporting: ReportingServices;
+  /** Active deployment mode. */
+  readonly mode: FlowMode;
+  /** Active routing config (enterprise only). */
+  readonly routing: {
+    putaway: boolean;
+    removal: boolean;
+    crossDock: boolean;
+  };
+  /** Active valuation config. */
+  readonly valuation: {
+    method: string;
+  };
+}
+interface CreateServicesInput {
+  repositories: {
+    move: MovePort;
+    moveGroup: MoveGroupPort;
+    quant: QuantPort;
+    reservation: ReservationPort;
+    location: LocationPort;
+    node: NodePort;
+    lot: LotPort;
+    costLayer: CostLayerPort;
+    procurement: ProcurementPort;
+    replenishmentRule: ReplenishmentRulePort;
+    count: CountPort;
+  };
+  /** Package model for PackageService (raw Mongoose model). */
+  packageModel?: Model<unknown>;
+  unitOfWork: UnitOfWork;
+  eventEmitter: EventEmitterPort;
+  idempotency: IdempotencyPort | null;
+  catalogBridge: CatalogBridge;
+  allocationPolicy: AllocationPolicy;
+  getNextSequence: (prefix: string, organizationId: string) => Promise<number>;
+  /** Deployment mode — controls feature availability. */
+  mode?: FlowMode;
+  /** Enterprise routing features. */
+  routing?: {
+    putaway?: boolean;
+    removal?: boolean;
+    crossDock?: boolean;
+  };
+  /** Valuation settings. */
+  valuation?: Partial<ValuationPolicy>;
+  /** Resolved virtual location map. */
+  virtualLocations?: VirtualLocationMap;
+}
+declare function createServices(input: CreateServicesInput): FlowServices;
+//#endregion
+export { PostingService as _, ScanService as a, AvailabilityCheckItem as b, ProjectedAvailability as c, RebuildScope as d, CreateMoveGroupServiceInput as f, PostResult as g, MoveService as h, createServices as i, QuantService as l, MoveGroupService as m, FlowServices as n, ReservationService as o, GroupAction as p, ReportingServices as r, ReserveInput as s, CreateServicesInput as t, RebuildResult as u, AllocateInput as v, AvailabilityCheckResult as x, AllocationService as y };