@de./types 1.0.0

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

@@ -0,0 +1,119 @@
+import { Type } from '@sinclair/typebox'
+
+// Inbound Order Stage Schema
+export const InboundOrderStageSchema = Type.Union([    
+  Type.Literal('UNLOADING'),
+  Type.Literal('INSPECTING'),
+  Type.Literal('RECEIVING'),
+  Type.Literal('PROCESSING'),
+  Type.Literal('ALLOCATING'),
+  Type.Literal('STORING')
+])
+
+// Outbound Order Stage Schema
+export const OutboundOrderStageSchema = Type.Union([
+  Type.Literal('PROCESSING'),
+  Type.Literal('QUALITY_CHECK'),
+  Type.Literal('ALLOCATING'),
+  Type.Literal('PICKING'),
+  Type.Literal('PACKING'),
+  Type.Literal('STAGING'),
+  Type.Literal('LOADING')               // Loading onto vehicle
+])
+
+// Internal Order Stage Schema
+export const InternalOrderStageSchema = Type.Union([
+  Type.Literal('PROCESSING'),
+  Type.Literal('COUNTING'),
+  Type.Literal('MOVING'),
+  Type.Literal('ADJUSTING'),
+  Type.Literal('CONSOLIDATING'),
+  Type.Literal('KITTING'),
+  Type.Literal('ASSEMBLING'),
+  Type.Literal('EXCEPTION_REVIEW')      // Exception handling
+])
+
+// Passthrough Order Stage Schema
+export const PassthroughOrderStageSchema = Type.Union([
+  Type.Literal('ARRIVAL'),               // Package arrives at hub
+  Type.Literal('RECEIVING'),             // Package received and scanned
+  Type.Literal('INSPECTION'),            // Package inspection
+  Type.Literal('SORTING'),               // Sorting packages by destination
+  Type.Literal('PROCESSING'),            // Package sorting process
+  Type.Literal('CONSOLIDATING'),         // Package consolidation
+  Type.Literal('DECONSOLIDATING'),       // Package consolidation
+  Type.Literal('ROUTE_OPTIMIZATION'),    // Optimizing delivery routes
+  Type.Literal('STAGING'),               // Package staging for dispatch
+  Type.Literal('UNLOADING'),             // Loading onto vehicle
+  Type.Literal('LOADING'),               // Loading onto vehicle
+  Type.Literal('DEPARTURE'),             // Package left the hub
+  Type.Literal('EXCEPTION_REVIEW'),      // Exception handling
+  Type.Literal('QUALITY_CHECK')          // Quality verification
+])
+
+// Delivery Order Stage Schema (Rally last-mile dispatch)
+export const DeliveryOrderStageSchema = Type.Union([
+  Type.Literal('PROCESSING'),          // Queued in batch, awaiting dispatch
+  Type.Literal('READY_FOR_PICKUP'),    // Origin party signalled item is ready
+  Type.Literal('DISPATCHING'),         // Being matched to an available rider
+  Type.Literal('COLLECTING'),          // Rider en route to pickup location
+  Type.Literal('COLLECTED'),           // Rider has item; heading to dropoff
+  Type.Literal('DELIVERING'),          // Rider en route to recipient
+  Type.Literal('CONFIRMING'),          // Delivery confirmation at dropoff
+  Type.Literal('RETURNING'),           // Failed delivery; returning to origin
+  Type.Literal('EXCEPTION_REVIEW'),    // Requires manual / ops intervention
+])
+
+// Shipping Order Stage Schema
+export const ShippingOrderStageSchema = Type.Union([
+  Type.Literal('DISPATCHING'),      // Vehicle/driver assignment
+  Type.Literal('COLLECTING'),       // Pickup operations
+  Type.Literal('TRANSPORTING'),     // In-transit
+  Type.Literal('SORTING'),          // Hub sorting
+  Type.Literal('TRANSFERRING'),     // Hub transfers
+  Type.Literal('CONSOLIDATING'),    // Load consolidation
+  Type.Literal('CLEARING'),         // Customs clearance
+  Type.Literal('DELIVERING'),       // Final delivery
+  Type.Literal('CONFIRMING'),       // Delivery confirmation
+  Type.Literal('RETURNING')         // Return processing
+])
+
+// Ride Stage Schema
+export const RideStageSchema = Type.Union([
+  // BOOKING process stages
+  Type.Literal('REQUESTING'),
+  Type.Literal('PRICING'),
+  Type.Literal('SCHEDULE_PLANNING'),    // Planning departure time
+  Type.Literal('CONFIRMING'),
+  
+  // DISPATCH process stages
+  Type.Literal('SEARCHING'),
+  Type.Literal('ASSIGNING'),
+  Type.Literal('DRIVER_PREPARING'),     // Driver preparing vehicle for long trip
+  Type.Literal('DRIVER_ACCEPTING'),
+  
+  // PICKUP process stages
+  Type.Literal('DRIVER_EN_ROUTE'),
+  Type.Literal('DRIVER_ARRIVED'),
+  Type.Literal('WAITING_PASSENGER'),
+  Type.Literal('PASSENGER_BOARDING'),
+  Type.Literal('LUGGAGE_LOADING'),      // Loading passenger luggage
+  
+  // TRANSIT process stages
+  Type.Literal('IN_TRANSIT'),
+  Type.Literal('HIGHWAY_TRANSIT'),      // On highway/interstate
+  Type.Literal('APPROACHING_DESTINATION'),
+  
+  // REST_STOPS process stages
+  Type.Literal('REST_STOP_APPROACHING'),
+  Type.Literal('REST_STOP_ACTIVE'),     // At rest stop
+  Type.Literal('RESUMING_TRANSIT'),     // Continuing journey
+  
+  // COMPLETION process stages
+  Type.Literal('ARRIVED_DESTINATION'),
+  Type.Literal('LUGGAGE_UNLOADING'),
+  Type.Literal('PASSENGER_ALIGHTING'),
+  Type.Literal('PAYMENT_PROCESSING'),
+  Type.Literal('RATING'),
+  Type.Literal('COMPLETED')
+])

package/src/lsp/order/inbound.ts

@@ -0,0 +1,231 @@
+import { Type, Static } from '@sinclair/typebox'
+import { ActionRecordSchema } from '../../time'
+import { BaseOrderStatusSchema, BaseOrderFlowPrioritySchema, OrderAssigneeSchema, LSPBaseOrderSchema } from '../../order'
+import { InboundOrderProcessSchema } from './flow/processes'
+import { InboundOrderStageSchema } from './flow/stages'
+
+// Inbound Order Status Schema (extends BaseOrderStatus)
+export const InboundOrderStatusSchema = Type.Union([
+  ...BaseOrderStatusSchema.anyOf,
+  Type.Literal('ARRIVED'),
+  Type.Literal('RECEIVED'),
+  Type.Literal('REJECTED'),
+  Type.Literal('UNPACKED'),
+  Type.Literal('QUALITY_CHECKED'),
+  Type.Literal('DISCREPANCY_FOUND'),
+  Type.Literal('ALLOCATED'),
+  Type.Literal('STORED')
+])
+
+// Inbound Order Flow Schema
+export const InboundOrderFlowSchema = Type.Object({
+  process: InboundOrderProcessSchema,
+  stage: InboundOrderStageSchema, // Example stage flow: UNLOADING → INSPECTING → PROCESSING → ALLOCATING → STORING
+  status: InboundOrderStatusSchema,
+  priority: BaseOrderFlowPrioritySchema
+})
+
+// Inbound Order Schema (extends LSPBaseOrder)
+export const InboundOrderSchema = Type.Intersect([
+  LSPBaseOrderSchema,
+  Type.Object({
+    flow: InboundOrderFlowSchema
+  })
+])
+
+// Outbound Order Log Schema
+export const OutboundOrderLogSchema = Type.Intersect([
+  ActionRecordSchema,
+  Type.Object({
+    flow: InboundOrderFlowSchema,
+    assignee: OrderAssigneeSchema,
+    reason: Type.Optional(Type.String({ maxLength: 500 }))
+  })
+])
+
+// Generate TypeScript types from schemas
+export type InboundOrderProcess = Static<typeof InboundOrderProcessSchema>
+export type InboundOrderStage = Static<typeof InboundOrderStageSchema>
+export type InboundOrderStatus = Static<typeof InboundOrderStatusSchema>
+export type InboundOrderFlow = Static<typeof InboundOrderFlowSchema>
+export type InboundOrder = Static<typeof InboundOrderSchema>
+export type OutboundOrderLog = Static<typeof OutboundOrderLogSchema>
+
+// Validation helpers for process flow rules
+export const InboundFlowValidationSchema = Type.Object({
+  process: InboundOrderProcessSchema,
+  allowedStages: Type.Array(InboundOrderStageSchema),
+  description: Type.String()
+})
+
+// Flow transition validation schema
+export const InboundFlowTransitionSchema = Type.Object({
+  from: Type.Object({
+    process: InboundOrderProcessSchema,
+    stage: InboundOrderStageSchema,
+    status: InboundOrderStatusSchema
+  }),
+  to: Type.Object({
+    process: InboundOrderProcessSchema,
+    stage: InboundOrderStageSchema,
+    status: InboundOrderStatusSchema
+  }),
+  allowed: Type.Boolean(),
+  reason: Type.Optional(Type.String())
+})
+
+// Commented flow rules schema for future implementation
+export const InboundFlowRulesSchema = Type.Record(
+  InboundOrderProcessSchema,
+  Type.Array(InboundOrderStageSchema),
+  {
+    description: 'Defines allowed stages for each inbound process',
+    examples: [{
+      'RECEIVING': ['UNLOADING', 'INSPECTING', 'RECEIVING', 'PROCESSING'],
+      'PUTAWAY': ['PROCESSING', 'ALLOCATING', 'STORING'],
+      'INVENTORY_ADJUSTMENT': ['PROCESSING', 'ALLOCATING'],
+      'RETURN_PROCESSING': ['PROCESSING', 'INSPECTING', 'ALLOCATING']
+    }]
+  }
+)
+
+export type InboundFlowValidation = Static<typeof InboundFlowValidationSchema>
+export type InboundFlowTransition = Static<typeof InboundFlowTransitionSchema>
+export type InboundFlowRules      = Static<typeof InboundFlowRulesSchema>
+
+// ─── Request Validation Schemas ───────────────────────────────────────────────
+
+import {
+	APIErrorSchema,
+	APIHeadersSchema,
+	APIResponseBaseSchema,
+	APIResponseDataSchemaFactory
+} from '../../api'
+
+export const InboundOrderCreateBodySchema = Type.Object({
+	process:         InboundOrderProcessSchema,
+	priority:        Type.Optional(Type.Union([
+		Type.Literal('LOW'), Type.Literal('NORMAL'),
+		Type.Literal('HIGH'), Type.Literal('URGENT')
+	])),
+	client:          Type.Optional(Type.String()),
+	supplier:        Type.Optional(Type.String()),
+	expectedArrival: Type.Optional(Type.Number()),
+	notes:           Type.Optional(Type.String()),
+	items:           Type.Optional(Type.Array(Type.Object({
+		sku:              Type.String(),
+		description:      Type.Optional(Type.String()),
+		expectedQuantity: Type.Number()
+	})))
+})
+
+export const InboundOrderCompleteBodySchema = Type.Object({
+	actualArrival: Type.Optional(Type.Number()),
+	notes:         Type.Optional(Type.String()),
+	discrepancies: Type.Optional(Type.Array(Type.Object({
+		sku:              Type.String(),
+		expectedQuantity: Type.Number(),
+		receivedQuantity: Type.Number(),
+		reason:           Type.Optional(Type.String())
+	})))
+})
+
+export const InboundOrderUpdateBodySchema = Type.Object({
+	warehouse:       Type.Optional(Type.String()),
+	notes:           Type.Optional(Type.String()),
+	priority:        Type.Optional(Type.String()),
+	expectedArrival: Type.Optional(Type.Number())
+})
+
+export const InboundOrderListQuerySchema = Type.Object({
+	status:   Type.Optional(Type.String()),
+	clientId: Type.Optional(Type.String()),
+	fromDate: Type.Optional(Type.Number()),
+	toDate:   Type.Optional(Type.Number()),
+	limit:    Type.Optional(Type.Number()),
+	offset:   Type.Optional(Type.Number())
+})
+
+export const InboundOrderStatusUpdateBodySchema = Type.Object({
+	status: InboundOrderStatusSchema,
+	notes:  Type.Optional(Type.String())
+})
+
+export const LSPInboundOrderCreateRVS = {
+	headers:  APIHeadersSchema,
+	body:     InboundOrderCreateBodySchema,
+	response: {
+		201:   APIResponseDataSchemaFactory({ reference: Type.String() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPInboundOrderCompleteRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ reference: Type.String() }),
+	body:     InboundOrderCompleteBodySchema,
+	response: {
+		200:   APIResponseDataSchemaFactory({ order: InboundOrderSchema }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPInboundOrderUpdateRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ reference: Type.String() }),
+	body:     InboundOrderUpdateBodySchema,
+	response: {
+		200:   APIResponseDataSchemaFactory({ message: Type.String(), order: InboundOrderSchema }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPInboundOrderRetrieveRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ reference: Type.String() }),
+	response: {
+		200:   APIResponseDataSchemaFactory({ order: InboundOrderSchema, jrtoken: Type.String() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPInboundOrderListRVS = {
+	headers:     APIHeadersSchema,
+	querystring: InboundOrderListQuerySchema,
+	response: {
+		200:   APIResponseDataSchemaFactory({ orders: Type.Array(InboundOrderSchema), total: Type.Number() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPInboundOrderUpdateStatusRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ reference: Type.String() }),
+	body:     InboundOrderStatusUpdateBodySchema,
+	response: {
+		200:   APIResponseDataSchemaFactory({ message: Type.String(), order: InboundOrderSchema }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export type LSPInboundOrderCreateValidation       = { body: Static<typeof LSPInboundOrderCreateRVS.body>, response: Static<(typeof LSPInboundOrderCreateRVS.response)[201]> }
+export type LSPInboundOrderCompleteValidation     = { params: Static<typeof LSPInboundOrderCompleteRVS.params>, body: Static<typeof LSPInboundOrderCompleteRVS.body>, response: Static<(typeof LSPInboundOrderCompleteRVS.response)[200]> }
+export type LSPInboundOrderUpdateValidation       = { params: Static<typeof LSPInboundOrderUpdateRVS.params>, body: Static<typeof LSPInboundOrderUpdateRVS.body>, response: Static<(typeof LSPInboundOrderUpdateRVS.response)[200]> }
+export type LSPInboundOrderRetrieveValidation     = { params: Static<typeof LSPInboundOrderRetrieveRVS.params>, response: Static<(typeof LSPInboundOrderRetrieveRVS.response)[200]> }
+export type LSPInboundOrderListValidation         = { querystring: Static<typeof LSPInboundOrderListRVS.querystring>, response: Static<(typeof LSPInboundOrderListRVS.response)[200]> }
+export type LSPInboundOrderUpdateStatusValidation = { params: Static<typeof LSPInboundOrderUpdateStatusRVS.params>, body: Static<typeof LSPInboundOrderUpdateStatusRVS.body>, response: Static<(typeof LSPInboundOrderUpdateStatusRVS.response)[200]> }
+
+export const LSPInboundOrderAssignRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({
+		reference: Type.String(),
+		action:    Type.Union([Type.Literal('assign'), Type.Literal('unassign')]),
+		to:        Type.Union([Type.Literal('agent'), Type.Literal('operator')])
+	}),
+	body:     Type.Object({ id: Type.String() }),
+	response: {
+		200:   APIResponseDataSchemaFactory({ orderId: Type.String(), assigneeType: Type.String() }),
+		'4XX': APIErrorSchema
+	}
+}
+export type LSPInboundOrderAssignValidation = { params: Static<typeof LSPInboundOrderAssignRVS.params>, body: Static<typeof LSPInboundOrderAssignRVS.body>, response: Static<(typeof LSPInboundOrderAssignRVS.response)[200]> }

package/src/lsp/order/internal.ts

@@ -0,0 +1,305 @@
+import { Type, Static } from '@sinclair/typebox'
+import { ActionRecordSchema } from '../../time'
+import { BaseOrderStatusSchema, BaseOrderFlowPrioritySchema, OrderAssigneeSchema, LSPBaseOrderSchema } from '../../order'
+import { InternalOrderProcessSchema } from './flow/processes'
+import { InternalOrderStageSchema } from './flow/stages'
+import { PSLAddressSchema } from '../psl'
+
+// Internal Order Status Schema (extends BaseOrderStatus)
+export const InternalOrderStatusSchema = Type.Union([
+  ...BaseOrderStatusSchema.anyOf, // Include all BaseOrderStatus values
+  Type.Literal('PICKED'),
+  Type.Literal('PACKED'),
+  Type.Literal('COUNTED'),
+  Type.Literal('MOVED'),
+  Type.Literal('ADJUSTED'),
+  Type.Literal('CONSOLIDATED'),
+  Type.Literal('KITTED'),
+  Type.Literal('ASSEMBLED'),
+  Type.Literal('VERIFIED')
+])
+
+// Internal Order Flow Schema
+export const InternalOrderFlowSchema = Type.Object({
+  process: InternalOrderProcessSchema,
+  stage: InternalOrderStageSchema,
+  status: InternalOrderStatusSchema,
+  priority: BaseOrderFlowPrioritySchema
+})
+
+// Internal Order Schema (extends LSPBaseOrder)
+export const InternalOrderSchema = Type.Intersect([
+  LSPBaseOrderSchema,
+  Type.Object({
+    flow: InternalOrderFlowSchema,
+    
+    // Movement context for warehouse operations
+    origin: Type.Optional(Type.Object({
+      address: PSLAddressSchema, 
+      description: Type.Optional(Type.String())
+    })),
+    destination: Type.Optional(Type.Object({
+      address: PSLAddressSchema,
+      description: Type.Optional(Type.String())
+    }))
+  })
+])
+
+// Internal Order Log Schema
+export const InternalOrderLogSchema = Type.Intersect([
+  ActionRecordSchema,
+  Type.Object({
+    flow: InternalOrderFlowSchema,
+    assignee: OrderAssigneeSchema,
+    reason: Type.Optional(Type.String({ maxLength: 500 }))
+  })
+])
+
+// Generate TypeScript types from schemas
+export type InternalOrderProcess = Static<typeof InternalOrderProcessSchema>
+export type InternalOrderStage = Static<typeof InternalOrderStageSchema>
+export type InternalOrderStatus = Static<typeof InternalOrderStatusSchema>
+export type InternalOrderFlow = Static<typeof InternalOrderFlowSchema>
+export type InternalOrder = Static<typeof InternalOrderSchema>
+export type InternalOrderLog = Static<typeof InternalOrderLogSchema>
+
+// Validation helpers for internal order operations
+export const InternalOrderValidationSchema = Type.Object({
+  process: InternalOrderProcessSchema,
+  requiredStages: Type.Array(InternalOrderStageSchema),
+  allowedTransitions: Type.Array(Type.Object({
+    from: InternalOrderStatusSchema,
+    to: InternalOrderStatusSchema
+  }))
+})
+
+// Internal order process definitions
+export const InternalOrderProcessDefinitionSchema = Type.Object({
+  process: InternalOrderProcessSchema,
+  description: Type.String(),
+  defaultStages: Type.Array(InternalOrderStageSchema),
+  estimatedDuration: Type.Optional(Type.Number({ description: 'Duration in minutes' })),
+  requiredPermissions: Type.Optional(Type.Array(Type.String())),
+  automatable: Type.Optional(Type.Boolean())
+})
+
+export type InternalOrderValidation        = Static<typeof InternalOrderValidationSchema>
+export type InternalOrderProcessDefinition = Static<typeof InternalOrderProcessDefinitionSchema>
+
+// ─── Request Validation Schemas ───────────────────────────────────────────────
+
+import {
+	APIErrorSchema,
+	APIHeadersSchema,
+	APIResponseBaseSchema,
+	APIResponseDataSchemaFactory
+} from '../../api'
+
+const TaskPrioritySchema = Type.Union([
+	Type.Literal('LOW'), Type.Literal('NORMAL'),
+	Type.Literal('HIGH'), Type.Literal('URGENT')
+])
+
+export const TaskCreateBodySchema = Type.Object({
+	process:         InternalOrderProcessSchema,
+	priority:        Type.Optional(TaskPrioritySchema),
+	sourceLocation:  Type.Optional(Type.String()),
+	targetLocation:  Type.Optional(Type.String()),
+	productId:       Type.Optional(Type.String()),
+	quantity:        Type.Optional(Type.Number()),
+	metadata:        Type.Optional(Type.Record(Type.String(), Type.Any())),
+	notes:           Type.Optional(Type.String()),
+	scheduledFor:    Type.Optional(Type.Number())
+})
+
+export const TaskListQuerySchema = Type.Object({
+	process:    Type.Optional(InternalOrderProcessSchema),
+	status:     Type.Optional(Type.String()),
+	assigneeId: Type.Optional(Type.String()),
+	priority:   Type.Optional(Type.String()),
+	fromDate:   Type.Optional(Type.Number()),
+	toDate:     Type.Optional(Type.Number()),
+	limit:      Type.Optional(Type.Number()),
+	offset:     Type.Optional(Type.Number())
+})
+
+export const TaskUpdateBodySchema = Type.Object({
+	priority:       Type.Optional(Type.String()),
+	sourceLocation: Type.Optional(Type.String()),
+	targetLocation: Type.Optional(Type.String()),
+	quantity:       Type.Optional(Type.Number()),
+	notes:          Type.Optional(Type.String()),
+	scheduledFor:   Type.Optional(Type.Number())
+})
+
+export const TaskStatusUpdateBodySchema = Type.Object({
+	status:           InternalOrderStatusSchema,
+	notes:            Type.Optional(Type.String()),
+	verificationData: Type.Optional(Type.Object({
+		scannedBarcodes: Type.Optional(Type.Array(Type.String())),
+		actualQuantity:  Type.Optional(Type.Number()),
+		discrepancy:     Type.Optional(Type.Boolean()),
+		photoUrls:       Type.Optional(Type.Array(Type.String()))
+	}))
+})
+
+export const TaskCompleteBodySchema = Type.Object({
+	actualQuantity:   Type.Optional(Type.Number()),
+	verificationData: Type.Optional(Type.Object({
+		scannedBarcodes: Type.Optional(Type.Array(Type.String())),
+		discrepancies:   Type.Optional(Type.Array(Type.Object({
+			type:        Type.String(),
+			description: Type.String(),
+			severity:    Type.Union([Type.Literal('LOW'), Type.Literal('MEDIUM'), Type.Literal('HIGH')])
+		}))),
+		photoUrls:  Type.Optional(Type.Array(Type.String())),
+		signature:  Type.Optional(Type.String())
+	})),
+	notes: Type.Optional(Type.String())
+})
+
+export const TaskBatchCreateBodySchema = Type.Object({
+	process:      InternalOrderProcessSchema,
+	tasks:        Type.Array(Type.Object({
+		sourceLocation: Type.Optional(Type.String()),
+		targetLocation: Type.Optional(Type.String()),
+		productId:      Type.Optional(Type.String()),
+		quantity:       Type.Optional(Type.Number()),
+		priority:       Type.Optional(Type.String()),
+		metadata:       Type.Optional(Type.Record(Type.String(), Type.Any()))
+	})),
+	waveId:       Type.Optional(Type.String()),
+	scheduledFor: Type.Optional(Type.Number()),
+	notes:        Type.Optional(Type.String())
+})
+
+export const TaskPerformanceQuerySchema = Type.Object({
+	process:    Type.Optional(InternalOrderProcessSchema),
+	assigneeId: Type.Optional(Type.String()),
+	fromDate:   Type.Optional(Type.Number()),
+	toDate:     Type.Optional(Type.Number())
+})
+
+export const LSPTaskCreateRVS = {
+	headers:  APIHeadersSchema,
+	body:     TaskCreateBodySchema,
+	response: {
+		201:   APIResponseDataSchemaFactory({ taskId: Type.String(), reference: Type.String() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPTaskListRVS = {
+	headers:     APIHeadersSchema,
+	querystring: TaskListQuerySchema,
+	response: {
+		200:   APIResponseDataSchemaFactory({ tasks: Type.Array(InternalOrderSchema), total: Type.Number() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPTaskRetrieveRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ reference: Type.String() }),
+	response: {
+		200:   APIResponseDataSchemaFactory({ task: InternalOrderSchema, jrtoken: Type.String() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPTaskUpdateRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ reference: Type.String() }),
+	body:     TaskUpdateBodySchema,
+	response: {
+		200:   APIResponseDataSchemaFactory({ message: Type.String(), task: InternalOrderSchema }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPTaskUpdateStatusRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ reference: Type.String() }),
+	body:     TaskStatusUpdateBodySchema,
+	response: {
+		200:   APIResponseDataSchemaFactory({ message: Type.String(), task: InternalOrderSchema }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPTaskCompleteRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ reference: Type.String() }),
+	body:     TaskCompleteBodySchema,
+	response: {
+		200:   APIResponseDataSchemaFactory({ message: Type.String(), task: InternalOrderSchema }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPTaskBatchCreateRVS = {
+	headers:  APIHeadersSchema,
+	body:     TaskBatchCreateBodySchema,
+	response: {
+		201:   APIResponseDataSchemaFactory({
+			created: Type.Number(),
+			tasks:   Type.Array(Type.Object({ taskId: Type.String(), reference: Type.String() })),
+			waveId:  Type.Optional(Type.String())
+		}),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPTaskCancelRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ reference: Type.String() }),
+	body:     Type.Object({ reason: Type.String(), notes: Type.Optional(Type.String()) }),
+	response: {
+		200:   APIResponseBaseSchema,
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPTaskPerformanceRVS = {
+	headers:     APIHeadersSchema,
+	querystring: TaskPerformanceQuerySchema,
+	response: {
+		200:   APIResponseDataSchemaFactory({
+			metrics: Type.Object({
+				totalTasks:              Type.Number(),
+				completedTasks:          Type.Number(),
+				averageCompletionTime:   Type.Number(),
+				tasksPerHour:            Type.Number(),
+				accuracyRate:            Type.Number(),
+				byProcess:               Type.Record(Type.String(), Type.Any()),
+				byPriority:              Type.Record(Type.String(), Type.Number())
+			})
+		}),
+		'4XX': APIErrorSchema
+	}
+}
+
+export type LSPTaskCreateValidation       = { body: Static<typeof LSPTaskCreateRVS.body>, response: Static<(typeof LSPTaskCreateRVS.response)[201]> }
+export type LSPTaskListValidation         = { querystring: Static<typeof LSPTaskListRVS.querystring>, response: Static<(typeof LSPTaskListRVS.response)[200]> }
+export type LSPTaskRetrieveValidation     = { params: Static<typeof LSPTaskRetrieveRVS.params>, response: Static<(typeof LSPTaskRetrieveRVS.response)[200]> }
+export type LSPTaskUpdateValidation       = { params: Static<typeof LSPTaskUpdateRVS.params>, body: Static<typeof LSPTaskUpdateRVS.body>, response: Static<(typeof LSPTaskUpdateRVS.response)[200]> }
+export type LSPTaskUpdateStatusValidation = { params: Static<typeof LSPTaskUpdateStatusRVS.params>, body: Static<typeof LSPTaskUpdateStatusRVS.body>, response: Static<(typeof LSPTaskUpdateStatusRVS.response)[200]> }
+export type LSPTaskCompleteValidation     = { params: Static<typeof LSPTaskCompleteRVS.params>, body: Static<typeof LSPTaskCompleteRVS.body>, response: Static<(typeof LSPTaskCompleteRVS.response)[200]> }
+export type LSPTaskBatchCreateValidation  = { body: Static<typeof LSPTaskBatchCreateRVS.body>, response: Static<(typeof LSPTaskBatchCreateRVS.response)[201]> }
+export type LSPTaskCancelValidation       = { params: Static<typeof LSPTaskCancelRVS.params>, body: Static<typeof LSPTaskCancelRVS.body>, response: Static<(typeof LSPTaskCancelRVS.response)[200]> }
+export type LSPTaskPerformanceValidation  = { querystring: Static<typeof LSPTaskPerformanceRVS.querystring>, response: Static<(typeof LSPTaskPerformanceRVS.response)[200]> }
+
+export const LSPTaskAssignRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({
+		reference: Type.String(),
+		action:    Type.Union([Type.Literal('assign'), Type.Literal('unassign')]),
+		to:        Type.Union([Type.Literal('agent'), Type.Literal('operator')])
+	}),
+	body:     Type.Object({ id: Type.String() }),
+	response: {
+		200:   APIResponseBaseSchema,
+		'4XX': APIErrorSchema
+	}
+}
+export type LSPTaskAssignValidation = { params: Static<typeof LSPTaskAssignRVS.params>, body: Static<typeof LSPTaskAssignRVS.body>, response: Static<(typeof LSPTaskAssignRVS.response)[200]> }