@de./types 1.0.0

package/src/lsp/operations.ts

@@ -0,0 +1,304 @@
+import { Type, Static } from '@sinclair/typebox'
+import {
+	APIErrorSchema,
+	APIHeadersSchema,
+	APIResponseBaseSchema,
+	APIResponseDataSchemaFactory
+} from '../api'
+import { OrderPackageSchema } from '../order'
+import { ShippingOrderSchema } from './order/shipping'
+
+// ─── Shared Inline Types ──────────────────────────────────────────────────────
+
+const ScoreTypeSchema = Type.Union([
+	Type.Literal('rider'),
+	Type.Literal('sender'),
+	Type.Literal('origin')
+])
+
+const OriginBatchTierSchema = Type.Union([
+	Type.Literal('free'),
+	Type.Literal('widened'),
+	Type.Literal('single_only'),
+	Type.Literal('excluded')
+])
+
+const ScoreRecordSchema = Type.Object({
+	id:               Type.String(),
+	type:             ScoreTypeSchema,
+	score:            Type.Number({ minimum: 0, maximum: 100 }),
+	completions:      Type.Number({ minimum: 0 }),
+	onTimeRate:       Type.Number({ minimum: 0, maximum: 1 }),
+	offerCount:       Type.Number({ minimum: 0 }),
+	acceptanceRate:   Type.Number({ minimum: 0, maximum: 1 }),
+	cancellationRate: Type.Number({ minimum: 0, maximum: 1 }),
+	avgRating:        Type.Number({ minimum: 0, maximum: 5 }),
+	ratingCount:      Type.Number({ minimum: 0 }),
+	trusted:          Type.Boolean(),
+	lastUpdated:      Type.Number()
+})
+
+export type ScoreRecord     = Static<typeof ScoreRecordSchema>
+export type OriginBatchTier = Static<typeof OriginBatchTierSchema>
+
+// ─── Score RVS ────────────────────────────────────────────────────────────────
+
+export const LSPScoreOriginRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ senderId: Type.String() }),
+	response: {
+		200:   APIResponseDataSchemaFactory({ senderId: Type.String(), score: ScoreRecordSchema, batchTier: OriginBatchTierSchema }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPScoreAgentRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ agentId: Type.String() }),
+	response: {
+		200:   APIResponseDataSchemaFactory({ agentId: Type.String(), score: ScoreRecordSchema }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export type LSPScoreOriginValidation = { params: Static<typeof LSPScoreOriginRVS.params>, response: Static<(typeof LSPScoreOriginRVS.response)[200]> }
+export type LSPScoreAgentValidation  = { params: Static<typeof LSPScoreAgentRVS.params>, response: Static<(typeof LSPScoreAgentRVS.response)[200]> }
+
+// ─── Reports RVS ─────────────────────────────────────────────────────────────
+
+export const LSPReportsInventoryRVS = {
+	headers:     APIHeadersSchema,
+	querystring: Type.Object({
+		locationId:    Type.Optional(Type.String()),
+		locationTypes: Type.Optional(Type.Union([Type.String(), Type.Array(Type.String())])),
+		threshold:     Type.Optional(Type.Number()),
+		fromDate:      Type.Optional(Type.Number()),
+		toDate:        Type.Optional(Type.Number())
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({
+			report: Type.Object({
+				summary: Type.Object({
+					totalUnits:     Type.Number(),
+					uniqueProducts: Type.Number(),
+					totalValue:     Type.Number(),
+					availableUnits: Type.Number(),
+					reservedUnits:  Type.Number()
+				}),
+				alerts: Type.Object({
+					lowStock:    Type.Number(),
+					outOfStock:  Type.Number(),
+					healthScore: Type.Number()
+				}),
+				byLocation: Type.Array(Type.Object({
+					locationId:     Type.String(),
+					locationName:   Type.String(),
+					totalItems:     Type.Number(),
+					totalValue:     Type.Number(),
+					uniqueProducts: Type.Number()
+				}))
+			}),
+			generatedAt: Type.Number()
+		}),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPReportsOperationsRVS = {
+	headers:     APIHeadersSchema,
+	querystring: Type.Object({
+		locationId: Type.Optional(Type.String()),
+		fromDate:   Type.Optional(Type.Number()),
+		toDate:     Type.Optional(Type.Number())
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({
+			report: Type.Object({
+				period: Type.Object({ from: Type.Number(), to: Type.Number() }),
+				tasks: Type.Object({
+					total:    Type.Number(),
+					byStatus: Type.Object({ pending: Type.Number(), inProgress: Type.Number(), completed: Type.Number(), failed: Type.Number() }),
+					avgCompletionTime: Type.Number(),
+					completionRate:    Type.Number()
+				}),
+				inbound: Type.Object({
+					total:    Type.Number(),
+					byStatus: Type.Object({ received: Type.Number(), processing: Type.Number(), stored: Type.Number(), cancelled: Type.Number() }),
+					successRate: Type.Number()
+				}),
+				outbound: Type.Object({
+					total:    Type.Number(),
+					byStatus: Type.Object({ pending: Type.Number(), picked: Type.Number(), packed: Type.Number(), shipped: Type.Number(), delivered: Type.Number() }),
+					fulfillmentRate: Type.Number()
+				}),
+				efficiency: Type.Object({
+					overallScore: Type.Number(),
+					avgTaskTime:  Type.Number(),
+					throughput:   Type.Object({ tasksPerDay: Type.Number(), inboundPerDay: Type.Number(), shipmentsPerDay: Type.Number() })
+				})
+			}),
+			generatedAt: Type.Number()
+		}),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPReportsFacilityRVS = {
+	headers:     APIHeadersSchema,
+	querystring: Type.Object({
+		locationId:   Type.Optional(Type.String()),
+		locationType: Type.Optional(Type.Union([Type.Literal('WAREHOUSE'), Type.Literal('HUB')]))
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({
+			report: Type.Object({
+				summary: Type.Object({
+					totalFacilities: Type.Number(),
+					warehouses:      Type.Number(),
+					hubs:            Type.Number(),
+					totalCapacity:   Type.Number(),
+					totalUsed:       Type.Number(),
+					totalAvailable:  Type.Number(),
+					avgUtilization:  Type.Number()
+				}),
+				facilities: Type.Array(Type.Object({
+					id:        Type.String(),
+					name:      Type.String(),
+					type:      Type.String(),
+					capacity:  Type.Object({ total: Type.Number(), used: Type.Number(), available: Type.Number(), utilizationRate: Type.Number() }),
+					inventory: Type.Object({ uniqueProducts: Type.Number(), totalUnits: Type.Number(), value: Type.Number() }),
+					locations: Type.Object({ total: Type.Number(), occupied: Type.Number(), available: Type.Number() })
+				}))
+			}),
+			generatedAt: Type.Number()
+		}),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPReportsTasksRVS = {
+	headers:     APIHeadersSchema,
+	querystring: Type.Object({
+		locationId: Type.Optional(Type.String()),
+		taskType:   Type.Optional(Type.String()),
+		fromDate:   Type.Optional(Type.Number()),
+		toDate:     Type.Optional(Type.Number())
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({
+			report: Type.Object({
+				period:  Type.Object({ from: Type.Number(), to: Type.Number() }),
+				summary: Type.Object({ total: Type.Number(), completed: Type.Number(), pending: Type.Number(), inProgress: Type.Number(), failed: Type.Number() }),
+				byType: Type.Array(Type.Object({
+					type: Type.String(), total: Type.Number(), completed: Type.Number(), completionRate: Type.Number(), avgCompletionTime: Type.Number()
+				})),
+				byAssignee: Type.Array(Type.Object({
+					uid: Type.String(), name: Type.String(), completed: Type.Number(), failed: Type.Number(), successRate: Type.Number(), avgCompletionTime: Type.Number()
+				}))
+			}),
+			generatedAt: Type.Number()
+		}),
+		'4XX': APIErrorSchema
+	}
+}
+
+export type LSPReportsInventoryValidation  = { querystring: Static<typeof LSPReportsInventoryRVS.querystring>, response: Static<(typeof LSPReportsInventoryRVS.response)[200]> }
+export type LSPReportsOperationsValidation = { querystring: Static<typeof LSPReportsOperationsRVS.querystring>, response: Static<(typeof LSPReportsOperationsRVS.response)[200]> }
+export type LSPReportsFacilityValidation   = { querystring: Static<typeof LSPReportsFacilityRVS.querystring>, response: Static<(typeof LSPReportsFacilityRVS.response)[200]> }
+export type LSPReportsTasksValidation      = { querystring: Static<typeof LSPReportsTasksRVS.querystring>, response: Static<(typeof LSPReportsTasksRVS.response)[200]> }
+
+// ─── Shipments RVS ────────────────────────────────────────────────────────────
+
+const ShipmentStatusSchema = Type.Union([
+	Type.Literal('PENDING'),
+	Type.Literal('READY_FOR_PICKUP'),
+	Type.Literal('PICKED_UP'),
+	Type.Literal('IN_TRANSIT'),
+	Type.Literal('OUT_FOR_DELIVERY'),
+	Type.Literal('DELIVERED'),
+	Type.Literal('EXCEPTION'),
+	Type.Literal('RETURNED')
+])
+
+export const LSPShipmentCreateRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ reference: Type.String() }),
+	body:     Type.Object({
+		packages:            Type.Array(OrderPackageSchema),
+		carrierId:           Type.Optional(Type.String()),
+		estimatedPickupDate: Type.Optional(Type.Number()),
+		notes:               Type.Optional(Type.String())
+	}),
+	response: {
+		201:   APIResponseDataSchemaFactory({ order: ShippingOrderSchema, packageCount: Type.Number() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPShipmentUpdateRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ reference: Type.String() }),
+	body:     Type.Object({
+		carrier:                          Type.Optional(Type.Any()),
+		'shipping.estimatedPickup':       Type.Optional(Type.Number()),
+		'shipping.estimatedDelivery':     Type.Optional(Type.Number()),
+		'shipping.notes':                 Type.Optional(Type.String())
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({ message: Type.String(), shipment: ShippingOrderSchema }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPShipmentRetrieveRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ reference: Type.String() }),
+	response: {
+		200:   APIResponseDataSchemaFactory({ shipment: ShippingOrderSchema }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPShipmentFetchRVS = {
+	headers:     APIHeadersSchema,
+	querystring: Type.Object({
+		serviceId: Type.Optional(Type.String()),
+		status:    Type.Optional(Type.String()),
+		carrierId: Type.Optional(Type.String()),
+		fromDate:  Type.Optional(Type.Number()),
+		toDate:    Type.Optional(Type.Number()),
+		limit:     Type.Optional(Type.Number()),
+		offset:    Type.Optional(Type.Number())
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({ shipments: Type.Array(ShippingOrderSchema), total: Type.Number() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPShipmentUpdateStatusRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ reference: Type.String() }),
+	body:     Type.Object({ status: ShipmentStatusSchema, notes: Type.Optional(Type.String()) }),
+	response: {
+		200:   APIResponseDataSchemaFactory({ shipment: ShippingOrderSchema }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPShipmentAddPackageRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ reference: Type.String() }),
+	body:     OrderPackageSchema,
+	response: {
+		200:   APIResponseDataSchemaFactory({ shipment: ShippingOrderSchema, package: OrderPackageSchema }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export type LSPShipmentCreateValidation       = { params: Static<typeof LSPShipmentCreateRVS.params>, body: Static<typeof LSPShipmentCreateRVS.body>, response: Static<(typeof LSPShipmentCreateRVS.response)[201]> }
+export type LSPShipmentUpdateValidation       = { params: Static<typeof LSPShipmentUpdateRVS.params>, body: Static<typeof LSPShipmentUpdateRVS.body>, response: Static<(typeof LSPShipmentUpdateRVS.response)[200]> }
+export type LSPShipmentRetrieveValidation     = { params: Static<typeof LSPShipmentRetrieveRVS.params>, response: Static<(typeof LSPShipmentRetrieveRVS.response)[200]> }
+export type LSPShipmentFetchValidation        = { querystring: Static<typeof LSPShipmentFetchRVS.querystring>, response: Static<(typeof LSPShipmentFetchRVS.response)[200]> }
+export type LSPShipmentUpdateStatusValidation = { params: Static<typeof LSPShipmentUpdateStatusRVS.params>, body: Static<typeof LSPShipmentUpdateStatusRVS.body>, response: Static<(typeof LSPShipmentUpdateStatusRVS.response)[200]> }
+export type LSPShipmentAddPackageValidation   = { params: Static<typeof LSPShipmentAddPackageRVS.params>, body: Static<typeof LSPShipmentAddPackageRVS.body>, response: Static<(typeof LSPShipmentAddPackageRVS.response)[200]> }

package/src/lsp/order/delivery.ts

@@ -0,0 +1,212 @@
+import { Type, Static } from '@sinclair/typebox'
+import { ActionRecordSchema, DateTimeZoneSchema } from '../../time'
+import { WeightSchema, VolumeSchema } from '../../measure'
+import { RTLocationSchema, AddressSchema, CoordinatesSchema, LocationInputSchema } from '../../geo'
+import {
+  BaseOrderStatusSchema,
+  BaseOrderFlowPrioritySchema,
+  OrderAssigneeSchema,
+  OrderPrioritySchema,
+  LSPBaseOrderSchema
+} from '../../order'
+import { DeliveryOrderProcessSchema } from './flow/processes'
+import { DeliveryOrderStageSchema } from './flow/stages'
+import { OfferIdSchema, AgentIdSchema, CPointIdSchema } from '../consolidation'
+import { ContextSchema } from '../../context'
+
+// ── Delivery Order Status ─────────────────────────────────────
+// Extends base statuses with Rally last-mile lifecycle values.
+
+export const DeliveryOrderStatusSchema = Type.Union([
+  ...BaseOrderStatusSchema.anyOf,
+  Type.Literal('DISPATCHED'),         // Rider assigned; offer accepted
+  Type.Literal('COLLECTED'),          // Item picked up from origin party
+  Type.Literal('IN_TRANSIT'),         // En route to recipient
+  Type.Literal('DELIVERED'),          // Successfully delivered
+  Type.Literal('DELIVERY_FAILED'),    // Delivery attempt failed
+  Type.Literal('RETURNED_TO_SENDER'), // Package returned to origin
+])
+
+// ── Delivery Order Flow ───────────────────────────────────────
+
+export const DeliveryOrderFlowSchema = Type.Object({
+  process: DeliveryOrderProcessSchema,
+  stage: DeliveryOrderStageSchema,
+  status: DeliveryOrderStatusSchema,
+  priority: BaseOrderFlowPrioritySchema
+})
+
+// ── Delivery Consolidation Sub-document ──────────────────────
+// Order-side projection of a ConsolidationOffer — only what the delivery
+// itself needs. Full engine state lives on the offer document (offerId ref).
+
+export const DeliveryConsolidationSchema = Type.Object({
+  offerId: OfferIdSchema,
+  leg1AgentId: AgentIdSchema,
+  leg2AgentIds: Type.Array( AgentIdSchema ),
+  cpointId: CPointIdSchema,
+  handoffCode: Type.Number({ description: '4-digit PIN exchanged at handoff' }),
+  status: Type.Union([
+    Type.Literal('PENDING'),
+    Type.Literal('IN_PROGRESS'),
+    Type.Literal('COMPLETED'),
+    Type.Literal('FAILED'),
+  ])
+})
+
+// ── Rally Dispatch Sub-document ───────────────────────────────
+// Stamped by Rally engines onto the order at various lifecycle points.
+// All fields except client and senderId begin null/absent and are
+// populated as the order moves through batch → dispatch → delivery.
+
+export const DeliveryRallyClientSchema = Type.Object({
+  reference: Type.String({ description: 'Consuming service own order reference — echoed in events' }),
+  branchId: Type.String({ description: 'Consuming service branch / location identifier' }),
+})
+
+export const DeliveryRallySchema = Type.Object({
+  client: DeliveryRallyClientSchema,
+  senderId: Type.String({ description: 'Origin party — vendor, warehouse, individual, etc.' }),
+  zoneId: Type.Optional( Type.Union([ Type.String(), Type.Null() ]) ),
+  riderId: Type.Optional( Type.Union([ Type.String(), Type.Null() ]) ),
+  offerId: Type.Optional( Type.Union([ OfferIdSchema, Type.Null() ]) ),
+  readyAfterMs: Type.Number({ minimum: 0, default: 0, description: 'Prep delay before rider should arrive at origin; 0 = immediate' }),
+  requiredAgentRole: Type.Optional( Type.String({ description: 'Agent capability role required; absent = any agent' }) ),
+  originTracked: Type.Boolean({ default: false, description: 'Whether senderId is scored as an origin party' }),
+  podId: Type.Optional( Type.String({ description: 'Pod unit ID — present when order is routed through a pod swarm bucket' }) ),
+})
+
+// ── Delivery Order Schema ─────────────────────────────────────
+// Extends BaseOrderSchema (type = LAST-MILE) with:
+//   • delivery-specific flow
+//   • explicit pickup / dropoff address pair (last-mile has a single leg)
+//   • typed rally sub-document (dispatch + zone + rider metadata)
+//
+// items[]  may be empty for opaque-package delivery; for food delivery
+// the calling service may populate them with menu items (category FD).
+// packages.totalWeight is the canonical capacity field used by Rally Scorer.
+
+export const DeliveryOrderSchema = Type.Intersect([
+  LSPBaseOrderSchema,
+  Type.Object({
+    flow: DeliveryOrderFlowSchema,
+    pickup: AddressSchema,
+    dropoff: AddressSchema,
+    rally: DeliveryRallySchema,
+    consolidation: Type.Optional( DeliveryConsolidationSchema ),
+    customerRating: Type.Optional( Type.Number({ minimum: 1, maximum: 5, description: 'Customer-submitted post-delivery rating' }) )
+  })
+])
+
+export const DeliveryDispatchableOrderSchema = Type.Object({
+  context: ContextSchema,           // carried so the sweep never loses context
+  reference: Type.String(),
+  client: DeliveryRallyClientSchema,
+  pickup: CoordinatesSchema,
+  dropoff: CoordinatesSchema,
+  senderId: Type.String(),  // origin party: warehouse, vendor, individual, etc.
+  zoneId: Type.String(),
+  slaDeadline: Type.Number(),  // ISO-8601; compared via timestamp at sort time
+  priority: OrderPrioritySchema,
+  readyAfterMs: Type.Number(),  // prep/assembly delay before agent should arrive; 0 = immediate
+  requiredAgentRole: Type.Optional(Type.String()), // when set, only agents with matching agentRole are eligible
+  addedAt: DateTimeZoneSchema  // unix ms — internal scheduling only
+})
+
+export const DeliveryIntackOrderRequestSchema = Type.Object({
+  client: Type.Object({
+    reference: Type.String(),
+    branchId: Type.String(),
+  }),
+  origin: LocationInputSchema,
+  destination: LocationInputSchema,
+  slaDeadline: Type.String({ format: 'date-time' }),
+  priority: OrderPrioritySchema,
+  weight: Type.Optional(WeightSchema),
+  volume: Type.Optional(VolumeSchema),
+  senderId: Type.String(),
+  readyAfterMs: Type.Optional( Type.Number({ minimum: 0, description: 'Prep/assembly delay in ms before agent should arrive; 0 = immediate' }) ),
+  senderDailyCap: Type.Optional( Type.Number({ minimum: 0, description: 'Max orders per day for this sender; 0 = uncapped' }) ),
+  requiredAgentRole: Type.Optional( Type.String({ description: 'Agent capability role required (e.g. SHOPPER); absent = any agent' }) ),
+  trackingNumber: Type.Optional( Type.String({ description: 'General order tracking number' }) ),
+  trackOriginScore: Type.Optional( Type.Boolean({ description: 'When true, senderId is scored as an origin party (availability + readiness tracking)' }) ),
+  podId: Type.Optional( Type.String({ description: 'Pod unit ID — when set, order is routed through the pod swarm bucket if the pod is available' }) ),
+})
+
+// ── Delivery Log Schema ───────────────────────────────────────
+
+export const DeliveryLogSchema = Type.Intersect([
+  ActionRecordSchema,
+  Type.Object({
+    flow: DeliveryOrderFlowSchema,
+    assignee: OrderAssigneeSchema,
+    location: Type.Optional( RTLocationSchema ),
+    reason: Type.Optional( Type.String({ maxLength: 500 }) ),
+    attachments: Type.Optional( Type.Array( Type.Object({
+      type: Type.Union([
+        Type.Literal('PHOTO'),
+        Type.Literal('SIGNATURE'),
+        Type.Literal('VOICE_NOTE'),
+        Type.Literal('BARCODE_SCAN'),
+      ]),
+      url: Type.String({ format: 'uri' }),
+      description: Type.Optional( Type.String({ maxLength: 200 }) )
+    })))
+  })
+])
+
+// ── TypeScript types ──────────────────────────────────────────
+
+export type DeliveryOrderProcess        = Static<typeof DeliveryOrderProcessSchema>
+export type DeliveryOrderStage          = Static<typeof DeliveryOrderStageSchema>
+export type DeliveryOrderStatus         = Static<typeof DeliveryOrderStatusSchema>
+export type DeliveryOrderFlow           = Static<typeof DeliveryOrderFlowSchema>
+export type DeliveryConsolidation       = Static<typeof DeliveryConsolidationSchema>
+export type DeliveryRallyClient         = Static<typeof DeliveryRallyClientSchema>
+export type DeliveryRally               = Static<typeof DeliveryRallySchema>
+export type DeliveryOrder               = Static<typeof DeliveryOrderSchema>
+export type DeliveryDispatchableOrder   = Static<typeof DeliveryDispatchableOrderSchema>
+export type DeliveryIntackOrderRequest  = Static<typeof DeliveryIntackOrderRequestSchema>
+export type DeliveryLog                 = Static<typeof DeliveryLogSchema>
+
+// ─── Request Validation Schemas ───────────────────────────────────────────────
+
+import {
+	APIErrorSchema,
+	APIHeadersSchema,
+	APIResponseBaseSchema,
+	APIResponseDataSchemaFactory
+} from '../../api'
+
+export const LSPOrderIntakeCreateRVS = {
+	headers:  APIHeadersSchema,
+	body:     DeliveryIntackOrderRequestSchema,
+	response: {
+		201:   APIResponseDataSchemaFactory({
+			reference:   Type.String(),
+			batchStatus: Type.Union([
+				Type.Literal('FORMING'),
+				Type.Literal('DISPATCHED'),
+				Type.Literal('DIRECT'),
+				Type.Literal('SENDER_CAP_REACHED'),
+				Type.Literal('SENDER_EXCLUDED')
+			]),
+			slaDeadline: Type.String(),
+			status:      DeliveryOrderStatusSchema
+		}),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPOrderIntakeApproveRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ reference: Type.String() }),
+	response: {
+		200:   APIResponseBaseSchema,
+		404:   APIErrorSchema,
+		'4XX': APIErrorSchema
+	}
+}
+
+export type LSPOrderIntakeCreateValidation  = { body: Static<typeof LSPOrderIntakeCreateRVS.body>, response: Static<(typeof LSPOrderIntakeCreateRVS.response)[201]> }
+export type LSPOrderIntakeApproveValidation = { params: Static<typeof LSPOrderIntakeApproveRVS.params>, response: Static<(typeof LSPOrderIntakeApproveRVS.response)[200]> }

package/src/lsp/order/flow/processes.ts

@@ -0,0 +1,70 @@
+import { Type } from '@sinclair/typebox'
+
+// Inbound Order Process Schema
+export const InboundOrderProcessSchema = Type.Union([
+  Type.Literal('RECEIVING'),
+  Type.Literal('PUTAWAY'),
+  Type.Literal('INVENTORY_ADJUSTMENT'),
+  Type.Literal('RETURN_PROCESSING'),
+  Type.Literal('EXCEPTION')
+])
+
+// Outbound Order Process Schema
+export const OutboundOrderProcessSchema = Type.Union([
+  Type.Literal('FULFILLMENT'),
+  Type.Literal('TRANSFER'),
+  Type.Literal('EXCEPTION')
+])
+
+// Internal Order Process Schema
+export const InternalOrderProcessSchema = Type.Union([
+  Type.Literal('CYCLE_COUNT'),
+  Type.Literal('REPLENISHMENT'),
+  Type.Literal('RELOCATION'),
+  Type.Literal('CONSOLIDATION'),
+  Type.Literal('KITTING'),
+  Type.Literal('ASSEMBLY'),
+  Type.Literal('EXCEPTION')
+])
+
+// Passthrough Order Process Schema
+export const PassthroughOrderProcessSchema = Type.Union([
+  Type.Literal('CROSS_DOCK'),
+  Type.Literal('CONSOLIDATION'),
+  Type.Literal('DECONSOLIDATION'),
+  Type.Literal('TRANSFER'),
+  Type.Literal('EXCEPTION')
+])
+
+// Shipping Order Process Types (following warehouse pattern)
+export const ShippingOrderProcessSchema = Type.Union([
+  Type.Literal('COLLECTION'),       // Picking up from origin
+  Type.Literal('LINEHAUL'),         // Long-distance transport
+  Type.Literal('DELIVERY'),         // Final delivery to destination
+  Type.Literal('TRANSFER'),         // Hub-to-hub transfer
+  Type.Literal('CONSOLIDATION'),    // Combining shipments
+  Type.Literal('DECONSOLIDATION'),  // Separating shipments
+  Type.Literal('CROSS_DOCK'),       // Direct transfer without storage
+  Type.Literal('SORTING'),          // Package sorting operations
+  Type.Literal('CUSTOMS'),          // Customs clearance
+  Type.Literal('RETURN')            // Return processing
+])
+
+// Delivery Order Process Types (Rally last-mile dispatch)
+export const DeliveryOrderProcessSchema = Type.Union([
+  Type.Literal('DISPATCH'),    // Rider matching + offer phase
+  Type.Literal('PICKUP'),      // Agent collecting from origin party
+  Type.Literal('DELIVERY'),    // Last-mile to recipient
+  Type.Literal('RETURN'),      // Failed-delivery return to origin
+  Type.Literal('EXCEPTION')    // Exception / intervention
+])
+
+// Ride Process Types (intra-city, quick trips, inter-city, long-distance)
+export const RideProcessSchema = Type.Union([
+  Type.Literal('BOOKING'),
+  Type.Literal('DISPATCH'),
+  Type.Literal('PICKUP'),
+  Type.Literal('TRANSIT'),
+  Type.Literal('REST_STOPS'),
+  Type.Literal('COMPLETION')
+])