@de./types 1.0.0

package/src/lsp/terminal/index.ts

@@ -0,0 +1,442 @@
+import { Type, Static } from '@sinclair/typebox'
+import { MoneySchema, LengthSchema, WeightSchema, AreaSchema } from '../../measure'
+import {
+  BaseServiceDefinitionSchema,
+  BaseServiceDefinitionUpdateSchema
+} from '../../service'
+import { PSLAccessibleSchema } from '../psl'
+import { PricingRuleSchema } from '../pricing'
+import { TerminalPerformanceSchema } from './performance'
+import { PassthroughOrderProcessSchema } from '../order/flow/processes'
+
+// Terminal Partition Schemas - Terminal-specific spatial organization
+
+// Terminal Zone Schema - Major operational areas within a terminal
+export const TerminalZoneSchema = Type.Object({
+  type: Type.Literal('ZONE'),
+  zoneType: Type.Union([
+    Type.Literal('CONTAINER_YARD'),
+    Type.Literal('WAREHOUSE'),
+    Type.Literal('BERTH_AREA'),
+    Type.Literal('GATE_AREA'),
+    Type.Literal('RAIL_YARD'),
+    Type.Literal('TRUCK_STAGING'),
+    Type.Literal('STORAGE_AREA'),
+    Type.Literal('MAINTENANCE_AREA'),
+    Type.Literal('ADMINISTRATIVE_AREA'),
+    Type.Literal('CUSTOMS_AREA'),
+    Type.Literal('QUARANTINE_AREA'),
+    Type.Literal('HAZMAT_AREA'),
+    Type.Literal('REFRIGERATED_AREA'),
+    Type.Literal('EMPTY_CONTAINER_DEPOT')
+  ]),
+  parentId: Type.String({ description: 'Must belong to a terminal' }),
+  name: Type.String({ minLength: 1, maxLength: 100 }),
+  
+  // Terminal zone specific properties
+  securityLevel: Type.Union([
+    Type.Literal('PUBLIC'),
+    Type.Literal('RESTRICTED'),
+    Type.Literal('SECURE'),
+    Type.Literal('STERILE')
+  ]),
+  accessControl: Type.Boolean(),
+  customsBonded: Type.Boolean(),
+  climateControlled: Type.Boolean(),
+  
+  // Operational properties
+  operatingHours: Type.Object({
+    start: Type.String({ description: 'HH:MM format' }),
+    end: Type.String({ description: 'HH:MM format' }),
+    twentyFourSeven: Type.Boolean()
+  }),
+  
+  // Handling methods for this zone
+  handlingMethod: Type.Optional(Type.Union([
+    Type.Literal('AUTOMATED'),
+    Type.Literal('SEMI_AUTOMATED'),
+    Type.Literal('MANUAL'),
+    Type.Literal('MIXED')
+  ])),
+  
+  // Storage method for storage zones
+  storageMethod: Type.Optional(Type.Union([
+    Type.Literal('STACKING'),
+    Type.Literal('RACKING'),
+    Type.Literal('GROUND_STORAGE'),
+    Type.Literal('BULK_STORAGE'),
+    Type.Literal('SPECIALIZED')
+  ]))
+})
+
+// Terminal Block Schema - Sub-divisions within zones (e.g., container yard blocks)
+export const TerminalBlockSchema = Type.Object({
+  type: Type.Literal('BLOCK'),
+  parentId: Type.String({ description: 'Must belong to a zone' }),
+  blockNumber: Type.String({ description: 'Block identifier (e.g., A1, B2)' }),
+  
+  // Physical properties
+  dimensions: Type.Object({
+    length: LengthSchema,
+    width: LengthSchema,
+    area: AreaSchema
+  }),
+  
+  // Access and equipment
+  craneAccess: Type.Boolean(),
+  truckAccess: Type.Boolean(),
+  railAccess: Type.Boolean(),
+  equipmentAccess: Type.Array(PSLAccessibleSchema),
+  
+  // Container yard specific properties
+  stackingHeight: Type.Optional(Type.Number({ 
+    minimum: 1, 
+    maximum: 8,
+    description: 'Maximum container stacking height'
+  })),
+  
+  // Cargo type restrictions
+  cargoTypes: Type.Array(Type.Union([
+    Type.Literal('DRY_CONTAINER'),
+    Type.Literal('REFRIGERATED_CONTAINER'),
+    Type.Literal('TANK_CONTAINER'),
+    Type.Literal('FLAT_RACK'),
+    Type.Literal('OPEN_TOP'),
+    Type.Literal('BREAK_BULK'),
+    Type.Literal('BULK_CARGO'),
+    Type.Literal('PROJECT_CARGO'),
+    Type.Literal('HAZMAT'),
+    Type.Literal('EMPTY_CONTAINERS')
+  ])),
+  
+  // Operational properties
+  trafficDirection: Type.Union([
+    Type.Literal('ONE_WAY'),
+    Type.Literal('TWO_WAY'),
+    Type.Literal('CIRCULAR')
+  ]),
+  
+  priorityLevel: Type.Union([
+    Type.Literal('HIGH'),
+    Type.Literal('MEDIUM'),
+    Type.Literal('LOW')
+  ]),
+  
+  maxDwellTime: Type.Optional(Type.Number({ 
+    minimum: 0,
+    description: 'Maximum allowed dwell time in hours'
+  }))
+})
+
+// Terminal Row Schema - Rows within blocks for systematic organization
+export const TerminalRowSchema = Type.Object({
+  type: Type.Literal('ROW'),
+  parentId: Type.String({ description: 'Must belong to a block' }),
+  rowNumber: Type.Number({ minimum: 1 }),
+  
+  // Physical properties
+  length: LengthSchema,
+  width: LengthSchema,
+  surfaceType: Type.Union([
+    Type.Literal('CONCRETE'),
+    Type.Literal('ASPHALT'),
+    Type.Literal('GRAVEL'),
+    Type.Literal('DIRT'),
+    Type.Literal('STEEL_PLATFORM')
+  ]),
+  
+  // Equipment and access
+  craneRail: Type.Boolean(),
+  lighting: Type.Boolean(),
+  powerAvailable: Type.Boolean(),
+  drainageSystem: Type.Boolean(),
+  
+  // Operational configuration
+  stackingPattern: Type.Union([
+    Type.Literal('SINGLE_DEEP'),
+    Type.Literal('DOUBLE_DEEP'),
+    Type.Literal('MULTIPLE_DEEP')
+  ]),
+  
+  operationalStatus: Type.Union([
+    Type.Literal('ACTIVE'),
+    Type.Literal('MAINTENANCE'),
+    Type.Literal('RESERVED'),
+    Type.Literal('OUT_OF_SERVICE')
+  ])
+})
+
+// Terminal Position Schema - Individual storage/handling positions
+export const TerminalPositionSchema = Type.Object({
+  type: Type.Literal('POSITION'),
+  parentId: Type.String({ description: 'Must belong to a row' }),
+  positionNumber: Type.Number({ minimum: 1 }),
+  
+  // Physical specifications
+  maxWeight: WeightSchema,
+  maxHeight: LengthSchema,
+  groundBearing: WeightSchema,
+  
+  // Current status
+  occupied: Type.Boolean(),
+  reserved: Type.Boolean(),
+  damaged: Type.Boolean(),
+  
+  // Current cargo information
+  currentCargo: Type.Optional(Type.Object({
+    cargoId: Type.String(),
+    cargoType: Type.String(),
+    weight: WeightSchema,
+    arrivalTime: Type.Number(),
+    plannedDeparture: Type.Optional(Type.Number()),
+    vesselId: Type.Optional(Type.String()),
+    bookingReference: Type.Optional(Type.String())
+  })),
+  
+  // Special features
+  powerConnection: Type.Boolean(),
+  dataConnection: Type.Boolean(),
+  monitoringEquipment: Type.Boolean(),
+  
+  // Maintenance and inspection
+  lastInspection: Type.Optional(Type.Number()),
+  nextMaintenanceDue: Type.Optional(Type.Number()),
+  conditionRating: Type.Number({ 
+    minimum: 0, 
+    maximum: 10,
+    description: 'Position condition rating'
+  })
+})
+
+// Terminal Berth Schema - Vessel berthing positions
+export const TerminalBerthSchema = Type.Object({
+  type: Type.Literal('BERTH'),
+  parentId: Type.String({ description: 'Must belong to a berth zone' }),
+  berthNumber: Type.String(),
+  
+  // Physical specifications
+  length: LengthSchema,
+  depth: LengthSchema,
+  maxVesselLength: LengthSchema,
+  maxVesselBeam: LengthSchema,
+  maxDraft: LengthSchema,
+  maxDeadweight: WeightSchema,
+  maxTEU: Type.Number({ minimum: 0 }),
+  
+  // Infrastructure
+  cranes: Type.Array(Type.Object({
+    craneId: Type.String(),
+    craneType: Type.Union([
+      Type.Literal('SHIP_TO_SHORE'),
+      Type.Literal('MOBILE_HARBOR'),
+      Type.Literal('GANTRY'),
+      Type.Literal('BULK_HANDLER')
+    ]),
+    maxReach: LengthSchema,
+    maxLift: WeightSchema,
+    available: Type.Boolean()
+  })),
+  
+  // Services available
+  services: Type.Object({
+    freshWater: Type.Boolean(),
+    fuelBunkering: Type.Boolean(),
+    shorePower: Type.Boolean(),
+    wasteReception: Type.Boolean(),
+    provisions: Type.Boolean(),
+    pilotage: Type.Boolean(),
+    tugAssistance: Type.Boolean(),
+    linesmen: Type.Boolean()
+  }),
+  
+  // Current occupation
+  currentVessel: Type.Optional(Type.Object({
+    vesselId: Type.String(),
+    vesselName: Type.String(),
+    arrivalTime: Type.Number(),
+    plannedDeparture: Type.Number(),
+    operationType: Type.Union([
+      Type.Literal('LOADING'),
+      Type.Literal('DISCHARGING'),
+      Type.Literal('BOTH'),
+      Type.Literal('MAINTENANCE'),
+      Type.Literal('WAITING')
+    ])
+  })),
+  
+  // Operational status
+  operationalStatus: Type.Union([
+    Type.Literal('AVAILABLE'),
+    Type.Literal('OCCUPIED'),
+    Type.Literal('RESERVED'),
+    Type.Literal('MAINTENANCE'),
+    Type.Literal('OUT_OF_SERVICE')
+  ]),
+  
+  // Environmental conditions
+  tidalRange: LengthSchema,
+  currentVelocity: Type.Number({ minimum: 0, description: 'knots' }),
+  windExposure: Type.Union([
+    Type.Literal('SHELTERED'),
+    Type.Literal('MODERATE'),
+    Type.Literal('EXPOSED')
+  ])
+})
+
+// Terminal Pricing Rule Schema
+export const TerminalPricingRuleSchema = Type.Composite([
+  PricingRuleSchema,
+  Type.Object({
+    process: PassthroughOrderProcessSchema,
+    
+    // Terminal-specific pricing factors
+    vesselSize: Type.Optional(Type.Object({
+      minTEU: Type.Number({ minimum: 0 }),
+      maxTEU: Type.Number({ minimum: 0 }),
+      priceMultiplier: Type.Number({ minimum: 0 })
+    })),
+    
+    cargoType: Type.Optional(Type.Union([
+      Type.Literal('CONTAINER'),
+      Type.Literal('BULK'),
+      Type.Literal('BREAK_BULK'),
+      Type.Literal('RO_RO'),
+      Type.Literal('PROJECT_CARGO'),
+      Type.Literal('HAZMAT')
+    ])),
+    
+    serviceType: Type.Optional(Type.Union([
+      Type.Literal('LOADING'),
+      Type.Literal('DISCHARGING'),
+      Type.Literal('STORAGE'),
+      Type.Literal('TRANSSHIPMENT'),
+      Type.Literal('CUSTOMS_CLEARANCE'),
+      Type.Literal('INSPECTION')
+    ])),
+    
+    dwellTime: Type.Optional(Type.Object({
+      freeTime: Type.Number({ minimum: 0, description: 'hours' }),
+      demurrageRate: MoneySchema,
+      storageRate: MoneySchema
+    }))
+  })
+])
+
+// Terminal Type Schema - Different categories of marine terminals
+export const TerminalTypeSchema = Type.Union([
+  Type.Literal('CONTAINER'),        // Container terminal
+  Type.Literal('BULK_DRY'),        // Dry bulk terminal (coal, grain, ore)
+  Type.Literal('BULK_LIQUID'),     // Liquid bulk terminal (oil, chemicals)
+  Type.Literal('GENERAL_CARGO'),   // General/break-bulk cargo terminal  
+  Type.Literal('MULTIPURPOSE'),    // Multi-purpose terminal
+  Type.Literal('RO_RO'),          // Roll-on/Roll-off terminal
+  Type.Literal('CRUISE'),         // Passenger/cruise terminal
+  Type.Literal('FERRY'),          // Ferry terminal
+  Type.Literal('FISHING'),        // Fishing port terminal
+  Type.Literal('NAVAL'),          // Naval/military terminal
+  Type.Literal('INDUSTRIAL'),     // Industrial port terminal
+  Type.Literal('INTERMODAL'),     // Intermodal freight terminal
+  Type.Literal('OFFSHORE')        // Offshore support terminal
+])
+
+// Main Terminal Schema
+export const TerminalSchema = Type.Composite([
+  BaseServiceDefinitionSchema,
+  Type.Object({
+    type: TerminalTypeSchema,
+    
+    // Terminal capability, Capacity, Operation coverage
+    capabilities: Type.Array(Type.String()), // Capability Composite IDs
+    capacities: Type.Array(Type.String()), // Capacity Composite IDs
+    coverage: Type.Array(Type.String()), // Coverage segment IDs
+    pricing: Type.Array(Type.String()), // Pricing rules IDs
+
+    // Terminal-specific properties
+    portCode: Type.String({ description: 'UN/LOCODE port identifier' }),
+    terminalCode: Type.String({ description: 'Terminal identifier within port' }),
+    
+    // Physical characteristics
+    waterDepth: LengthSchema,
+    totalArea: AreaSchema,
+    numberOfBerths: Type.Number({ minimum: 0 }),
+    maxVesselSize: Type.Object({
+      length: LengthSchema,
+      beam: LengthSchema,
+      draft: LengthSchema,
+      deadweight: WeightSchema
+    }),
+    
+    // Operational characteristics
+    operatingHours: Type.Object({
+      vesselOperations: Type.String({ description: '24/7 or specific hours' }),
+      gateOperations: Type.String({ description: 'Gate operating hours' }),
+      customsOperations: Type.String({ description: 'Customs operating hours' })
+    }),
+    
+    // Services offered
+    services: Type.Array(Type.Union([
+      Type.Literal('VESSEL_BERTHING'),
+      Type.Literal('CARGO_HANDLING'),
+      Type.Literal('STORAGE'),
+      Type.Literal('CUSTOMS_CLEARANCE'),
+      Type.Literal('INSPECTION'),
+      Type.Literal('QUARANTINE'),
+      Type.Literal('PILOTAGE'),
+      Type.Literal('TUGBOAT'),
+      Type.Literal('BUNKERING'),
+      Type.Literal('FRESH_WATER'),
+      Type.Literal('WASTE_DISPOSAL'),
+      Type.Literal('SHIP_REPAIR'),
+      Type.Literal('CREW_CHANGE'),
+      Type.Literal('PROVISIONS')
+    ])),
+    
+    // Certifications and compliance
+    certifications: Type.Array(Type.Union([
+      Type.Literal('ISPS_COMPLIANT'),
+      Type.Literal('ISO_9001'),
+      Type.Literal('ISO_14001'),
+      Type.Literal('C_TPAT'),
+      Type.Literal('AEO'),
+      Type.Literal('CUSTOMS_BONDED'),
+      Type.Literal('FREE_ZONE'),
+      Type.Literal('HAZMAT_CERTIFIED')
+    ])),
+
+    // Performance metrics
+    performance: Type.Optional(TerminalPerformanceSchema)
+  })
+])
+
+export const TerminalUpdateSchema = Type.Composite([
+  BaseServiceDefinitionUpdateSchema,
+  Type.Object({
+    type: Type.Optional(TerminalTypeSchema)
+  })
+])
+
+// TypeScript type exports
+export type TerminalZone = Static<typeof TerminalZoneSchema>
+export type TerminalBlock = Static<typeof TerminalBlockSchema>
+export type TerminalRow = Static<typeof TerminalRowSchema>
+export type TerminalPosition = Static<typeof TerminalPositionSchema>
+export type TerminalBerth = Static<typeof TerminalBerthSchema>
+export type TerminalPricingRule = Static<typeof TerminalPricingRuleSchema>
+export type TerminalType = Static<typeof TerminalTypeSchema>
+export type Terminal = Static<typeof TerminalSchema>
+export type TerminalUpdate = Static<typeof TerminalUpdateSchema>
+
+// Re-export all terminal capability schemas and types
+export * from './capabilities'
+
+// Re-export all terminal capacity schemas and types
+export * from './capacities'
+
+// Re-export all terminal performance schemas and types
+export * from './performance'
+
+// Re-export all terminal analytics schemas and types
+export * from './analytics'
+
+// Re-export all terminal utilities schemas and types
+export * from './utilities'

package/src/lsp/terminal/performance.ts

@@ -0,0 +1,168 @@
+import { Type, Static } from '@sinclair/typebox'
+import { DurationSchema } from '../../time'
+import { MoneySchema } from '../../measure'
+import { SPPerformanceSummarySchema } from '../../context'
+
+// Current performance metrics for terminals
+export const TerminalCurrentPerformanceSchema = Type.Object({
+  vesselPerformance: Type.Object({
+    vesselTurnaroundTime: DurationSchema,
+    berthProductivity: Type.Number({ minimum: 0, description: 'moves per hour' }),
+    berthOccupancy: Type.Number({ minimum: 0, maximum: 100 }),
+    vesselWaitingTime: DurationSchema,
+    onTimeVesselDeparture: Type.Number({ minimum: 0, maximum: 100 })
+  }),
+  cargoPerformance: Type.Object({
+    dailyThroughput: Type.Number({ minimum: 0 }),
+    hourlyThroughput: Type.Number({ minimum: 0 }),
+    craneProductivity: Type.Number({ minimum: 0, description: 'moves per hour' }),
+    yardProductivity: Type.Number({ minimum: 0, description: 'moves per hour' }),
+    overallUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+    dwellTime: DurationSchema
+  }),
+  gatePerformance: Type.Object({
+    truckTurnaroundTime: DurationSchema,
+    gateProductivity: Type.Number({ minimum: 0, description: 'trucks per hour' }),
+    appointmentCompliance: Type.Number({ minimum: 0, maximum: 100 }),
+    gateUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+    averageWaitTime: DurationSchema
+  }),
+  systemPerformance: Type.Object({
+    systemUptime: Type.Number({ minimum: 0, maximum: 100 }),
+    equipmentAvailability: Type.Number({ minimum: 0, maximum: 100 }),
+    automationLevel: Type.Number({ minimum: 0, maximum: 100 }),
+    digitalIntegration: Type.Number({ minimum: 0, maximum: 100 }),
+    dataAccuracy: Type.Number({ minimum: 0, maximum: 100 })
+  })
+})
+
+// Peak performance metrics for terminals
+export const TerminalPeakPerformanceSchema = Type.Object({
+  peakThroughput: Type.Object({
+    peakDailyThroughput: Type.Number({ minimum: 0 }),
+    peakHourlyThroughput: Type.Number({ minimum: 0 }),
+    peakVesselHandling: Type.Number({ minimum: 0, description: 'vessels per day' }),
+    peakCranePerformance: Type.Number({ minimum: 0, description: 'moves per hour' }),
+    peakGatePerformance: Type.Number({ minimum: 0, description: 'trucks per hour' })
+  }),
+  peakUtilization: Type.Object({
+    peakBerthUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+    peakYardUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+    peakEquipmentUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+    peakStorageUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+    peakStaffUtilization: Type.Number({ minimum: 0, maximum: 100 })
+  }),
+  peakCapacity: Type.Object({
+    peakCapacityMultiplier: Type.Number({ minimum: 1 }),
+    sustainablePeakDuration: DurationSchema,
+    peakSeasonCapacity: Type.Number({ minimum: 0, maximum: 200 }),
+    lastPeakDate: Type.Optional(Type.Number()),
+    peakTriggerThreshold: Type.Number({ minimum: 0, maximum: 100 })
+  })
+})
+
+// Quality and accuracy metrics for terminals
+export const TerminalQualityPerformanceSchema = Type.Object({
+  cargoAccuracy: Type.Object({
+    overallAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+    loadingAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+    dischargingAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+    documentationAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+    inventoryAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+    damageRate: Type.Number({ minimum: 0, maximum: 100 }),
+    lossRate: Type.Number({ minimum: 0, maximum: 100 })
+  }),
+  operationalQuality: Type.Object({
+    vesselHandlingAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+    equipmentReliability: Type.Number({ minimum: 0, maximum: 100 }),
+    systemReliability: Type.Number({ minimum: 0, maximum: 100 }),
+    safetyPerformance: Type.Number({ minimum: 0, maximum: 100 }),
+    environmentalCompliance: Type.Number({ minimum: 0, maximum: 100 }),
+    customerSatisfaction: Type.Number({ minimum: 0, maximum: 100 })
+  }),
+  serviceQuality: Type.Object({
+    serviceReliability: Type.Number({ minimum: 0, maximum: 100 }),
+    responseTime: DurationSchema,
+    issueResolutionTime: DurationSchema,
+    communicationEffectiveness: Type.Number({ minimum: 0, maximum: 100 }),
+    proactiveServiceLevel: Type.Number({ minimum: 0, maximum: 100 })
+  })
+})
+
+// Time-based performance for terminals
+export const TerminalTimingPerformanceSchema = Type.Object({
+  vesselTiming: Type.Object({
+    averageVesselTurnaroundTime: DurationSchema,
+    minVesselTurnaroundTime: DurationSchema,
+    maxVesselTurnaroundTime: DurationSchema,
+    vesselPunctuality: Type.Number({ minimum: 0, maximum: 100 }),
+    berthAllocationTime: DurationSchema,
+    pilotageWaitTime: DurationSchema
+  }),
+  cargoTiming: Type.Object({
+    averageCargoHandlingTime: DurationSchema,
+    containerDwellTime: DurationSchema,
+    customsClearanceTime: DurationSchema,
+    documentProcessingTime: DurationSchema,
+    cargoReleaseTime: DurationSchema,
+    storageProcessingTime: DurationSchema
+  }),
+  gateTiming: Type.Object({
+    averageTruckTurnaroundTime: DurationSchema,
+    gateProcessingTime: DurationSchema,
+    appointmentPunctuality: Type.Number({ minimum: 0, maximum: 100 }),
+    peakHourPerformance: Type.Number({ minimum: 0, maximum: 100 }),
+    offPeakPerformance: Type.Number({ minimum: 0, maximum: 100 })
+  }),
+  slaCompliance: Type.Object({
+    overallSlaCompliance: Type.Number({ minimum: 0, maximum: 100 }),
+    vesselSlaCompliance: Type.Number({ minimum: 0, maximum: 100 }),
+    cargoSlaCompliance: Type.Number({ minimum: 0, maximum: 100 }),
+    customsSlaCompliance: Type.Number({ minimum: 0, maximum: 100 }),
+    documentSlaCompliance: Type.Number({ minimum: 0, maximum: 100 })
+  })
+})
+
+// Cost performance for terminals
+export const TerminalCostPerformanceSchema = Type.Object({
+  handlingCosts: Type.Object({
+    costPerTEU: MoneySchema,
+    costPerTon: MoneySchema,
+    costPerVessel: MoneySchema,
+    costPerMove: MoneySchema,
+    costPerSquareMeter: MoneySchema
+  }),
+  operationalCosts: Type.Object({
+    laborCostPerHour: MoneySchema,
+    equipmentCostPerHour: MoneySchema,
+    energyCostPerTEU: MoneySchema,
+    maintenanceCostPerTEU: MoneySchema,
+    totalOperatingCost: MoneySchema
+  }),
+  efficiency: Type.Object({
+    costEfficiency: Type.Number({ minimum: 0, maximum: 100 }),
+    productivityPerDollar: Type.Number({ minimum: 0 }),
+    revenuePerSquareMeter: MoneySchema,
+    profitMargin: Type.Number({ minimum: 0, maximum: 100 }),
+    returnOnAssets: Type.Number({ minimum: 0, maximum: 100 })
+  })
+})
+
+// Combined terminal performance schema
+export const TerminalPerformanceSchema = Type.Object({
+  summary: SPPerformanceSummarySchema,
+  metrics: Type.Object({
+    current: TerminalCurrentPerformanceSchema,
+    peak: TerminalPeakPerformanceSchema,
+    quality: TerminalQualityPerformanceSchema,
+    timing: TerminalTimingPerformanceSchema,
+    costs: Type.Optional(TerminalCostPerformanceSchema)
+  })
+})
+
+export type TerminalCurrentPerformance = Static<typeof TerminalCurrentPerformanceSchema>
+export type TerminalPeakPerformance = Static<typeof TerminalPeakPerformanceSchema>
+export type TerminalQualityPerformance = Static<typeof TerminalQualityPerformanceSchema>
+export type TerminalTimingPerformance = Static<typeof TerminalTimingPerformanceSchema>
+export type TerminalCostPerformance = Static<typeof TerminalCostPerformanceSchema>
+export type TerminalPerformance = Static<typeof TerminalPerformanceSchema>