@de./types 1.0.0

package/src/order.ts

@@ -0,0 +1,1207 @@
+import { Type, Static } from '@sinclair/typebox'
+import { MoneySchema, WeightSchema, VolumeSchema, DimensionsSchema, TemperatureSchema, SpecialHandlingSchema } from './measure'
+import { ActionRecordSchema, DateTimeRangeSchema, DateTimeScheduleSchema, DateTimeZoneSchema } from './time'
+import { ContextSchema, GenericServiceContextSchema, PipelineContextSchema } from './context'
+import { LSPOrderTypeSchema } from './lsp'
+import { UserTypeSchema } from './user'
+import { DProfileReferenceSchema } from './de.profile'
+import { AddressSchema, ContactsSchema } from './geo'
+import { PipelineExecutionSchema } from './realm'
+
+// Order Priority Schema
+export const OrderPrioritySchema = Type.Union([
+  Type.Literal('STANDARD'),
+  Type.Literal('EXPRESS'),
+  Type.Literal('OVERNIGHT'),
+  Type.Literal('SAME_DAY'),
+  Type.Literal('FREIGHT'),
+  Type.Literal('WHITE_GLOVE'),
+  Type.Literal('VIS') // VIS: Very Important Shipment
+])
+
+// Order Requirement Schema
+export const OrderRequirementSchema = Type.Union([
+  Type.Literal('SIGNATURE_REQUIRED'),
+  Type.Literal('AGE_VERIFICATION'),
+  Type.Literal('APPOINTMENT_DELIVERY'),
+  Type.Literal('INSIDE_DELIVERY'),
+  Type.Literal('TEMPERATURE_CONTROLLED'),
+  Type.Literal('HAZMAT_CERTIFIED'),
+  Type.Literal('FRAGILE_HANDLING')
+])
+
+// Order Item Schemas
+export const OrderItemStatusSchema = Type.Union([
+  Type.Literal('PENDING'),
+  Type.Literal('ALLOCATED'),
+  Type.Literal('PICKED'),
+  Type.Literal('PACKED'),
+  Type.Literal('SHIPPED'),
+  Type.Literal('BACKORDERED'),
+  Type.Literal('DELIVERED'),
+  Type.Literal('CANCELLED')
+])
+export const OrderItemSchema = Type.Object({
+  id: Type.String(),
+  orderRef: Type.String(),
+  productId: Type.String(),
+  sku: Type.String(),
+  name: Type.String({ minLength: 1, maxLength: 200 }),
+  quantity: Type.Number({ minimum: 1 }),
+  quantityFulfilled: Type.Number({ minimum: 0 }),
+  unitPrice: MoneySchema,
+  taxes: MoneySchema,
+  discounts: Type.Optional(MoneySchema),
+  slotId: Type.Optional(Type.String()),
+  lotNumber: Type.Optional(Type.String()),
+  serialNumbers: Type.Optional(Type.Array(Type.String())),
+  specialHandling: Type.Optional(Type.Array(SpecialHandlingSchema)),
+  notes: Type.Optional(Type.String({ maxLength: 500 })),
+  status: OrderItemStatusSchema
+})
+
+// Order Package Schemas
+export const OrderPackageTypeSchema = Type.Union([
+  Type.Literal('BOX'),
+  Type.Literal('TUBE'),
+  Type.Literal('ENVELOPE'),
+  Type.Literal('PALLET'),
+  Type.Literal('CUSTOM')
+])
+export const OrderPackageCategorySchema = Type.Union([
+  Type.Literal('FD'), // Food & Drinks / Food Delivery
+  Type.Literal('GR'), // Groceries
+  Type.Literal('FT'), // Furniture
+  Type.Literal('EC'), // Electronics
+  Type.Literal('CT'), // Clothing & Textiles
+  Type.Literal('MC'), // Medical Care / Medical & Cosmetics
+  Type.Literal('JR'), // Jewelry
+  Type.Literal('BP'), // Books & Publications
+  Type.Literal('WD'), // White Goods (appliances) / Wooden items
+  Type.Literal('EM'), // Emergency / Express Mail
+  Type.Literal('CM'), // Chemicals / Cosmetics
+  Type.Literal('SG'), // Sporting Goods
+  Type.Literal('IM'), // Industrial Materials / Import
+  Type.Literal('TY'), // Toys
+  Type.Literal('DM'), // Documents / Direct Mail
+  Type.Literal('AM'), // Automotive / Art & Media
+  Type.Literal('VC'), // Vehicle Components / Video Content
+  Type.Literal('HC'), // Health Care / Home Care
+  Type.Literal('UT'), // Utilities / Tools
+  Type.Literal('MN')  // Machinery / Maintenance
+])
+export const OrderPackageItemSchema = Type.Object({
+  itemId: Type.String(),
+  productId: Type.String(),
+  quantity: Type.Number({ minimum: 1 }),
+  source: Type.String(),
+  serialNumbers: Type.Optional(Type.Array(Type.String())),
+  lotNumber: Type.Optional(Type.Union([Type.String(), Type.Null()]))
+})
+export const OrderPackageSchema = Type.Object({
+  id: Type.String(),
+  // Serve as package Number
+  packageNumber: Type.Number({ minimum: 1 }),
+  // Package Tracking Code - Hierarchical tracking
+  tracking: Type.Optional(Type.Object({
+    masterTrackingNumber: Type.String(),
+    trackingNumber: Type.String(),
+    carrierTrackingNumber: Type.Optional(Type.String())
+  })),
+  type: OrderPackageTypeSchema,
+  category: OrderPackageCategorySchema,
+  /**
+   * Attach Waypoint No to the package for better
+   * referencing after routing optimization
+   */
+  waypointNo: Type.Optional(Type.String()),
+  shipmentId: Type.Optional(Type.String()),
+  // Classification care level of the package: From 1 to 5
+  careLevel: Type.Optional(Type.Number({ minimum: 1, maximum: 5 })),
+  weight: Type.Optional(WeightSchema),
+  volume: Type.Optional(VolumeSchema),
+  dimensions: Type.Optional(DimensionsSchema),
+  temperature: Type.Optional(TemperatureSchema),
+  notes: Type.Optional(Type.String({ maxLength: 500 })),
+  items: Type.Optional(Type.Array(OrderPackageItemSchema)),
+  specialHandling: Type.Optional(Type.Array(SpecialHandlingSchema)),
+  added: Type.Optional(ActionRecordSchema),
+  updated: Type.Optional(ActionRecordSchema)
+})
+
+// Order Payment Schemas
+export const OrderPaymentStatusSchema = Type.Union([
+  Type.Literal('PENDING'),
+  Type.Literal('AUTHORIZED'),
+  Type.Literal('CAPTURED'),
+  Type.Literal('FAILED'),
+  Type.Literal('REFUNDED')
+])
+export const OrderPaymentModeSchema = Type.Union([
+  Type.Literal('PREPAY'),
+  Type.Literal('POSTPAY'),
+  Type.Literal('CASH')
+])
+export const OrderPaymentSchema = Type.Object({
+  // Mode of payment: Define by LSP
+  mode: OrderPaymentModeSchema,
+  // Operation request payment state
+  status: OrderPaymentStatusSchema,
+  method: Type.Optional(Type.String()),
+  option: Type.Optional(Type.String())
+})
+
+// Order Operation Schema
+export const OrderOperationSchema = Type.Object({
+  fees: Type.Object({
+    cost: MoneySchema,
+    taxes: Type.Optional(MoneySchema),
+    discount: Type.Optional(MoneySchema),
+    total: MoneySchema
+  }),
+  payment: OrderPaymentSchema,
+  rating: Type.Optional(Type.Number({ minimum: 1, maximum: 5 }))
+})
+
+// Order Intent Schema
+export const OrderIntentSchema = Type.Object({
+  connectorId: Type.String(), // Access/Auth connector from which the intent token was issued
+  customerId: Type.String(), // Unique ID/reference of the client
+  origin: Type.String({ format: 'uri' }) // Domain origin from where order is intent from
+})
+
+// Compensation Action Schema - Defines what to do on failure (declared early for use in hierarchy)
+export const CompensationActionSchema = Type.Union([
+  Type.Literal('ROLLBACK_ALL'),
+  Type.Literal('ROLLBACK_SIBLINGS'),
+  Type.Literal('MARK_FAILED'),
+  Type.Literal('COMPENSATE'),
+  Type.Literal('MANUAL_INTERVENTION'),
+  Type.Literal('IGNORE')
+])
+
+// ========================================================================
+// ORDER COMPOSITION METADATA (Flaw #10 Fix)
+// ========================================================================
+
+// Creation Reason - WHY was this child order created?
+export const CompositionReasonSchema = Type.Union([
+  Type.Literal('LIFECYCLE_REQUIREMENT'),    // Required by order type lifecycle
+  Type.Literal('PIPELINE_STAGE'),           // Created by pipeline template
+  Type.Literal('AUTOMATIC_RULE'),           // Triggered by business rule
+  Type.Literal('CONDITIONAL_TRIGGER'),      // Condition met (e.g., value > $1000)
+  Type.Literal('EXCEPTION_HANDLING'),       // Exception/failure recovery
+  Type.Literal('MANUAL_REQUEST'),           // Operator/manager created
+  Type.Literal('COMPENSATION'),             // Created as compensating action
+  Type.Literal('SPLIT_ORDER')               // Split from larger order
+])
+
+// Relationship Type - Semantic meaning of parent-child relationship
+export const RelationshipTypeSchema = Type.Union([
+  Type.Literal('MANDATORY'),     // Must complete before parent can complete
+  Type.Literal('OPTIONAL'),      // Parent can complete without this child
+  Type.Literal('CONDITIONAL')    // Depends on runtime conditions
+])
+
+// Parent State at Child Creation - Context of parent when child was spawned
+export const ParentStateAtCreationSchema = Type.Object({
+  process: Type.String(),
+  stage: Type.String(),
+  status: Type.String()
+})
+
+// Child Order Relationship Metadata
+export const ChildOrderRelationshipSchema = Type.Object({
+  type: RelationshipTypeSchema,
+  canBlockParent: Type.Boolean(),              // Can this child block parent completion?
+  sequence: Type.Optional(Type.Number()),      // Order in execution sequence
+  dependencies: Type.Optional(Type.Array(Type.String()))  // Sibling order references this depends on
+})
+
+// Additional composition metadata
+export const CompositionMetadataSchema = Type.Optional(Type.Object({
+  trigger: Type.Optional(Type.String()),       // What triggered creation
+  notes: Type.Optional(Type.String()),         // Human notes
+  tags: Type.Optional(Type.Array(Type.String()))  // Categorization tags
+}))
+
+export const GenericOrderProcessorSchema = Type.Object({
+  context: ContextSchema,
+  service: GenericServiceContextSchema
+})
+
+// Order Hierarchy Schema (Parent-Child Relationships)
+export const OrderHierarchySchema = Type.Object({
+  // Is this the root/parent order (CSP's original order)?
+  isRoot: Type.Boolean(),
+  
+  // Reference to root order (always set for non-root orders)
+  rootOrderId: Type.Optional(Type.String()),
+  rootOrderReference: Type.Optional(Type.String()),
+  rootOrderType: Type.Optional(LSPOrderTypeSchema),
+  
+  // Immediate parent order (for multi-level hierarchies)
+  parentOrderId: Type.Optional(Type.String()),
+  parentOrderReference: Type.Optional(Type.String()),
+  parentOrderType: Type.Optional(Type.String()),
+  
+  // Child orders spawned from this order
+  childOrders: Type.Optional(Type.Array(Type.Object({
+    orderId: Type.String(),
+    orderReference: Type.String(),
+    orderType: Type.String(),
+    processor: GenericOrderProcessorSchema,
+    status: Type.String(),
+    created: ActionRecordSchema, // Who/what/when
+    
+    // Composition metadata
+    creationReason: CompositionReasonSchema,
+    parentStateAtCreation: ParentStateAtCreationSchema,
+    relationship: ChildOrderRelationshipSchema,
+    metadata: CompositionMetadataSchema,
+    
+    // Compensation tracking
+    compensation: Type.Object({
+      compensated: Type.Optional(Type.Boolean()),
+      recorded: Type.Optional(ActionRecordSchema),
+      action: Type.Optional(CompensationActionSchema),
+      reason: Type.Optional(Type.String())
+    })
+  }))),
+  
+  // Denormalized descendant tracking (Flaw #9 Fix)
+  allDescendantReferences: Type.Optional(Type.Array(Type.String())),
+  descendantCount: Type.Optional(Type.Number({ minimum: 0, default: 0 })),
+  descendantsByType: Type.Optional(Type.Record(Type.String(), Type.Array(Type.String()))),
+  
+  // Order depth in hierarchy (root = 0, first child = 1, etc.)
+  depth: Type.Number({ minimum: 0, default: 0 }),
+  
+  // Compensation state
+  compensationState: Type.Optional(Type.Object({
+    isCompensating: Type.Boolean(),
+    compensationStarted: Type.Optional(ActionRecordSchema),
+    compensationCompleted: Type.Optional(ActionRecordSchema),
+    compensationStrategy: Type.Optional(CompensationActionSchema),
+    compensatedChildren: Type.Optional(Type.Array(Type.String())),
+    failedCompensations: Type.Optional(Type.Array(Type.Object({
+      childReference: Type.String(),
+      error: Type.String(),
+      timestamp: Type.Number()
+    })))
+  }))
+})
+
+// ========================================================================
+// ORDER LIFECYCLE POLICIES
+// ========================================================================
+
+// Order Lifecycle Policy Schema - Defines parent-child completion rules
+export const OrderLifecyclePolicySchema = Type.Object({
+  // Parent completion rules
+  parentCompletion: Type.Object({
+    requireAllChildrenComplete: Type.Boolean(),
+    requiredChildStatuses: Type.Optional(Type.Array(Type.String())),
+    allowCompletionIfChildrenAre: Type.Optional(Type.Array(Type.String()))
+  }),
+  
+  // Parent cancellation rules
+  parentCancellation: Type.Object({
+    allowWithActiveChildren: Type.Boolean(),
+    childAction: Type.Union([
+      Type.Literal('CASCADE_CANCEL'),
+      Type.Literal('ORPHAN'),
+      Type.Literal('COMPLETE_FIRST'),
+      Type.Literal('SUSPEND')
+    ])
+  }),
+  
+  // Child completion rules
+  childCompletion: Type.Object({
+    requireActiveParent: Type.Boolean(),
+    notifyParent: Type.Boolean(),
+    autoCompleteParent: Type.Boolean()
+  })
+})
+
+// LSP Order Lifecycle Policies - Business rules for order relationships
+export const LSP_LIFECYCLE_POLICIES: Record<string, OrderLifecyclePolicy> = {
+  'OutboundOrder': {
+    parentCompletion: {
+      requireAllChildrenComplete: true,
+      requiredChildStatuses: ['COMPLETED', 'SHIPPED'],
+      allowCompletionIfChildrenAre: ['COMPLETED', 'SHIPPED', 'DELIVERED']
+    },
+    parentCancellation: {
+      allowWithActiveChildren: false,
+      childAction: 'CASCADE_CANCEL'
+    },
+    childCompletion: {
+      requireActiveParent: true,
+      notifyParent: true,
+      autoCompleteParent: true
+    }
+  },
+  
+  'InboundOrder': {
+    parentCompletion: {
+      requireAllChildrenComplete: true,
+      requiredChildStatuses: ['COMPLETED'],
+      allowCompletionIfChildrenAre: ['COMPLETED']
+    },
+    parentCancellation: {
+      allowWithActiveChildren: false,
+      childAction: 'CASCADE_CANCEL'
+    },
+    childCompletion: {
+      requireActiveParent: true,
+      notifyParent: true,
+      autoCompleteParent: true
+    }
+  },
+  
+  'InternalOrder': {
+    parentCompletion: {
+      requireAllChildrenComplete: true,
+      requiredChildStatuses: ['COMPLETED'],
+      allowCompletionIfChildrenAre: ['COMPLETED']
+    },
+    parentCancellation: {
+      allowWithActiveChildren: true,
+      childAction: 'CASCADE_CANCEL'
+    },
+    childCompletion: {
+      requireActiveParent: true,
+      notifyParent: true,
+      autoCompleteParent: true
+    }
+  },
+  
+  'ShippingOrder': {
+    parentCompletion: {
+      requireAllChildrenComplete: true,
+      requiredChildStatuses: ['COMPLETED', 'DELIVERED'],
+      allowCompletionIfChildrenAre: ['DELIVERED', 'COMPLETED']
+    },
+    parentCancellation: {
+      allowWithActiveChildren: false,
+      childAction: 'COMPLETE_FIRST'
+    },
+    childCompletion: {
+      requireActiveParent: true,
+      notifyParent: true,
+      autoCompleteParent: false
+    }
+  },
+  
+  'PassthroughOrder': {
+    parentCompletion: {
+      requireAllChildrenComplete: true,
+      requiredChildStatuses: ['COMPLETED', 'DISPATCHED'],
+      allowCompletionIfChildrenAre: ['COMPLETED', 'DISPATCHED']
+    },
+    parentCancellation: {
+      allowWithActiveChildren: true,
+      childAction: 'CASCADE_CANCEL'
+    },
+    childCompletion: {
+      requireActiveParent: true,
+      notifyParent: true,
+      autoCompleteParent: true
+    }
+  }
+}
+
+// ========================================================================
+// COMPENSATION & ROLLBACK STRATEGIES
+// ========================================================================
+
+// Compensation Strategy Schema
+export const CompensationStrategySchema = Type.Object({
+  // What to do when a child order fails fatally
+  onChildFailure: Type.Object({
+    action: CompensationActionSchema,
+    
+    // Should we rollback parent?
+    rollbackParent: Type.Boolean(),
+    
+    // Should we rollback siblings?
+    rollbackSiblings: Type.Boolean(),
+    
+    // Should we rollback completed children?
+    rollbackCompletedChildren: Type.Boolean(),
+    
+    // Custom compensation logic
+    compensatingActions: Type.Optional(Type.Array(Type.Object({
+      orderType: Type.String(),
+      action: Type.String(),
+      params: Type.Optional(Type.Record(Type.String(), Type.Any()))
+    })))
+  }),
+  
+  // What to do when parent fails
+  onParentFailure: Type.Object({
+    action: CompensationActionSchema,
+    
+    // Should we cancel active children?
+    cancelActiveChildren: Type.Boolean(),
+    
+    // Should we rollback completed children?
+    rollbackCompletedChildren: Type.Boolean(),
+    
+    // Custom compensation logic
+    compensatingActions: Type.Optional(Type.Array(Type.Object({
+      orderType: Type.String(),
+      action: Type.String(),
+      params: Type.Optional(Type.Record(Type.String(), Type.Any()))
+    })))
+  }),
+  
+  // Cleanup after successful completion
+  onSuccess: Type.Object({
+    // Clean up intermediate child orders?
+    cleanupIntermediateOrders: Type.Boolean(),
+    
+    // Archive completed children?
+    archiveChildren: Type.Boolean()
+  })
+})
+
+export type CompensationAction = Static<typeof CompensationActionSchema>
+export type CompensationStrategy = Static<typeof CompensationStrategySchema>
+
+// LSP Compensation Strategies - Rollback policies per order type
+export const LSP_COMPENSATION_STRATEGIES: Record<string, CompensationStrategy> = {
+  'OutboundOrder': {
+    onChildFailure: {
+      action: 'COMPENSATE',
+      rollbackParent: false,              // Keep parent, let it retry
+      rollbackSiblings: true,             // Cancel other picking/packing tasks
+      rollbackCompletedChildren: false,   // Don't undo completed picks
+      compensatingActions: [
+        {
+          orderType: 'InternalOrder',
+          action: 'REVERSE_ALLOCATION',   // Return allocated inventory
+          params: { reason: 'SIBLING_FAILURE' }
+        }
+      ]
+    },
+    onParentFailure: {
+      action: 'ROLLBACK_ALL',
+      cancelActiveChildren: true,          // Cancel all in-progress children
+      rollbackCompletedChildren: true      // Reverse completed operations
+    },
+    onSuccess: {
+      cleanupIntermediateOrders: false,    // Keep for audit
+      archiveChildren: true                // Move to archive collection
+    }
+  },
+  
+  'InboundOrder': {
+    onChildFailure: {
+      action: 'MARK_FAILED',
+      rollbackParent: false,
+      rollbackSiblings: false,             // Let other putaway tasks continue
+      rollbackCompletedChildren: false
+    },
+    onParentFailure: {
+      action: 'ROLLBACK_ALL',
+      cancelActiveChildren: true,
+      rollbackCompletedChildren: true      // Remove from inventory
+    },
+    onSuccess: {
+      cleanupIntermediateOrders: false,
+      archiveChildren: true
+    }
+  },
+  
+  'InternalOrder': {
+    onChildFailure: {
+      action: 'ROLLBACK_SIBLINGS',
+      rollbackParent: false,
+      rollbackSiblings: true,              // Cancel related warehouse tasks
+      rollbackCompletedChildren: false
+    },
+    onParentFailure: {
+      action: 'ROLLBACK_ALL',
+      cancelActiveChildren: true,
+      rollbackCompletedChildren: true      // Reverse inventory moves
+    },
+    onSuccess: {
+      cleanupIntermediateOrders: true,     // Clean up temporary tasks
+      archiveChildren: false
+    }
+  },
+  
+  'ShippingOrder': {
+    onChildFailure: {
+      action: 'MANUAL_INTERVENTION',       // Hub failures need manual handling
+      rollbackParent: false,
+      rollbackSiblings: false,
+      rollbackCompletedChildren: false
+    },
+    onParentFailure: {
+      action: 'COMPENSATE',
+      cancelActiveChildren: true,
+      rollbackCompletedChildren: false,    // Can't undo physical shipment
+      compensatingActions: [
+        {
+          orderType: 'ShippingOrder',
+          action: 'CREATE_RETURN_SHIPMENT',
+          params: { reason: 'PARENT_FAILURE' }
+        }
+      ]
+    },
+    onSuccess: {
+      cleanupIntermediateOrders: false,
+      archiveChildren: true
+    }
+  },
+  
+  'PassthroughOrder': {
+    onChildFailure: {
+      action: 'ROLLBACK_SIBLINGS',
+      rollbackParent: false,
+      rollbackSiblings: true,
+      rollbackCompletedChildren: false
+    },
+    onParentFailure: {
+      action: 'ROLLBACK_ALL',
+      cancelActiveChildren: true,
+      rollbackCompletedChildren: true
+    },
+    onSuccess: {
+      cleanupIntermediateOrders: true,
+      archiveChildren: true
+    }
+  }
+}
+
+// ========================================================================
+// PROCESS-STAGE TRANSITION MAPS
+// ========================================================================
+
+// Process-Stage Transition Map - Defines valid stages per process
+export const ProcessStageTransitionMapSchema = Type.Object({
+  process: Type.String(),
+  allowedStages: Type.Array(Type.String()),
+  stageFlow: Type.Array(Type.Object({
+    from: Type.String(),
+    to: Type.Array(Type.String())
+  }))
+})
+
+export type ProcessStageTransitionMap = Static<typeof ProcessStageTransitionMapSchema>
+
+// LSP Process-Stage Maps - Valid stage transitions per process
+export const LSP_PROCESS_STAGE_MAPS: Record<string, Record<string, ProcessStageTransitionMap>> = {
+  // OUTBOUND ORDER PROCESS-STAGE MAPS
+  'OutboundOrder': {
+    'FULFILLMENT': {
+      process: 'FULFILLMENT',
+      allowedStages: ['PROCESSING', 'QUALITY_CHECK', 'ALLOCATING', 'PICKING', 'PACKING', 'STAGING', 'LOADING'],
+      stageFlow: [
+        { from: 'PROCESSING', to: ['QUALITY_CHECK', 'ALLOCATING'] },
+        { from: 'QUALITY_CHECK', to: ['ALLOCATING', 'PROCESSING'] },
+        { from: 'ALLOCATING', to: ['PICKING'] },
+        { from: 'PICKING', to: ['PACKING', 'QUALITY_CHECK'] },
+        { from: 'PACKING', to: ['STAGING', 'QUALITY_CHECK'] },
+        { from: 'STAGING', to: ['LOADING'] },
+        { from: 'LOADING', to: [] }  // Terminal stage
+      ]
+    },
+    'TRANSFER': {
+      process: 'TRANSFER',
+      allowedStages: ['PROCESSING', 'ALLOCATING', 'PICKING', 'STAGING', 'LOADING'],
+      stageFlow: [
+        { from: 'PROCESSING', to: ['ALLOCATING'] },
+        { from: 'ALLOCATING', to: ['PICKING'] },
+        { from: 'PICKING', to: ['STAGING'] },
+        { from: 'STAGING', to: ['LOADING'] },
+        { from: 'LOADING', to: [] }
+      ]
+    },
+    'EXCEPTION': {
+      process: 'EXCEPTION',
+      allowedStages: ['PROCESSING', 'QUALITY_CHECK'],
+      stageFlow: [
+        { from: 'PROCESSING', to: ['QUALITY_CHECK'] },
+        { from: 'QUALITY_CHECK', to: [] }
+      ]
+    }
+  },
+  
+  // INBOUND ORDER PROCESS-STAGE MAPS
+  'InboundOrder': {
+    'RECEIVING': {
+      process: 'RECEIVING',
+      allowedStages: ['UNLOADING', 'INSPECTING', 'RECEIVING', 'PROCESSING'],
+      stageFlow: [
+        { from: 'UNLOADING', to: ['INSPECTING'] },
+        { from: 'INSPECTING', to: ['RECEIVING', 'PROCESSING'] },
+        { from: 'RECEIVING', to: ['PROCESSING'] },
+        { from: 'PROCESSING', to: [] }
+      ]
+    },
+    'PUTAWAY': {
+      process: 'PUTAWAY',
+      allowedStages: ['PROCESSING', 'ALLOCATING', 'STORING'],
+      stageFlow: [
+        { from: 'PROCESSING', to: ['ALLOCATING'] },
+        { from: 'ALLOCATING', to: ['STORING'] },
+        { from: 'STORING', to: [] }
+      ]
+    },
+    'INVENTORY_ADJUSTMENT': {
+      process: 'INVENTORY_ADJUSTMENT',
+      allowedStages: ['PROCESSING', 'INSPECTING', 'RECEIVING'],
+      stageFlow: [
+        { from: 'PROCESSING', to: ['INSPECTING'] },
+        { from: 'INSPECTING', to: ['RECEIVING'] },
+        { from: 'RECEIVING', to: [] }
+      ]
+    },
+    'RETURN_PROCESSING': {
+      process: 'RETURN_PROCESSING',
+      allowedStages: ['UNLOADING', 'INSPECTING', 'PROCESSING', 'ALLOCATING', 'STORING'],
+      stageFlow: [
+        { from: 'UNLOADING', to: ['INSPECTING'] },
+        { from: 'INSPECTING', to: ['PROCESSING'] },
+        { from: 'PROCESSING', to: ['ALLOCATING', 'STORING'] },
+        { from: 'ALLOCATING', to: ['STORING'] },
+        { from: 'STORING', to: [] }
+      ]
+    },
+    'EXCEPTION': {
+      process: 'EXCEPTION',
+      allowedStages: ['PROCESSING', 'INSPECTING'],
+      stageFlow: [
+        { from: 'PROCESSING', to: ['INSPECTING'] },
+        { from: 'INSPECTING', to: [] }
+      ]
+    }
+  },
+  
+  // INTERNAL ORDER PROCESS-STAGE MAPS
+  'InternalOrder': {
+    'CYCLE_COUNT': {
+      process: 'CYCLE_COUNT',
+      allowedStages: ['PROCESSING', 'COUNTING', 'ADJUSTING'],
+      stageFlow: [
+        { from: 'PROCESSING', to: ['COUNTING'] },
+        { from: 'COUNTING', to: ['ADJUSTING'] },
+        { from: 'ADJUSTING', to: [] }
+      ]
+    },
+    'REPLENISHMENT': {
+      process: 'REPLENISHMENT',
+      allowedStages: ['PROCESSING', 'MOVING'],
+      stageFlow: [
+        { from: 'PROCESSING', to: ['MOVING'] },
+        { from: 'MOVING', to: [] }
+      ]
+    },
+    'RELOCATION': {
+      process: 'RELOCATION',
+      allowedStages: ['PROCESSING', 'MOVING'],
+      stageFlow: [
+        { from: 'PROCESSING', to: ['MOVING'] },
+        { from: 'MOVING', to: [] }
+      ]
+    },
+    'CONSOLIDATION': {
+      process: 'CONSOLIDATION',
+      allowedStages: ['PROCESSING', 'CONSOLIDATING'],
+      stageFlow: [
+        { from: 'PROCESSING', to: ['CONSOLIDATING'] },
+        { from: 'CONSOLIDATING', to: [] }
+      ]
+    },
+    'KITTING': {
+      process: 'KITTING',
+      allowedStages: ['PROCESSING', 'KITTING'],
+      stageFlow: [
+        { from: 'PROCESSING', to: ['KITTING'] },
+        { from: 'KITTING', to: [] }
+      ]
+    },
+    'ASSEMBLY': {
+      process: 'ASSEMBLY',
+      allowedStages: ['PROCESSING', 'ASSEMBLING'],
+      stageFlow: [
+        { from: 'PROCESSING', to: ['ASSEMBLING'] },
+        { from: 'ASSEMBLING', to: [] }
+      ]
+    },
+    'EXCEPTION': {
+      process: 'EXCEPTION',
+      allowedStages: ['PROCESSING', 'EXCEPTION_REVIEW'],
+      stageFlow: [
+        { from: 'PROCESSING', to: ['EXCEPTION_REVIEW'] },
+        { from: 'EXCEPTION_REVIEW', to: [] }
+      ]
+    }
+  },
+  
+  // SHIPPING ORDER PROCESS-STAGE MAPS
+  'ShippingOrder': {
+    'COLLECTION': {
+      process: 'COLLECTION',
+      allowedStages: ['DISPATCHING', 'COLLECTING', 'CONFIRMING'],
+      stageFlow: [
+        { from: 'DISPATCHING', to: ['COLLECTING'] },
+        { from: 'COLLECTING', to: ['CONFIRMING'] },
+        { from: 'CONFIRMING', to: [] }
+      ]
+    },
+    'LINEHAUL': {
+      process: 'LINEHAUL',
+      allowedStages: ['DISPATCHING', 'TRANSPORTING', 'TRANSFERRING'],
+      stageFlow: [
+        { from: 'DISPATCHING', to: ['TRANSPORTING'] },
+        { from: 'TRANSPORTING', to: ['TRANSFERRING'] },
+        { from: 'TRANSFERRING', to: [] }
+      ]
+    },
+    'DELIVERY': {
+      process: 'DELIVERY',
+      allowedStages: ['DISPATCHING', 'TRANSPORTING', 'DELIVERING', 'CONFIRMING'],
+      stageFlow: [
+        { from: 'DISPATCHING', to: ['TRANSPORTING'] },
+        { from: 'TRANSPORTING', to: ['DELIVERING'] },
+        { from: 'DELIVERING', to: ['CONFIRMING'] },
+        { from: 'CONFIRMING', to: [] }
+      ]
+    },
+    'TRANSFER': {
+      process: 'TRANSFER',
+      allowedStages: ['DISPATCHING', 'TRANSPORTING', 'TRANSFERRING'],
+      stageFlow: [
+        { from: 'DISPATCHING', to: ['TRANSPORTING'] },
+        { from: 'TRANSPORTING', to: ['TRANSFERRING'] },
+        { from: 'TRANSFERRING', to: [] }
+      ]
+    },
+    'CONSOLIDATION': {
+      process: 'CONSOLIDATION',
+      allowedStages: ['SORTING', 'CONSOLIDATING'],
+      stageFlow: [
+        { from: 'SORTING', to: ['CONSOLIDATING'] },
+        { from: 'CONSOLIDATING', to: [] }
+      ]
+    },
+    'CROSS_DOCK': {
+      process: 'CROSS_DOCK',
+      allowedStages: ['SORTING', 'TRANSFERRING'],
+      stageFlow: [
+        { from: 'SORTING', to: ['TRANSFERRING'] },
+        { from: 'TRANSFERRING', to: [] }
+      ]
+    },
+    'CUSTOMS': {
+      process: 'CUSTOMS',
+      allowedStages: ['CLEARING'],
+      stageFlow: [
+        { from: 'CLEARING', to: [] }
+      ]
+    },
+    'RETURN': {
+      process: 'RETURN',
+      allowedStages: ['COLLECTING', 'TRANSPORTING', 'RETURNING'],
+      stageFlow: [
+        { from: 'COLLECTING', to: ['TRANSPORTING'] },
+        { from: 'TRANSPORTING', to: ['RETURNING'] },
+        { from: 'RETURNING', to: [] }
+      ]
+    }
+  },
+  
+  // PASSTHROUGH ORDER PROCESS-STAGE MAPS
+  'PassthroughOrder': {
+    'CROSS_DOCK': {
+      process: 'CROSS_DOCK',
+      allowedStages: ['ARRIVAL', 'RECEIVING', 'SORTING', 'STAGING', 'LOADING', 'DEPARTURE'],
+      stageFlow: [
+        { from: 'ARRIVAL', to: ['RECEIVING'] },
+        { from: 'RECEIVING', to: ['SORTING'] },
+        { from: 'SORTING', to: ['STAGING'] },
+        { from: 'STAGING', to: ['LOADING'] },
+        { from: 'LOADING', to: ['DEPARTURE'] },
+        { from: 'DEPARTURE', to: [] }
+      ]
+    },
+    'CONSOLIDATION': {
+      process: 'CONSOLIDATION',
+      allowedStages: ['ARRIVAL', 'RECEIVING', 'INSPECTION', 'SORTING', 'CONSOLIDATING', 'STAGING', 'LOADING', 'DEPARTURE'],
+      stageFlow: [
+        { from: 'ARRIVAL', to: ['RECEIVING'] },
+        { from: 'RECEIVING', to: ['INSPECTION'] },
+        { from: 'INSPECTION', to: ['SORTING'] },
+        { from: 'SORTING', to: ['CONSOLIDATING'] },
+        { from: 'CONSOLIDATING', to: ['STAGING'] },
+        { from: 'STAGING', to: ['LOADING'] },
+        { from: 'LOADING', to: ['DEPARTURE'] },
+        { from: 'DEPARTURE', to: [] }
+      ]
+    },
+    'DECONSOLIDATION': {
+      process: 'DECONSOLIDATION',
+      allowedStages: ['ARRIVAL', 'RECEIVING', 'DECONSOLIDATING', 'SORTING', 'STAGING', 'LOADING', 'DEPARTURE'],
+      stageFlow: [
+        { from: 'ARRIVAL', to: ['RECEIVING'] },
+        { from: 'RECEIVING', to: ['DECONSOLIDATING'] },
+        { from: 'DECONSOLIDATING', to: ['SORTING'] },
+        { from: 'SORTING', to: ['STAGING'] },
+        { from: 'STAGING', to: ['LOADING'] },
+        { from: 'LOADING', to: ['DEPARTURE'] },
+        { from: 'DEPARTURE', to: [] }
+      ]
+    },
+    'TRANSFER': {
+      process: 'TRANSFER',
+      allowedStages: ['ARRIVAL', 'RECEIVING', 'PROCESSING', 'STAGING', 'LOADING', 'DEPARTURE'],
+      stageFlow: [
+        { from: 'ARRIVAL', to: ['RECEIVING'] },
+        { from: 'RECEIVING', to: ['PROCESSING'] },
+        { from: 'PROCESSING', to: ['STAGING'] },
+        { from: 'STAGING', to: ['LOADING'] },
+        { from: 'LOADING', to: ['DEPARTURE'] },
+        { from: 'DEPARTURE', to: [] }
+      ]
+    },
+    'EXCEPTION': {
+      process: 'EXCEPTION',
+      allowedStages: ['PROCESSING', 'EXCEPTION_REVIEW', 'QUALITY_CHECK'],
+      stageFlow: [
+        { from: 'PROCESSING', to: ['EXCEPTION_REVIEW'] },
+        { from: 'EXCEPTION_REVIEW', to: ['QUALITY_CHECK'] },
+        { from: 'QUALITY_CHECK', to: [] }
+      ]
+    }
+  }
+}
+
+// Order Assignee Schema
+export const OrderAssigneeSchema = Type.Object({
+  type: UserTypeSchema,
+  id: Type.String(),
+  name: Type.String(),
+  process: Type.String(),
+  assigned: ActionRecordSchema
+})
+
+// Exception handling
+export const OrderExceptionSchema = Type.Object({
+  code: Type.String(),
+  type: Type.Union([
+    Type.Literal('DAMAGE'),
+    Type.Literal('MISSING_PACKAGE'),
+    Type.Literal('WRONG_DESTINATION'),
+    Type.Literal('SCANNING_ERROR'),
+    Type.Literal('ROUTING_ERROR'),
+    Type.Literal('DELAY'),
+    Type.Literal('CUSTOMS_HOLD'),
+    Type.Literal('SECURITY_HOLD')
+  ]),
+  severity: Type.Union([
+    Type.Literal('LOW'),
+    Type.Literal('MEDIUM'),
+    Type.Literal('HIGH'),
+    Type.Literal('CRITICAL')
+  ]),
+  description: Type.String({ maxLength: 1000 }),
+  reported: ActionRecordSchema,
+  resolved: ActionRecordSchema,
+  resolution: Type.Optional(Type.String({ maxLength: 1000 }))
+})
+
+// Order Consolidation & Deconsolidation information
+export const ConsolidationTypeSchema = Type.Union([
+  Type.Literal('ROUTE_BASED'),
+  Type.Literal('DESTINATION_BASED'),
+  Type.Literal('SERVICE_BASED'),
+  Type.Literal('TIME_BASED')
+])
+export const OrderConsolidationSchema = Type.Object({
+  batchId: Type.String(),
+  type: ConsolidationTypeSchema,
+  with: Type.Array(Type.String()),
+  info: Type.Optional(Type.Object({
+    containerId: Type.String(),
+    containerType: Type.String(),
+    loadSequence: Type.Number(),
+    totalPackages: Type.Number()
+  }))
+})
+export const OrderDeconsolidationSchema = Type.Object({
+  batchId: Type.String(),
+  type: ConsolidationTypeSchema,
+  with: Type.Array(Type.String()),
+  info: Type.Optional(Type.Object({
+    containerId: Type.String(),
+    containerType: Type.String(),
+    loadSequence: Type.Number(),
+    totalPackages: Type.Number()
+  }))
+})
+
+// Base Order Status Values (string constants for reuse)
+export const BASE_ORDER_STATUSES = [
+  'ACK',
+  'NACK',
+  'PENDING',
+  'ON_HOLD',
+  'ASSIGNED',
+  'APPROVED',
+  'SCHEDULED',
+  'SUSPENDED',
+  'CANCELLED',
+  'IN_PROGRESS',
+  'EXCEPTION',
+  'COMPLETED',
+  'FAILED'
+] as const
+
+// Base Order Status Schema
+export const BaseOrderStatusSchema = Type.Union([
+  Type.Literal('ACK'),
+  Type.Literal('NACK'),
+  Type.Literal('PENDING'),
+  Type.Literal('ON_HOLD'),
+  Type.Literal('ASSIGNED'),
+  Type.Literal('APPROVED'),
+  Type.Literal('SCHEDULED'),
+  Type.Literal('SUSPENDED'),
+  Type.Literal('CANCELLED'),
+  Type.Literal('IN_PROGRESS'),
+  Type.Literal('EXCEPTION'),
+  Type.Literal('COMPLETED'),
+  Type.Literal('FAILED')
+])
+export const BaseOrderFlowPrioritySchema = Type.Union([
+  Type.Literal('LOW'),
+  Type.Literal('NORMAL'),
+  Type.Literal('HIGH'),
+  Type.Literal('URGENT'),
+  Type.Literal('CRITICAL')
+])
+
+// Order Tracking Schema - Hierarchical tracking strategy
+export const OrderTrackingSchema = Type.Object({
+  // Customer-facing master tracking number (shared across hierarchy)
+  masterTrackingNumber: Type.String(),
+  
+  // Unique tracking number for this specific order
+  trackingNumber: Type.String(),
+  
+  // External carrier tracking number (for shipping orders)
+  carrierTrackingNumber: Type.Optional(Type.String()),
+  
+  // Alternative tracking references (for integration with external systems)
+  alternativeTrackingNumbers: Type.Optional(Type.Array(Type.Object({
+    provider: Type.String(),
+    trackingNumber: Type.String()
+  })))
+})
+
+// Order Routing schemas
+export const OrderRoutingModeSchema = Type.Union([
+  Type.Literal('PIPELINE'),
+  Type.Literal('MANUAL')
+])
+export const OrderRoutingStrategySchema = Type.Union([
+  Type.Literal('CHEAPEST'),
+  Type.Literal('FASTEST'),
+  Type.Literal('NEAREST'),
+  Type.Literal('BALANCED')
+])
+export const OrderRoutingConfigSchema = Type.Object({
+  mode: OrderRoutingModeSchema,
+  handler: Type.Union([GenericServiceContextSchema, PipelineContextSchema]),
+  strategy: Type.Optional(OrderRoutingStrategySchema)
+})
+export const OrderNoteSchema = Type.Object({
+  content: Type.String({ maxLength: 1000 }),
+  created: ActionRecordSchema
+})
+
+// Order client schemas
+export const OrderClientRelationshipSchema = Type.Union([
+  Type.Literal('C2B'),
+  Type.Literal('B2B'),
+  Type.Literal('B2C')
+])
+export const OrderProfileClientSchema = Type.Object({
+  relationship: OrderClientRelationshipSchema,
+  mode: Type.Literal('PROFILE'),
+  dprofile: DProfileReferenceSchema
+})
+export const OrderInlineClientSchema = Type.Object({
+  relationship: OrderClientRelationshipSchema,
+  mode: Type.Literal('INLINE'),
+  id: Type.String(),
+  // Contact and address information
+  contacts: Type.Optional(ContactsSchema),
+  address: Type.Optional(AddressSchema)
+})
+export const OrderClientSchema = Type.Union([
+  OrderInlineClientSchema,
+  OrderProfileClientSchema
+], { discriminator: { propertyName: 'mode' } })
+
+// Base Order Schema
+export const BaseOrderSchema = Type.Object({
+  cid: Type.String({ description: 'Connector that created this order' }),
+  reference: Type.String(),
+  tracking: OrderTrackingSchema, // Hierarchical tracking information
+  intentToken: Type.String(),
+  // Context creator of this order
+  context: ContextSchema,
+  
+  // Order Hierarchy (Parent-Child Relationships)
+  hierarchy: OrderHierarchySchema,
+  
+  // Routing
+  routing: OrderRoutingConfigSchema,
+  
+  /**
+   * Pipeline Execution State
+   * 
+   * Only present on root orders. Tracks progress through pipeline stages.
+   * Pipeline template version is locked at order creation time to prevent
+   * mid-flight changes from affecting in-progress orders.
+   */
+  pipelineExecution: Type.Optional(PipelineExecutionSchema),
+  
+  // Operation details (fees, payment, rating)
+  operation: OrderOperationSchema,
+  
+  // Assigned agents/workers
+  assignees: Type.Optional(Type.Array(OrderAssigneeSchema)),
+
+  // Order characteristics
+  priority: OrderPrioritySchema,
+  requirements: Type.Optional(Type.Array(OrderRequirementSchema)),
+  schedule: Type.Optional(DateTimeScheduleSchema),
+
+  // Exception tracking
+  exceptions: Type.Optional(Type.Array(OrderExceptionSchema)),
+
+  /**
+   * Client identifier for customer-facing services
+   * Present when customer directly books CSP/LSP service (delivery, ride, warehouse, etc.)
+   * Absent for internal operations orders
+   */
+  client: Type.Optional(OrderClientSchema),
+  sla: Type.Optional(Type.Object({
+    deadline: DateTimeZoneSchema
+  })),
+
+  // Additional metadata
+  notes: Type.Optional(Type.Array(OrderNoteSchema)),
+  tags: Type.Optional(Type.Array(Type.String())),
+  metadata: Type.Optional(Type.Record(Type.String(), Type.Any())),
+
+  // Lock order from modifications
+  locked: Type.Optional(Type.Boolean()),
+
+  created: ActionRecordSchema,
+  updated: Type.Optional(ActionRecordSchema)
+})
+
+// Ride Order Schemas
+export const RideOrderTypeSchema = Type.Union([
+  Type.Literal('SHORT-MILE'),
+  Type.Literal('LONG-MILE')
+])
+
+export const RideBaseOrderSchema = Type.Intersect([
+  BaseOrderSchema,
+  Type.Object({
+    type: RideOrderTypeSchema
+    // passengers: Type.Array(OrderPassengerSchema), // Uncomment when available
+    // luggages: Type.Array(OrderLuggageSchema), // Uncomment when available
+  })
+])
+
+export const LSPBaseOrderSchema = Type.Intersect([
+  BaseOrderSchema,
+  Type.Object({
+    type: LSPOrderTypeSchema,
+    items: Type.Array(OrderItemSchema),
+    packages: Type.Object({
+      totalWeight: Type.Optional(WeightSchema),
+      totalVolume: Type.Optional(VolumeSchema),
+      list: Type.Array(OrderPackageSchema)
+    }),
+    consolidations: Type.Optional(Type.Array(OrderConsolidationSchema)),
+    deconsolidations: Type.Optional(Type.Array(OrderDeconsolidationSchema))
+  })
+])
+
+// Generate TypeScript types from schemas
+export type OrderPriority = Static<typeof OrderPrioritySchema>
+export type OrderItemStatus = Static<typeof OrderItemStatusSchema>
+export type OrderItem = Static<typeof OrderItemSchema>
+export type OrderPackageType = Static<typeof OrderPackageTypeSchema>
+export type OrderPackageCategory = Static<typeof OrderPackageCategorySchema>
+export type OrderPackageItem = Static<typeof OrderPackageItemSchema>
+export type OrderPackage = Static<typeof OrderPackageSchema>
+export type OrderOperation = Static<typeof OrderOperationSchema>
+export type OrderIntent = Static<typeof OrderIntentSchema>
+export type OrderTracking = Static<typeof OrderTrackingSchema>
+export type OrderRoutingMode = Static<typeof OrderRoutingModeSchema>
+export type OrderRoutingStrategy = Static<typeof OrderRoutingStrategySchema>
+export type OrderRoutingConfig = Static<typeof OrderRoutingConfigSchema>
+export type GenericOrderProcessor = Static<typeof GenericOrderProcessorSchema>
+export type OrderNote = Static<typeof OrderNoteSchema>
+export type OrderClientRelationship = Static<typeof OrderClientRelationshipSchema>
+export type OrderProfileClient = Static<typeof OrderProfileClientSchema>
+export type OrderInlineClient = Static<typeof OrderInlineClientSchema>
+export type OrderClient = Static<typeof OrderClientSchema>
+export type OrderHierarchy = Static<typeof OrderHierarchySchema>
+export type OrderLifecyclePolicy = Static<typeof OrderLifecyclePolicySchema>
+export type OrderAssignee = Static<typeof OrderAssigneeSchema>
+export type OrderException = Static<typeof OrderExceptionSchema>
+export type BaseOrderStatus = Static<typeof BaseOrderStatusSchema>
+export type BaseOrderFlowPriority = Static<typeof BaseOrderFlowPrioritySchema>
+export type BaseOrder = Static<typeof BaseOrderSchema>
+
+// Composition metadata types
+export type CompositionReason = Static<typeof CompositionReasonSchema>
+export type RelationshipType = Static<typeof RelationshipTypeSchema>
+export type ParentStateAtCreation = Static<typeof ParentStateAtCreationSchema>
+export type ChildOrderRelationship = Static<typeof ChildOrderRelationshipSchema>
+export type CompositionMetadata = Static<typeof CompositionMetadataSchema>
+
+export type RideOrderType = Static<typeof RideOrderTypeSchema>
+export type RideBaseOrder = Static<typeof RideBaseOrderSchema>
+export type LSPBaseOrder = Static<typeof LSPBaseOrderSchema>
+
+
+// Utility schemas for order operations
+export const OrderSearchSchema = Type.Object({
+  status: Type.Optional(Type.Array(BaseOrderStatusSchema)),
+  priority: Type.Optional(OrderPrioritySchema),
+  dateRange: Type.Optional(DateTimeRangeSchema),
+  processor: Type.Optional(Type.String()),
+  assigneeId: Type.Optional(Type.String()),
+  tags: Type.Optional(Type.Array(Type.String())),
+  limit: Type.Optional(Type.Number({ minimum: 1, maximum: 100 })),
+  offset: Type.Optional(Type.Number({ minimum: 0 }))
+})
+
+export const OrderStatsSchema = Type.Object({
+  total: Type.Number(),
+  byStatus: Type.Record(BaseOrderStatusSchema, Type.Number()),
+  byPriority: Type.Record(OrderPrioritySchema, Type.Number()),
+  byType: Type.Object({
+    shipping: Type.Number(),
+    ride: Type.Number()
+  }),
+  avgProcessingTime: Type.Number(), // minutes
+  onTimeDelivery: Type.Number({ minimum: 0, maximum: 100 }) // percentage
+})
+
+export type OrderSearch = Static<typeof OrderSearchSchema>
+export type OrderStats = Static<typeof OrderStatsSchema>