@de./types 1.0.0

package/src/lsp/order/management.ts

@@ -0,0 +1,367 @@
+import { Type, Static } from '@sinclair/typebox'
+import {
+	APIErrorSchema,
+	APIHeadersSchema,
+	APIResponseBaseSchema,
+	APIResponseDataSchemaFactory
+} from '../../api'
+
+// ─── Order Management RVS ─────────────────────────────────────────────────────
+
+const OrderBlockerSchema = Type.Object({
+	reference:        Type.String(),
+	type:             Type.String(),
+	currentStatus:    Type.String(),
+	requiredStatuses: Type.Optional(Type.Array(Type.String()))
+})
+
+const CompensationResultSchema = Type.Object({
+	strategy:        Type.String(),
+	childrenUpdated: Type.Number(),
+	errors:          Type.Array(Type.Object({
+		childReference: Type.String(),
+		error:          Type.String()
+	}))
+})
+
+export const LSPOrderCompleteRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ reference: Type.String() }),
+	body:     Type.Object({
+		orderType:        Type.String(),
+		actualPickupAt:   Type.Optional(Type.Number()),
+		actualDeliveryAt: Type.Optional(Type.Number())
+	}),
+	response: {
+		200:   APIResponseBaseSchema,
+		400:   APIResponseDataSchemaFactory({
+			blockers: Type.Optional(Type.Array(OrderBlockerSchema))
+		}),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPOrderCancelRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ reference: Type.String() }),
+	body:     Type.Object({
+		orderType: Type.String(),
+		reason:    Type.Optional(Type.String())
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({
+			compensation: CompensationResultSchema
+		}),
+		400:   APIResponseDataSchemaFactory({
+			suggestion:      Type.String(),
+			activeChildren:  Type.Optional(Type.Array(Type.Object({
+				reference: Type.String(),
+				type:      Type.String(),
+				status:    Type.String()
+			})))
+		}),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPOrderFailRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ reference: Type.String() }),
+	body:     Type.Object({
+		orderType:   Type.String(),
+		reason:      Type.String(),
+		failureCode: Type.Optional(Type.String())
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({
+			compensation: Type.Object({
+				strategy:          Type.String(),
+				compensatedOrders: Type.Array(Type.String()),
+				failures:          Type.Array(Type.Object({
+					orderReference: Type.String(),
+					error:          Type.String()
+				}))
+			})
+		}),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPOrderUpdateStageRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ reference: Type.String() }),
+	body:     Type.Object({
+		orderType: Type.String(),
+		newStage:  Type.String()
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({
+			previousStage: Type.String(),
+			newStage:      Type.String()
+		}),
+		400:   APIResponseDataSchemaFactory({
+			currentStage:    Type.String(),
+			requestedStage:  Type.String(),
+			validNextStages: Type.Optional(Type.Array(Type.String()))
+		}),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPOrderGetStatusRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ reference: Type.String() }),
+	response: {
+		200:   APIResponseDataSchemaFactory({
+			reference: Type.String(),
+			tracking:  Type.Object({
+				masterTrackingNumber:    Type.String(),
+				trackingNumber:          Type.String(),
+				carrierTrackingNumber:   Type.Optional(Type.String())
+			}),
+			flow:      Type.Object({
+				process:  Type.String(),
+				stage:    Type.String(),
+				status:   Type.String(),
+				priority: Type.String()
+			}),
+			hierarchy:    Type.Object({
+				isRoot:            Type.Boolean(),
+				depth:             Type.Number(),
+				childOrders:       Type.Optional(Type.Array(Type.Any())),
+				compensationState: Type.Optional(Type.Any())
+			}),
+			compensation: Type.Optional(Type.Any())
+		}),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPOrderListRVS = {
+	headers:     APIHeadersSchema,
+	querystring: Type.Object({
+		orderType: Type.Optional(Type.String()),
+		status:    Type.Optional(Type.String()),
+		stage:     Type.Optional(Type.String()),
+		process:   Type.Optional(Type.String()),
+		fromDate:  Type.Optional(Type.Number()),
+		toDate:    Type.Optional(Type.Number()),
+		limit:     Type.Optional(Type.Number({ minimum: 1, maximum: 200, default: 20 })),
+		offset:    Type.Optional(Type.Number({ minimum: 0, default: 0 }))
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({
+			orders: Type.Array(Type.Any()),
+			total:  Type.Number(),
+			limit:  Type.Number(),
+			offset: Type.Number()
+		}),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPOrderGetRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ reference: Type.String() }),
+	response: {
+		200:   APIResponseDataSchemaFactory({ order: Type.Any() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+// ─── Subscribe RVS ────────────────────────────────────────────────────────────
+
+export const LSPOrderSubscribeRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({
+		id:        Type.String({ description: 'LSP ID' }),
+		reference: Type.String({ description: 'Order reference' })
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({
+			socketToken: Type.String(),
+			room:        Type.String(),
+			expiry:      Type.Number()
+		}),
+		'4XX': APIErrorSchema
+	}
+}
+
+// ─── Sorting RVS ──────────────────────────────────────────────────────────────
+
+const SortingCriteriaSchema = Type.Union([
+	Type.Literal('DESTINATION'),
+	Type.Literal('SERVICE_LEVEL'),
+	Type.Literal('CARRIER'),
+	Type.Literal('ROUTE'),
+	Type.Literal('ZONE')
+])
+
+export const LSPSortingListQuerySchema = Type.Object({
+	destination:  Type.Optional(Type.String()),
+	serviceLevel: Type.Optional(Type.String()),
+	fromDate:     Type.Optional(Type.Number()),
+	toDate:       Type.Optional(Type.Number()),
+	limit:        Type.Optional(Type.Number({ minimum: 1, maximum: 200, default: 50 })),
+	offset:       Type.Optional(Type.Number({ minimum: 0, default: 0 }))
+})
+
+export const LSPSortRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ hubId: Type.String() }),
+	body:     Type.Object({
+		orderReferences: Type.Array(Type.String()),
+		sortingCriteria: SortingCriteriaSchema,
+		destination:     Type.Optional(Type.String()),
+		equipment:       Type.Optional(Type.String()),
+		operator:        Type.Optional(Type.String()),
+		notes:           Type.Optional(Type.String())
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({
+			sorted: Type.Array(Type.Object({
+				reference:       Type.String(),
+				sortDestination: Type.String(),
+				status:          Type.String()
+			})),
+			failed: Type.Array(Type.Object({
+				reference: Type.String(),
+				reason:    Type.String()
+			}))
+		}),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPSortingStatsRVS = {
+	headers:     APIHeadersSchema,
+	params:      Type.Object({ hubId: Type.String() }),
+	querystring: Type.Object({
+		fromDate: Type.Optional(Type.Number()),
+		toDate:   Type.Optional(Type.Number())
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({
+			stats: Type.Object({
+				totalSorted:     Type.Number(),
+				sortingRate:     Type.Number(),
+				accuracy:        Type.Number(),
+				byDestination:   Type.Record(Type.String(), Type.Number()),
+				byServiceLevel:  Type.Record(Type.String(), Type.Number()),
+				avgSortTime:     Type.Number()
+			})
+		}),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPSortingListRVS = {
+	headers:     APIHeadersSchema,
+	params:      Type.Object({ hubId: Type.String() }),
+	querystring: LSPSortingListQuerySchema,
+	response: {
+		200:   APIResponseDataSchemaFactory({
+			orders: Type.Array(Type.Any()),
+			total:  Type.Number(),
+			limit:  Type.Number(),
+			offset: Type.Number()
+		}),
+		'4XX': APIErrorSchema
+	}
+}
+
+// ─── Cross-Dock RVS ───────────────────────────────────────────────────────────
+
+const CrossDockPrioritySchema = Type.Union([
+	Type.Literal('LOW'),
+	Type.Literal('NORMAL'),
+	Type.Literal('HIGH'),
+	Type.Literal('URGENT')
+])
+
+export const LSPCrossDockInitiateRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ hubId: Type.String() }),
+	body:     Type.Object({
+		orderReferences: Type.Array(Type.String()),
+		targetHub:       Type.Optional(Type.String()),
+		targetCarrier:   Type.Optional(Type.String()),
+		priority:        Type.Optional(CrossDockPrioritySchema),
+		maxDwellTime:    Type.Optional(Type.Number({ description: 'Minutes' })),
+		notes:           Type.Optional(Type.String())
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({
+			crossDocked: Type.Array(Type.Object({
+				reference: Type.String(),
+				status:    Type.String(),
+				dwellTime: Type.Optional(Type.Number())
+			})),
+			failed: Type.Array(Type.Object({
+				reference: Type.String(),
+				reason:    Type.String()
+			}))
+		}),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPCrossDockCompleteRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ hubId: Type.String() }),
+	body:     Type.Object({
+		orderReferences: Type.Array(Type.String()),
+		vehicleId:       Type.Optional(Type.String()),
+		driverId:        Type.Optional(Type.String()),
+		departureTime:   Type.Optional(Type.Number()),
+		notes:           Type.Optional(Type.String())
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({
+			dispatched: Type.Array(Type.String()),
+			failed:     Type.Array(Type.Object({
+				reference: Type.String(),
+				reason:    Type.String()
+			})),
+			message: Type.String()
+		}),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPCrossDockStatsRVS = {
+	headers:     APIHeadersSchema,
+	params:      Type.Object({ hubId: Type.String() }),
+	querystring: Type.Object({
+		fromDate: Type.Optional(Type.Number()),
+		toDate:   Type.Optional(Type.Number())
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({
+			stats: Type.Object({
+				totalCrossDocked: Type.Number(),
+				avgDwellTime:     Type.Number(),
+				onTimeDispatch:   Type.Number(),
+				byPriority:       Type.Record(Type.String(), Type.Number())
+			})
+		}),
+		'4XX': APIErrorSchema
+	}
+}
+
+// ─── Validation types ─────────────────────────────────────────────────────────
+
+export type LSPOrderCompleteValidation     = { params: Static<typeof LSPOrderCompleteRVS.params>, body: Static<typeof LSPOrderCompleteRVS.body>, response: Static<(typeof LSPOrderCompleteRVS.response)[200]> }
+export type LSPOrderCancelValidation       = { params: Static<typeof LSPOrderCancelRVS.params>, body: Static<typeof LSPOrderCancelRVS.body>, response: Static<(typeof LSPOrderCancelRVS.response)[200]> }
+export type LSPOrderFailValidation         = { params: Static<typeof LSPOrderFailRVS.params>, body: Static<typeof LSPOrderFailRVS.body>, response: Static<(typeof LSPOrderFailRVS.response)[200]> }
+export type LSPOrderUpdateStageValidation  = { params: Static<typeof LSPOrderUpdateStageRVS.params>, body: Static<typeof LSPOrderUpdateStageRVS.body>, response: Static<(typeof LSPOrderUpdateStageRVS.response)[200]> }
+export type LSPOrderGetStatusValidation    = { params: Static<typeof LSPOrderGetStatusRVS.params>, response: Static<(typeof LSPOrderGetStatusRVS.response)[200]> }
+export type LSPOrderListValidation         = { querystring: Static<typeof LSPOrderListRVS.querystring>, response: Static<(typeof LSPOrderListRVS.response)[200]> }
+export type LSPOrderGetValidation          = { params: Static<typeof LSPOrderGetRVS.params>, response: Static<(typeof LSPOrderGetRVS.response)[200]> }
+export type LSPOrderSubscribeValidation    = { params: Static<typeof LSPOrderSubscribeRVS.params>, response: Static<(typeof LSPOrderSubscribeRVS.response)[200]> }
+export type LSPSortValidation              = { params: Static<typeof LSPSortRVS.params>, body: Static<typeof LSPSortRVS.body>, response: Static<(typeof LSPSortRVS.response)[200]> }
+export type LSPSortingListValidation       = { params: Static<typeof LSPSortingListRVS.params>, querystring: Static<typeof LSPSortingListRVS.querystring>, response: Static<(typeof LSPSortingListRVS.response)[200]> }
+export type LSPSortingStatsValidation      = { params: Static<typeof LSPSortingStatsRVS.params>, querystring: Static<typeof LSPSortingStatsRVS.querystring>, response: Static<(typeof LSPSortingStatsRVS.response)[200]> }
+export type LSPCrossDockInitiateValidation = { params: Static<typeof LSPCrossDockInitiateRVS.params>, body: Static<typeof LSPCrossDockInitiateRVS.body>, response: Static<(typeof LSPCrossDockInitiateRVS.response)[200]> }
+export type LSPCrossDockCompleteValidation = { params: Static<typeof LSPCrossDockCompleteRVS.params>, body: Static<typeof LSPCrossDockCompleteRVS.body>, response: Static<(typeof LSPCrossDockCompleteRVS.response)[200]> }
+export type LSPCrossDockStatsValidation    = { params: Static<typeof LSPCrossDockStatsRVS.params>, querystring: Static<typeof LSPCrossDockStatsRVS.querystring>, response: Static<(typeof LSPCrossDockStatsRVS.response)[200]> }

package/src/lsp/order/outbound.ts

@@ -0,0 +1,128 @@
+import { Type, Static } from '@sinclair/typebox'
+import { ActionRecordSchema } from '../../time'
+import { BaseOrderStatusSchema, BaseOrderFlowPrioritySchema, OrderAssigneeSchema, LSPBaseOrderSchema } from '../../order'
+import { OutboundOrderProcessSchema } from './flow/processes'
+import { OutboundOrderStageSchema } from './flow/stages'
+
+// Outbound Order Status Schema (extends BaseOrderStatus)
+export const OutboundOrderStatusSchema = Type.Union([
+  ...BaseOrderStatusSchema.anyOf,
+  Type.Literal('IN_BUCKET'),
+  Type.Literal('PICKED'),
+  Type.Literal('PACKED'),
+  Type.Literal('READY_TO_SHIP'),
+  Type.Literal('PARTIALLY_PICKED'),
+  Type.Literal('PARTIALLY_SHIPPED'),
+  Type.Literal('SHIPPED')
+])
+
+// Outbound Order Flow Schema
+export const OutboundOrderFlowSchema = Type.Object({
+  process: OutboundOrderProcessSchema,
+  stage: OutboundOrderStageSchema,
+  status: OutboundOrderStatusSchema,
+  priority: BaseOrderFlowPrioritySchema
+})
+
+// Outbound Order Schema (extends LSPBaseOrder)
+export const OutboundOrderSchema = Type.Intersect([
+  LSPBaseOrderSchema,
+  Type.Object({
+    flow: OutboundOrderFlowSchema
+  })
+])
+
+// Outbound Order Log Schema
+export const OutboundOrderLogSchema = Type.Intersect([
+  ActionRecordSchema,
+  Type.Object({
+    flow: OutboundOrderFlowSchema,
+    assignee: OrderAssigneeSchema,
+    reason: Type.Optional(Type.String({ maxLength: 500 }))
+  })
+])
+
+// Generate TypeScript types from schemas
+export type OutboundOrderProcess = Static<typeof OutboundOrderProcessSchema>
+export type OutboundOrderStage = Static<typeof OutboundOrderStageSchema>
+export type OutboundOrderStatus = Static<typeof OutboundOrderStatusSchema>
+export type OutboundOrderFlow = Static<typeof OutboundOrderFlowSchema>
+export type OutboundOrder = Static<typeof OutboundOrderSchema>
+export type OutboundOrderLog = Static<typeof OutboundOrderLogSchema>
+
+// Validation helpers for outbound order operations
+export const OutboundOrderValidationSchema = Type.Object({
+  process: OutboundOrderProcessSchema,
+  allowedStages: Type.Array(OutboundOrderStageSchema),
+  description: Type.String()
+})
+
+// Flow transition validation schema
+export const OutboundFlowTransitionSchema = Type.Object({
+  from: Type.Object({
+    process: OutboundOrderProcessSchema,
+    stage: OutboundOrderStageSchema,
+    status: OutboundOrderStatusSchema
+  }),
+  to: Type.Object({
+    process: OutboundOrderProcessSchema,
+    stage: OutboundOrderStageSchema,
+    status: OutboundOrderStatusSchema
+  }),
+  allowed: Type.Boolean(),
+  reason: Type.Optional(Type.String())
+})
+
+// Commented flow rules schema for future implementation
+export const OutboundFlowRulesSchema = Type.Record(
+  OutboundOrderProcessSchema,
+  Type.Array(OutboundOrderStageSchema),
+  {
+    description: 'Defines allowed stages for each outbound process',
+    examples: [{
+      'FULFILLMENT': ['PROCESSING', 'ALLOCATING', 'PICKING', 'PACKING', 'QUALITY_CHECK', 'STAGING'],
+      'REPLENISHMENT': ['PROCESSING', 'PICKING', 'STAGING'],
+      'TRANSFER': ['PROCESSING', 'ALLOCATING', 'PICKING', 'PACKING', 'STAGING'],
+      'CYCLE_COUNT': ['PROCESSING']
+    }]
+  }
+)
+
+// Picking optimization schemas
+export const OutboundPickingBatchSchema = Type.Object({
+  batchId: Type.String(),
+  orders: Type.Array(Type.String({ description: 'Order references' })),
+  assignee: OrderAssigneeSchema,
+  pickingMethod: Type.Union([
+    Type.Literal('SINGLE_ORDER'),
+    Type.Literal('BATCH_PICKING'),
+    Type.Literal('ZONE_PICKING'),
+    Type.Literal('WAVE_PICKING')
+  ]),
+  priority: Type.Number({ minimum: 1, maximum: 5 }),
+  estimatedDuration: Type.Optional(Type.Number({ description: 'Duration in minutes' })),
+  created: ActionRecordSchema
+})
+
+export const OutboundShipmentSchema = Type.Object({
+  shipmentId: Type.String(),
+  orders: Type.Array(Type.String({ description: 'Order references' })),
+  carrier: Type.String(),
+  carrierTrackingNumber: Type.Optional(Type.String()),
+  estimatedDelivery: Type.Optional(Type.Number()),
+  actualDelivery: Type.Optional(Type.Number()),
+  status: Type.Union([
+    Type.Literal('PREPARED'),
+    Type.Literal('PICKED_UP'),
+    Type.Literal('IN_TRANSIT'),
+    Type.Literal('DELIVERED'),
+    Type.Literal('FAILED_DELIVERY'),
+    Type.Literal('RETURNED')
+  ])
+})
+
+export type OutboundOrderValidation = Static<typeof OutboundOrderValidationSchema>
+export type OutboundFlowTransition = Static<typeof OutboundFlowTransitionSchema>
+export type OutboundFlowRules = Static<typeof OutboundFlowRulesSchema>
+export type OutboundPickingBatch = Static<typeof OutboundPickingBatchSchema>
+export type OutboundShipment = Static<typeof OutboundShipmentSchema>