@de./types 1.0.0

package/src/lsp/order/passthrough.ts

@@ -0,0 +1,434 @@
+import { Type, Static } from '@sinclair/typebox'
+import { RoutingSegmentSchema } from '../../routing'
+import { ActionRecordSchema } from '../../time'
+import { AddressSchema } from '../../geo'
+import { ContextSchema } from '../../context'
+import { 
+  BaseOrderFlowPrioritySchema,
+  BaseOrderStatusSchema,
+  LSPBaseOrderSchema
+} from '../../order'
+import { PassthroughOrderProcessSchema } from './flow/processes'
+import { PassthroughOrderStageSchema } from './flow/stages'
+
+// Passthrough Order Status Schema
+export const PassthroughOrderStatusSchema = Type.Union([
+  ...BaseOrderStatusSchema.anyOf,
+  Type.Literal('IN_TRANSIT_TO_HUB'),     // En route to hub
+  Type.Literal('AT_HUB'),                // At hub facility
+  Type.Literal('SCANNED_IN'),            // Scanned into hub
+  Type.Literal('SORTED'),                // Package sorted
+  Type.Literal('CONSOLIDATED'),          // Added to consolidated shipment
+  Type.Literal('DECONSOLIDATED'),        // Extracted from consolidated shipment
+  Type.Literal('STAGED'),                // Staged for dispatch
+  Type.Literal('UNLOADED'),              // Staged for dispatch
+  Type.Literal('LOADED'),                // Loaded for dispatch
+  Type.Literal('DISPATCHED'),            // Dispatched from hub
+  Type.Literal('EXCEPTION'),             // Exception status
+  Type.Literal('DAMAGED'),               // Package damaged
+  Type.Literal('MISSING'),               // Package missing
+  Type.Literal('QUARANTINED'),           // Package quarantined
+  Type.Literal('REROUTED')               // Package rerouted
+])
+
+// Passthrough Order Flow Schema
+export const PassthroughOrderFlowSchema = Type.Object({
+  process: PassthroughOrderProcessSchema,
+  stage: PassthroughOrderStageSchema,
+  status: PassthroughOrderStatusSchema,
+  priority: BaseOrderFlowPrioritySchema
+})
+
+// Passthrough Order Schema
+export const PassthroughOrderSchema = Type.Intersect([
+  LSPBaseOrderSchema,
+  Type.Object({
+    id: Type.String(),
+    flow: PassthroughOrderFlowSchema,
+    
+    // Hub-specific fields
+    currentHub: Type.Optional(Type.String({ description: 'Current hub ID' })),
+    
+    // Enhanced route (following shipping order pattern)
+    route: Type.Optional(RoutingSegmentSchema),
+    
+    // Shipping fields
+    origin: Type.Optional(AddressSchema),
+    destination: Type.Optional(AddressSchema),
+    serviceLevel: Type.Optional(Type.String({ description: 'Service level code' })),
+    
+    // Consolidation & routing
+    sortDestination: Type.Optional(AddressSchema),
+    consolidationId: Type.Optional(Type.String({ description: 'Consolidation ID if consolidated' })),
+    assignedCarrier: Type.Optional(Type.String({ description: 'Assigned carrier ID' })),
+    
+    // Timing
+    departureTime: Type.Optional(Type.Number({ description: 'Unix timestamp of departure' })),
+    
+    // Audit trail
+    created: ActionRecordSchema,
+    updated: Type.Optional(ActionRecordSchema)
+  })
+])
+
+// Passthrough Order Log Assignee Schema - simplified for logging
+export const PassthroughOrderLogAssigneeSchema = Type.Object({
+  id: Type.String(),
+  type: Type.Union([
+    Type.Literal('admin'),
+    Type.Literal('operator'),
+    Type.Literal('agent'),
+    Type.Literal('developer')
+  ])
+})
+
+// Passthrough Order Log Schema
+export const PassthroughOrderLogSchema = Type.Intersect([
+  ActionRecordSchema,
+  Type.Object({
+    orderId: Type.String(),
+    orderReference: Type.String(),
+    flow: PassthroughOrderFlowSchema,
+    assignee: PassthroughOrderLogAssigneeSchema,
+    location: Type.Optional(Type.String({ description: 'Specific location within hub' })),
+    equipment: Type.Optional(Type.String({ description: 'Equipment used' })),
+    reason: Type.Optional(Type.String({ maxLength: 500 })),
+    metadata: Type.Optional(Type.Record(Type.String(), Type.Any()))
+  })
+])
+
+export type PassthroughOrderProcess = Static<typeof PassthroughOrderProcessSchema>
+export type PassthroughOrderStage = Static<typeof PassthroughOrderStageSchema>
+export type PassthroughOrderStatus = Static<typeof PassthroughOrderStatusSchema>
+export type PassthroughOrderFlow = Static<typeof PassthroughOrderFlowSchema>
+export type PassthroughOrder = Static<typeof PassthroughOrderSchema>
+export type PassthroughOrderLog = Static<typeof PassthroughOrderLogSchema>
+
+// ── Hub Outbound Consolidation ────────────────────────────────────────────────
+// Groups passthrough orders at a hub/warehouse into an outbound shipment batch
+// for carrier dispatch. Distinct from Rally ConsolidationOffer (agent meetups).
+
+export const HubConsolidationStatusSchema = Type.Union([
+  Type.Literal('ACTIVE'),
+  Type.Literal('DISPATCHED'),
+  Type.Literal('CANCELLED'),
+  Type.Literal('CLOSED'),
+])
+
+export const HubConsolidationSchema = Type.Object({
+  id: Type.String(),
+  locationId: Type.String({ description: 'Hub or warehouse ID' }),
+  destination: Type.String({ description: 'Outbound destination identifier' }),
+  carrier: Type.Optional(Type.String()),
+  vehicleId: Type.Optional(Type.String()),
+  driverId: Type.Optional(Type.String()),
+  orderReferences: Type.Array(Type.String()),
+  status: HubConsolidationStatusSchema,
+  targetDepartureTime: Type.Optional(Type.Number()),
+  actualDepartureTime: Type.Optional(Type.Number()),
+  deconsolidationReason: Type.Optional(Type.String()),
+  notes: Type.Optional(Type.String({ maxLength: 500 })),
+  context: ContextSchema,
+  created: ActionRecordSchema,
+  updated: Type.Optional(ActionRecordSchema),
+})
+
+export type HubConsolidationStatus = Static<typeof HubConsolidationStatusSchema>
+export type HubConsolidation       = Static<typeof HubConsolidationSchema>
+
+// ─── Request Validation Schemas ───────────────────────────────────────────────
+
+import {
+	APIErrorSchema,
+	APIHeadersSchema,
+	APIResponseBaseSchema,
+	APIResponseDataSchemaFactory
+} from '../../api'
+
+const PassthroughPrioritySchema = Type.Union([
+	Type.Literal('LOW'), Type.Literal('NORMAL'),
+	Type.Literal('HIGH'), Type.Literal('URGENT')
+])
+
+export const PassthroughOrderCreateBodySchema = Type.Object({
+	reference:    Type.String(),
+	client:       Type.String(),
+	packages:     Type.Array(Type.Object({
+		weight:     Type.Any(),
+		dimensions: Type.Any(),
+		value:      Type.Optional(Type.Any()),
+		tracking:   Type.Optional(Type.Object({
+			masterTrackingNumber:  Type.String(),
+			trackingNumber:        Type.String(),
+			carrierTrackingNumber: Type.Optional(Type.String())
+		}))
+	})),
+	origin:       Type.Object({ address: Type.Any(), contact: Type.Optional(Type.Any()) }),
+	destination:  Type.Object({ address: Type.Any(), contact: Type.Optional(Type.Any()) }),
+	serviceLevel: Type.String(),
+	process:      PassthroughOrderProcessSchema,
+	priority:     Type.Optional(PassthroughPrioritySchema)
+})
+
+export const PassthroughOrderListQuerySchema = Type.Object({
+	status:   Type.Optional(PassthroughOrderStatusSchema),
+	process:  Type.Optional(PassthroughOrderProcessSchema),
+	stage:    Type.Optional(PassthroughOrderStageSchema),
+	fromDate: Type.Optional(Type.Number()),
+	toDate:   Type.Optional(Type.Number()),
+	limit:    Type.Optional(Type.Number({ minimum: 1, maximum: 500 })),
+	offset:   Type.Optional(Type.Number({ minimum: 0 }))
+})
+
+export const PassthroughOrderUpdateStageBodySchema = Type.Object({
+	stage:    PassthroughOrderStageSchema,
+	status:   Type.Optional(PassthroughOrderStatusSchema),
+	location: Type.Optional(Type.String()),
+	notes:    Type.Optional(Type.String())
+})
+
+export const PassthroughOrderUpdateStatusBodySchema = Type.Object({
+	status:   PassthroughOrderStatusSchema,
+	reason:   Type.Optional(Type.String()),
+	metadata: Type.Optional(Type.Record(Type.String(), Type.Any()))
+})
+
+export const PassthroughOrderLogsQuerySchema = Type.Object({
+	limit:  Type.Optional(Type.Number({ minimum: 1, maximum: 200, default: 50 })),
+	offset: Type.Optional(Type.Number({ minimum: 0, default: 0 }))
+})
+
+export const LSPPassthroughOrderCreateRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ hubId: Type.String() }),
+	body:     PassthroughOrderCreateBodySchema,
+	response: {
+		201:   APIResponseDataSchemaFactory({ order: PassthroughOrderSchema, message: Type.String() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPassthroughOrderListRVS = {
+	headers:     APIHeadersSchema,
+	params:      Type.Object({ hubId: Type.String() }),
+	querystring: PassthroughOrderListQuerySchema,
+	response: {
+		200:   APIResponseDataSchemaFactory({
+			orders: Type.Array(PassthroughOrderSchema),
+			total:  Type.Number(),
+			limit:  Type.Number(),
+			offset: Type.Number()
+		}),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPassthroughOrderGetRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ hubId: Type.String(), reference: Type.String() }),
+	response: {
+		200:   APIResponseDataSchemaFactory({ order: PassthroughOrderSchema }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPassthroughOrderUpdateStageRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ hubId: Type.String(), reference: Type.String() }),
+	body:     PassthroughOrderUpdateStageBodySchema,
+	response: {
+		200:   APIResponseDataSchemaFactory({ order: PassthroughOrderSchema, message: Type.String() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPassthroughOrderUpdateStatusRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ hubId: Type.String(), reference: Type.String() }),
+	body:     PassthroughOrderUpdateStatusBodySchema,
+	response: {
+		200:   APIResponseDataSchemaFactory({ order: PassthroughOrderSchema, message: Type.String() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPassthroughOrderCancelRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ hubId: Type.String(), reference: Type.String() }),
+	body:     Type.Object({ reason: Type.String({ maxLength: 500 }), notes: Type.Optional(Type.String()) }),
+	response: {
+		200:   APIResponseBaseSchema,
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPassthroughOrderLogsRVS = {
+	headers:     APIHeadersSchema,
+	params:      Type.Object({ hubId: Type.String(), reference: Type.String() }),
+	querystring: PassthroughOrderLogsQuerySchema,
+	response: {
+		200:   APIResponseDataSchemaFactory({ logs: Type.Array(Type.Any()), total: Type.Number() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPassthroughOrderAssignRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ hubId: Type.String(), reference: Type.String() }),
+	body:     Type.Object({
+		type: Type.Union([Type.Literal('agent'), Type.Literal('operator')]),
+		id:   Type.String()
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({ order: PassthroughOrderSchema }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export type LSPPassthroughOrderCreateValidation       = { params: Static<typeof LSPPassthroughOrderCreateRVS.params>, body: Static<typeof LSPPassthroughOrderCreateRVS.body>, response: Static<(typeof LSPPassthroughOrderCreateRVS.response)[201]> }
+export type LSPPassthroughOrderListValidation         = { params: Static<typeof LSPPassthroughOrderListRVS.params>, querystring: Static<typeof LSPPassthroughOrderListRVS.querystring>, response: Static<(typeof LSPPassthroughOrderListRVS.response)[200]> }
+export type LSPPassthroughOrderGetValidation          = { params: Static<typeof LSPPassthroughOrderGetRVS.params>, response: Static<(typeof LSPPassthroughOrderGetRVS.response)[200]> }
+export type LSPPassthroughOrderUpdateStageValidation  = { params: Static<typeof LSPPassthroughOrderUpdateStageRVS.params>, body: Static<typeof LSPPassthroughOrderUpdateStageRVS.body>, response: Static<(typeof LSPPassthroughOrderUpdateStageRVS.response)[200]> }
+export type LSPPassthroughOrderUpdateStatusValidation = { params: Static<typeof LSPPassthroughOrderUpdateStatusRVS.params>, body: Static<typeof LSPPassthroughOrderUpdateStatusRVS.body>, response: Static<(typeof LSPPassthroughOrderUpdateStatusRVS.response)[200]> }
+export type LSPPassthroughOrderCancelValidation       = { params: Static<typeof LSPPassthroughOrderCancelRVS.params>, body: Static<typeof LSPPassthroughOrderCancelRVS.body>, response: Static<(typeof LSPPassthroughOrderCancelRVS.response)[200]> }
+export type LSPPassthroughOrderLogsValidation         = { params: Static<typeof LSPPassthroughOrderLogsRVS.params>, querystring: Static<typeof LSPPassthroughOrderLogsRVS.querystring>, response: Static<(typeof LSPPassthroughOrderLogsRVS.response)[200]> }
+export type LSPPassthroughOrderAssignValidation       = { params: Static<typeof LSPPassthroughOrderAssignRVS.params>, body: Static<typeof LSPPassthroughOrderAssignRVS.body>, response: Static<(typeof LSPPassthroughOrderAssignRVS.response)[200]> }
+
+// ─── Outbound Consolidation RVS ───────────────────────────────────────────────
+
+export const LSPOutboundConsolidationCreateRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     Type.Object({
+		orderReferences:     Type.Array(Type.String(), { minItems: 1 }),
+		destination:         Type.String(),
+		carrier:             Type.Optional(Type.String()),
+		targetDepartureTime: Type.Optional(Type.Number()),
+		notes:               Type.Optional(Type.String({ maxLength: 500 }))
+	}),
+	response: {
+		201:   APIResponseDataSchemaFactory({ consolidation: HubConsolidationSchema }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPOutboundConsolidationAddOrdersRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String(), consolidationId: Type.String() }),
+	body:     Type.Object({
+		orderReferences: Type.Array(Type.String(), { minItems: 1 }),
+		notes:           Type.Optional(Type.String({ maxLength: 500 }))
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({
+			added:  Type.Array(Type.String()),
+			failed: Type.Array(Type.Object({ reference: Type.String(), reason: Type.String() }))
+		}),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPOutboundConsolidationRemoveOrdersRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String(), consolidationId: Type.String() }),
+	body:     Type.Object({
+		orderReferences: Type.Array(Type.String(), { minItems: 1 }),
+		notes:           Type.Optional(Type.String({ maxLength: 500 }))
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({
+			removed:  Type.Array(Type.String()),
+			notFound: Type.Array(Type.String())
+		}),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPOutboundConsolidationUpdateRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String(), consolidationId: Type.String() }),
+	body:     Type.Object({
+		destination:         Type.Optional(Type.String()),
+		carrier:             Type.Optional(Type.String()),
+		targetDepartureTime: Type.Optional(Type.Number()),
+		notes:               Type.Optional(Type.String({ maxLength: 500 }))
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({ consolidation: HubConsolidationSchema }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPOutboundConsolidationDeconsolidateRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String(), consolidationId: Type.String() }),
+	body:     Type.Object({
+		reason: Type.String(),
+		notes:  Type.Optional(Type.String({ maxLength: 500 }))
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({ deconsolidated: Type.Number() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPOutboundConsolidationCancelRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String(), consolidationId: Type.String() }),
+	body:     Type.Object({
+		reason: Type.String(),
+		notes:  Type.Optional(Type.String({ maxLength: 500 }))
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({ reverted: Type.Number() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPOutboundConsolidationFetchRVS = {
+	headers:     APIHeadersSchema,
+	params:      Type.Object({ id: Type.String() }),
+	querystring: Type.Object({
+		status: Type.Optional(HubConsolidationStatusSchema),
+		limit:  Type.Optional(Type.Number({ minimum: 1, maximum: 500 })),
+		offset: Type.Optional(Type.Number({ minimum: 0 }))
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({ consolidations: Type.Array(HubConsolidationSchema), total: Type.Number() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPOutboundConsolidationGetRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String(), consolidationId: Type.String() }),
+	response: {
+		200:   APIResponseDataSchemaFactory({ consolidation: HubConsolidationSchema }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPOutboundConsolidationDispatchRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String(), consolidationId: Type.String() }),
+	body:     Type.Object({
+		vehicleId:     Type.Optional(Type.String()),
+		driverId:      Type.Optional(Type.String()),
+		departureTime: Type.Optional(Type.Number()),
+		notes:         Type.Optional(Type.String({ maxLength: 500 }))
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({ dispatched: Type.Number(), consolidationId: Type.String() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export type LSPOutboundConsolidationCreateValidation        = { params: Static<typeof LSPOutboundConsolidationCreateRVS.params>, body: Static<typeof LSPOutboundConsolidationCreateRVS.body>, response: Static<(typeof LSPOutboundConsolidationCreateRVS.response)[201]> }
+export type LSPOutboundConsolidationAddOrdersValidation     = { params: Static<typeof LSPOutboundConsolidationAddOrdersRVS.params>, body: Static<typeof LSPOutboundConsolidationAddOrdersRVS.body>, response: Static<(typeof LSPOutboundConsolidationAddOrdersRVS.response)[200]> }
+export type LSPOutboundConsolidationRemoveOrdersValidation  = { params: Static<typeof LSPOutboundConsolidationRemoveOrdersRVS.params>, body: Static<typeof LSPOutboundConsolidationRemoveOrdersRVS.body>, response: Static<(typeof LSPOutboundConsolidationRemoveOrdersRVS.response)[200]> }
+export type LSPOutboundConsolidationUpdateValidation        = { params: Static<typeof LSPOutboundConsolidationUpdateRVS.params>, body: Static<typeof LSPOutboundConsolidationUpdateRVS.body>, response: Static<(typeof LSPOutboundConsolidationUpdateRVS.response)[200]> }
+export type LSPOutboundConsolidationDeconsolidateValidation = { params: Static<typeof LSPOutboundConsolidationDeconsolidateRVS.params>, body: Static<typeof LSPOutboundConsolidationDeconsolidateRVS.body>, response: Static<(typeof LSPOutboundConsolidationDeconsolidateRVS.response)[200]> }
+export type LSPOutboundConsolidationCancelValidation        = { params: Static<typeof LSPOutboundConsolidationCancelRVS.params>, body: Static<typeof LSPOutboundConsolidationCancelRVS.body>, response: Static<(typeof LSPOutboundConsolidationCancelRVS.response)[200]> }
+export type LSPOutboundConsolidationFetchValidation         = { params: Static<typeof LSPOutboundConsolidationFetchRVS.params>, querystring: Static<typeof LSPOutboundConsolidationFetchRVS.querystring>, response: Static<(typeof LSPOutboundConsolidationFetchRVS.response)[200]> }
+export type LSPOutboundConsolidationGetValidation           = { params: Static<typeof LSPOutboundConsolidationGetRVS.params>, response: Static<(typeof LSPOutboundConsolidationGetRVS.response)[200]> }
+export type LSPOutboundConsolidationDispatchValidation      = { params: Static<typeof LSPOutboundConsolidationDispatchRVS.params>, body: Static<typeof LSPOutboundConsolidationDispatchRVS.body>, response: Static<(typeof LSPOutboundConsolidationDispatchRVS.response)[200]> }

package/src/lsp/order/ride.ts

@@ -0,0 +1,190 @@
+import { Type, Static } from '@sinclair/typebox'
+import { VehicleSchema } from '../fleet/vehicle'
+import { ActionRecordSchema, DateTimeZoneSchema, DurationSchema } from '../../time'
+import { DistanceSchema, WeightSchema } from '../../measure'
+import { RTLocationSchema, AddressSchema } from '../../geo'
+import {
+  BaseOrderSchema,
+  BaseOrderStatusSchema,
+  BaseOrderFlowPrioritySchema,
+  OrderAssigneeSchema,
+  RideOrderTypeSchema
+} from '../../order'
+import { RideProcessSchema } from './flow/processes'
+import { RideStageSchema } from './flow/stages'
+
+/**
+ * Ride Order Type-Specific Definitions
+ * Following the same pattern as ShippingOrder
+ */
+
+// Ride-Specific Status (extends base statuses)
+export const RideOrderStatusSchema = Type.Union([
+  ...BaseOrderStatusSchema.anyOf,
+  Type.Literal('DRIVER_ASSIGNED'),
+  Type.Literal('DRIVER_EN_ROUTE'),
+  Type.Literal('DRIVER_ARRIVED'),
+  Type.Literal('PASSENGER_ONBOARD'),
+  Type.Literal('IN_TRANSIT'),
+  Type.Literal('AT_DESTINATION'),
+  Type.Literal('COMPLETED'),
+  Type.Literal('PASSENGER_NO_SHOW'),
+  Type.Literal('DRIVER_CANCELLED'),
+  Type.Literal('PASSENGER_CANCELLED'),
+  Type.Literal('RIDE_ABANDONED'),
+  Type.Literal('INCIDENT_REPORTED')
+])
+
+// Long-Mile Ride Flow
+export const RideOrderFlowSchema = Type.Object({
+  process: RideProcessSchema,
+  stage: RideStageSchema,
+  status: RideOrderStatusSchema,
+  priority: BaseOrderFlowPrioritySchema
+})
+
+// Passenger Schema
+export const PassengerSchema = Type.Object({
+  id: Type.String(),
+  name: Type.String({ minLength: 1, maxLength: 100 }),
+  phone: Type.String(),
+  rating: Type.Optional(Type.Number({ minimum: 1, maximum: 5 })),
+  verified: Type.Boolean({ default: false }),
+  specialNeeds: Type.Optional(Type.Array(Type.Union([
+    Type.Literal('WHEELCHAIR'),
+    Type.Literal('CHILD_SEAT'),
+    Type.Literal('PET_FRIENDLY'),
+    Type.Literal('ELDERLY_ASSISTANCE'),
+    Type.Literal('MEDICAL_ASSISTANCE')
+  ])))
+})
+
+// Luggage Schema
+export const LuggageSchema = Type.Object({
+  count: Type.Number({ minimum: 0, maximum: 10 }),
+  type: Type.Array(Type.Union([
+    Type.Literal('SMALL_BAG'),
+    Type.Literal('MEDIUM_BAG'),
+    Type.Literal('LARGE_BAG'),
+    Type.Literal('SUITCASE'),
+    Type.Literal('BACKPACK'),
+    Type.Literal('SPORTS_EQUIPMENT'),
+    Type.Literal('OVERSIZED')
+  ])),
+  totalWeight: Type.Optional(WeightSchema) // kg
+})
+
+// Main Ride Order Schema (extends RideBaseOrder with flow)
+export const RideOrderSchema = Type.Intersect([
+  BaseOrderSchema,
+  Type.Object({
+    type: RideOrderTypeSchema,
+    // Ride-specific flow
+    flow: RideOrderFlowSchema,
+    
+    // Ride-specific fields
+    pickup: AddressSchema,
+    dropoff: AddressSchema,
+    passengers: Type.Array(PassengerSchema, { minItems: 1 }),
+    luggage: Type.Optional(LuggageSchema),
+    
+    // Vehicle and driver assignment
+    vehicle: Type.Optional(VehicleSchema),
+    estimatedDuration: Type.Optional(DurationSchema),
+    estimatedDistance: Type.Optional(DistanceSchema),
+    
+    // Fare information
+    fare: Type.Object({
+      baseFare: Type.Number({ minimum: 0 }),
+      distanceFare: Type.Optional(Type.Number({ minimum: 0 })),
+      timeFare: Type.Optional(Type.Number({ minimum: 0 })),
+      surcharges: Type.Optional(Type.Array(Type.Object({
+        type: Type.Union([
+          Type.Literal('NIGHT_CHARGE'),
+          Type.Literal('PEAK_HOUR'),
+          Type.Literal('TOLL'),
+          Type.Literal('AIRPORT_FEE'),
+          Type.Literal('WAITING_TIME'),
+          Type.Literal('CANCELLATION_FEE')
+        ]),
+        amount: Type.Number({ minimum: 0 }),
+        description: Type.Optional(Type.String({ maxLength: 200 }))
+      }))),
+      discount: Type.Optional(Type.Number({ minimum: 0 })),
+      totalFare: Type.Number({ minimum: 0 }),
+      currency: Type.String({ default: 'USD' })
+    }),
+    
+    // Payment information
+    payment: Type.Optional(Type.Object({
+      method: Type.Union([
+        Type.Literal('CASH'),
+        Type.Literal('CARD'),
+        Type.Literal('WALLET'),
+        Type.Literal('CORPORATE'),
+        Type.Literal('OTHER')
+      ]),
+      status: Type.Union([
+        Type.Literal('PENDING'),
+        Type.Literal('AUTHORIZED'),
+        Type.Literal('CAPTURED'),
+        Type.Literal('FAILED'),
+        Type.Literal('REFUNDED')
+      ]),
+      transactionId: Type.Optional(Type.String()),
+      paid: Type.Optional(ActionRecordSchema)
+    })),
+    
+    // Trip metrics (filled during/after ride)
+    metrics: Type.Optional(Type.Object({
+      actualDistance: Type.Optional(DistanceSchema),
+      actualDuration: Type.Optional(DurationSchema),
+      waitingTime: Type.Optional(DurationSchema),
+      routeDeviation: Type.Optional(Type.Number({ minimum: 0, description: 'km' })),
+      startOdometer: Type.Optional(Type.Number({ minimum: 0 })),
+      endOdometer: Type.Optional(Type.Number({ minimum: 0 }))
+    })),
+    
+    // Special instructions
+    instructions: Type.Optional(Type.String({ maxLength: 500 })),
+    
+    // Ride preferences
+    preferences: Type.Optional(Type.Object({
+      ac: Type.Optional(Type.Boolean()),
+      music: Type.Optional(Type.Boolean()),
+      conversation: Type.Optional(Type.Boolean()),
+      temperature: Type.Optional(Type.Number({ minimum: 16, maximum: 30 }))
+    }))
+  })
+])
+
+// Ride Log Schema
+export const RideLogSchema = Type.Intersect([
+  ActionRecordSchema,
+  Type.Object({
+    flow: RideOrderFlowSchema,
+    assignee: Type.Optional(OrderAssigneeSchema),
+    location: Type.Optional(RTLocationSchema),
+    odometer: Type.Optional(Type.Number({ minimum: 0 })),
+    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('VIDEO'),
+        Type.Literal('VOICE_NOTE'),
+        Type.Literal('INCIDENT_REPORT')
+      ]),
+      url: Type.String({ format: 'uri' }),
+      description: Type.Optional(Type.String({ maxLength: 200 }))
+    })))
+  })
+])
+
+// TypeScript type exports
+export type RideOrderStatus = Static<typeof RideOrderStatusSchema>
+export type RideOrderFlow = Static<typeof RideOrderFlowSchema>
+export type Passenger = Static<typeof PassengerSchema>
+export type Luggage = Static<typeof LuggageSchema>
+export type RideOrder = Static<typeof RideOrderSchema>
+export type RideLog = Static<typeof RideLogSchema>