@de./types 1.0.0

package/src/lsp/warehouse/utilities.ts

@@ -0,0 +1,634 @@
+import { Type, Static } from '@sinclair/typebox'
+import { DurationSchema } from '../../time'
+import { MoneySchema, PerTimeSchema, AreaSchema, VolumeSchema, WeightSchema, DistanceSchema, PerAreaSchema } from '../../measure'
+import { WarehouseCapabilitiesSchema } from './capabilities'
+import { WarehouseCapacitySchema } from './capacities'
+
+// Enhanced warehouse matching and selection schema
+export const WarehouseMatchingCriteriaSchema = Type.Object({
+  requiredCapabilities: Type.Partial(WarehouseCapabilitiesSchema),
+  requiredCapacity: Type.Partial(WarehouseCapacitySchema),
+  
+  serviceRequirements: Type.Object({
+    serviceLevels: Type.Array(Type.Union([
+      Type.Literal('SAME_DAY'),
+      Type.Literal('NEXT_DAY'),
+      Type.Literal('STANDARD'),
+      Type.Literal('ECONOMY')
+    ])),
+    minimumThroughput: Type.Number({ minimum: 0 }),
+    maximumProcessingTime: Type.Number({ minimum: 0 }),
+    minimumAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+    minimumUptime: Type.Number({ minimum: 0, maximum: 100 }),
+    geographicCoverage: Type.Array(Type.String())
+  }),
+  
+  technologyRequirements: Type.Optional(Type.Object({
+    requiredIntegrations: Type.Array(Type.String()),
+    apiRequirements: Type.Boolean(),
+    realTimeTracking: Type.Boolean(),
+    automationLevel: Type.Optional(Type.Union([
+      Type.Literal('MANUAL'),
+      Type.Literal('SEMI_AUTOMATED'),
+      Type.Literal('FULLY_AUTOMATED'),
+      Type.Literal('AI_OPTIMIZED')
+    ])),
+    dataAnalytics: Type.Boolean(),
+    cloudIntegration: Type.Boolean(),
+    mobileAccess: Type.Boolean()
+  })),
+  
+  complianceRequirements: Type.Optional(Type.Object({
+    requiredCertifications: Type.Array(Type.String()),
+    securityLevel: Type.Union([
+      Type.Literal('BASIC'),
+      Type.Literal('ENHANCED'),
+      Type.Literal('HIGH_SECURITY'),
+      Type.Literal('MAXIMUM_SECURITY')
+    ]),
+    hazmatHandling: Type.Boolean(),
+    temperatureControl: Type.Boolean(),
+    customsBonded: Type.Boolean(),
+    dataCompliance: Type.Array(Type.String())
+  })),
+  
+  performanceRequirements: Type.Optional(Type.Object({
+    minimumAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+    minimumUptime: Type.Number({ minimum: 0, maximum: 100 }),
+    maximumCycleTime: Type.Number({ minimum: 0 }),
+    minimumThroughput: Type.Number({ minimum: 0 }),
+    minimumEfficiency: Type.Number({ minimum: 0, maximum: 100 }),
+    maximumErrorRate: Type.Number({ minimum: 0, maximum: 100 }),
+    minimumCustomerSatisfaction: Type.Number({ minimum: 0, maximum: 100 })
+  })),
+  
+  locationRequirements: Type.Optional(Type.Object({
+    preferredRegions: Type.Array(Type.String()),
+    maxDistanceFromOrigin: DistanceSchema,
+    accessibilityRequirements: Type.Array(Type.String()),
+    timeZonePreference: Type.Optional(Type.String()),
+    proximityToAirports: DistanceSchema,
+    proximityToSeaports: DistanceSchema,
+    railAccess: Type.Boolean(),
+    highwayAccess: Type.Boolean()
+  })),
+  
+  weightings: Type.Optional(Type.Object({
+    capabilities: Type.Number({ minimum: 0, maximum: 100 }),
+    capacity: Type.Number({ minimum: 0, maximum: 100 }),
+    performance: Type.Number({ minimum: 0, maximum: 100 }),
+    cost: Type.Number({ minimum: 0, maximum: 100 }),
+    location: Type.Number({ minimum: 0, maximum: 100 }),
+    technology: Type.Number({ minimum: 0, maximum: 100 }),
+    compliance: Type.Number({ minimum: 0, maximum: 100 }),
+    sustainability: Type.Number({ minimum: 0, maximum: 100 })
+  })),
+  
+  mustHave: Type.Optional(Type.Array(Type.String())),
+  niceToHave: Type.Optional(Type.Array(Type.String())),
+  dealBreakers: Type.Optional(Type.Array(Type.String())),
+  
+  budgetConstraints: Type.Optional(Type.Object({
+    maxStorageCost: MoneySchema,
+    maxHandlingCost: MoneySchema,
+    maxTotalCost: MoneySchema,
+    costModel: Type.Union([
+      Type.Literal('FIXED'),
+      Type.Literal('VARIABLE'),
+      Type.Literal('HYBRID'),
+      Type.Literal('PERFORMANCE_BASED')
+    ]),
+    paymentTerms: Type.Optional(Type.String()),
+    volumeCommitments: Type.Optional(Type.Object({
+      minimumVolume: Type.Number({ minimum: 0 }),
+      commitmentPeriod: DurationSchema
+    }))
+  })),
+  
+  riskPreferences: Type.Optional(Type.Object({
+    riskTolerance: Type.Union([
+      Type.Literal('LOW'),
+      Type.Literal('MEDIUM'),
+      Type.Literal('HIGH')
+    ]),
+    redundancyRequirement: Type.Boolean(),
+    backupWarehouseRequired: Type.Boolean(),
+    businessContinuityRequirement: Type.Boolean(),
+    insuranceRequirements: Type.Optional(Type.Object({
+      minimumCoverage: MoneySchema,
+      liabilityRequirements: Type.Array(Type.String())
+    }))
+  }))
+})
+
+// Warehouse optimization schema
+export const WarehouseOptimizationSchema = Type.Object({
+  warehouseId: Type.String(),
+  optimizationDate: Type.Number(),
+  optimizationType: Type.Union([
+    Type.Literal('LAYOUT_OPTIMIZATION'),
+    Type.Literal('PROCESS_OPTIMIZATION'),
+    Type.Literal('CAPACITY_OPTIMIZATION'),
+    Type.Literal('COST_OPTIMIZATION'),
+    Type.Literal('MULTI_OBJECTIVE')
+  ]),
+  
+  currentState: Type.Object({
+    layout: Type.Object({
+      totalArea: AreaSchema,
+      storageEfficiency: Type.Number({ minimum: 0, maximum: 100 }),
+      pickingEfficiency: Type.Number({ minimum: 0, maximum: 100 }),
+      trafficFlow: Type.Number({ minimum: 0, maximum: 100 }),
+      spaceUtilization: Type.Number({ minimum: 0, maximum: 100 })
+    }),
+    operations: Type.Object({
+      throughput: Type.Number({ minimum: 0 }),
+      accuracy: Type.Number({ minimum: 0, maximum: 100 }),
+      cycleTime: Type.Number({ minimum: 0 }),
+      costPerOrder: MoneySchema,
+      laborEfficiency: Type.Number({ minimum: 0, maximum: 100 })
+    }),
+    resources: Type.Object({
+      equipmentUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+      staffUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+      systemPerformance: Type.Number({ minimum: 0, maximum: 100 })
+    })
+  }),
+  
+  constraints: Type.Object({
+    maxBudget: Type.Optional(MoneySchema),
+    maxDowntime: Type.Optional(DurationSchema),
+    minServiceLevel: Type.Optional(Type.Number({ minimum: 0, maximum: 100 })),
+    requiredCertifications: Type.Optional(Type.Array(Type.String())),
+    physicalLimitations: Type.Optional(Type.Array(Type.String())),
+    stakeholderRequirements: Type.Optional(Type.Array(Type.String()))
+  }),
+  
+  objectives: Type.Object({
+    primary: Type.Union([
+      Type.Literal('MAXIMIZE_THROUGHPUT'),
+      Type.Literal('MINIMIZE_COST'),
+      Type.Literal('MAXIMIZE_ACCURACY'),
+      Type.Literal('MINIMIZE_CYCLE_TIME'),
+      Type.Literal('MAXIMIZE_SPACE_UTILIZATION'),
+      Type.Literal('MINIMIZE_ENVIRONMENTAL_IMPACT')
+    ]),
+    secondary: Type.Optional(Type.Array(Type.Union([
+      Type.Literal('MAXIMIZE_THROUGHPUT'),
+      Type.Literal('MINIMIZE_COST'),
+      Type.Literal('MAXIMIZE_ACCURACY'),
+      Type.Literal('MINIMIZE_CYCLE_TIME'),
+      Type.Literal('MAXIMIZE_SPACE_UTILIZATION'),
+      Type.Literal('MINIMIZE_ENVIRONMENTAL_IMPACT')
+    ]))),
+    weights: Type.Optional(Type.Object({
+      throughput: Type.Number({ minimum: 0, maximum: 100 }),
+      cost: Type.Number({ minimum: 0, maximum: 100 }),
+      accuracy: Type.Number({ minimum: 0, maximum: 100 }),
+      time: Type.Number({ minimum: 0, maximum: 100 }),
+      spaceUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+      environmentalImpact: Type.Number({ minimum: 0, maximum: 100 })
+    }))
+  }),
+  
+  optimizedSolution: Type.Object({
+    layout: Type.Object({
+      recommendedChanges: Type.Array(Type.String()),
+      newStorageEfficiency: Type.Number({ minimum: 0, maximum: 100 }),
+      newPickingEfficiency: Type.Number({ minimum: 0, maximum: 100 }),
+      newTrafficFlow: Type.Number({ minimum: 0, maximum: 100 }),
+      newSpaceUtilization: Type.Number({ minimum: 0, maximum: 100 })
+    }),
+    operations: Type.Object({
+      projectedThroughput: Type.Number({ minimum: 0 }),
+      projectedAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+      projectedCycleTime: Type.Number({ minimum: 0 }),
+      projectedCostPerOrder: MoneySchema,
+      projectedLaborEfficiency: Type.Number({ minimum: 0, maximum: 100 })
+    }),
+    resources: Type.Object({
+      recommendedEquipment: Type.Array(Type.String()),
+      recommendedStaffing: Type.Number({ minimum: 0 }),
+      recommendedTechnology: Type.Array(Type.String())
+    })
+  }),
+  
+  results: Type.Object({
+    improvementMetrics: Type.Object({
+      throughputIncrease: Type.Optional(Type.Number({ description: 'percentage' })),
+      costReduction: Type.Optional(MoneySchema),
+      accuracyImprovement: Type.Optional(Type.Number({ description: 'percentage' })),
+      timeReduction: Type.Optional(Type.Number({ description: 'percentage' })),
+      spaceEfficiencyGain: Type.Optional(Type.Number({ description: 'percentage' })),
+      environmentalImpactReduction: Type.Optional(Type.Number({ description: 'percentage' }))
+    }),
+    roi: Type.Optional(Type.Number({ description: 'percentage' })),
+    paybackPeriod: Type.Optional(DurationSchema),
+    riskAssessment: Type.Object({
+      implementationRisk: Type.Union([
+        Type.Literal('LOW'),
+        Type.Literal('MEDIUM'),
+        Type.Literal('HIGH')
+      ]),
+      operationalRisk: Type.Union([
+        Type.Literal('LOW'),
+        Type.Literal('MEDIUM'),
+        Type.Literal('HIGH')
+      ]),
+      financialRisk: Type.Union([
+        Type.Literal('LOW'),
+        Type.Literal('MEDIUM'),
+        Type.Literal('HIGH')
+      ])
+    })
+  }),
+  
+  implementation: Type.Object({
+    phases: Type.Array(Type.Object({
+      phaseNumber: Type.Number(),
+      phaseName: Type.String(),
+      description: Type.String(),
+      startDate: Type.Number(),
+      endDate: Type.Number(),
+      milestones: Type.Array(Type.Object({
+        milestone: Type.String(),
+        date: Type.Number(),
+        deliverable: Type.String()
+      })),
+      resources: Type.Object({
+        budget: MoneySchema,
+        staff: Type.Number(),
+        equipment: Type.Array(Type.String()),
+        technology: Type.Array(Type.String())
+      }),
+      risks: Type.Array(Type.Object({
+        risk: Type.String(),
+        probability: Type.Union([
+          Type.Literal('LOW'),
+          Type.Literal('MEDIUM'),
+          Type.Literal('HIGH')
+        ]),
+        impact: Type.Union([
+          Type.Literal('LOW'),
+          Type.Literal('MEDIUM'),
+          Type.Literal('HIGH')
+        ]),
+        mitigation: Type.String()
+      }))
+    })),
+    totalDuration: DurationSchema,
+    totalCost: MoneySchema,
+    criticalPath: Type.Array(Type.String()),
+    dependencies: Type.Array(Type.Object({
+      task: Type.String(),
+      dependsOn: Type.Array(Type.String()),
+      delay: Type.Number({ description: 'days if dependency not met' })
+    }))
+  })
+})
+
+// Warehouse benchmarking schema
+export const WarehouseBenchmarkingSchema = Type.Object({
+  warehouseId: Type.String(),
+  benchmarkDate: Type.Number(),
+  benchmarkType: Type.Union([
+    Type.Literal('INDUSTRY_BENCHMARK'),
+    Type.Literal('NETWORK_BENCHMARK'),
+    Type.Literal('PEER_BENCHMARK'),
+    Type.Literal('HISTORICAL_BENCHMARK')
+  ]),
+  
+  performanceComparison: Type.Object({
+    throughput: Type.Object({
+      warehouseValue: Type.Number(),
+      benchmarkValue: Type.Number(),
+      variance: Type.Number({ description: 'percentage' }),
+      percentile: Type.Number({ minimum: 0, maximum: 100 })
+    }),
+    accuracy: Type.Object({
+      warehouseValue: Type.Number({ minimum: 0, maximum: 100 }),
+      benchmarkValue: Type.Number({ minimum: 0, maximum: 100 }),
+      variance: Type.Number({ description: 'percentage points' }),
+      percentile: Type.Number({ minimum: 0, maximum: 100 })
+    }),
+    efficiency: Type.Object({
+      warehouseValue: Type.Number({ minimum: 0, maximum: 100 }),
+      benchmarkValue: Type.Number({ minimum: 0, maximum: 100 }),
+      variance: Type.Number({ description: 'percentage points' }),
+      percentile: Type.Number({ minimum: 0, maximum: 100 })
+    }),
+    cost: Type.Object({
+      warehouseValue: MoneySchema,
+      benchmarkValue: MoneySchema,
+      variance: Type.Number({ description: 'percentage' }),
+      percentile: Type.Number({ minimum: 0, maximum: 100 })
+    })
+  }),
+  
+  capabilityComparison: Type.Object({
+    automationLevel: Type.Object({
+      warehouseLevel: Type.String(),
+      benchmarkLevel: Type.String(),
+      gap: Type.String()
+    }),
+    technologyAdoption: Type.Object({
+      warehouseScore: Type.Number({ minimum: 0, maximum: 100 }),
+      benchmarkScore: Type.Number({ minimum: 0, maximum: 100 }),
+      gap: Type.Number({ description: 'percentage points' })
+    }),
+    serviceOfferings: Type.Object({
+      warehouseServices: Type.Number(),
+      benchmarkServices: Type.Number(),
+      gap: Type.Number()
+    }),
+    sustainabilityScore: Type.Object({
+      warehouseScore: Type.Number({ minimum: 0, maximum: 100 }),
+      benchmarkScore: Type.Number({ minimum: 0, maximum: 100 }),
+      gap: Type.Number({ description: 'percentage points' })
+    })
+  }),
+  
+  improvementOpportunities: Type.Array(Type.Object({
+    area: Type.String(),
+    currentGap: Type.Number(),
+    targetImprovement: Type.Number(),
+    estimatedCost: Type.Optional(MoneySchema),
+    estimatedTimeline: DurationSchema,
+    priority: Type.Union([
+      Type.Literal('LOW'),
+      Type.Literal('MEDIUM'),
+      Type.Literal('HIGH'),
+      Type.Literal('CRITICAL')
+    ])
+  })),
+  
+  bestPractices: Type.Array(Type.Object({
+    practice: Type.String(),
+    description: Type.String(),
+    implementationDifficulty: Type.Union([
+      Type.Literal('LOW'),
+      Type.Literal('MEDIUM'),
+      Type.Literal('HIGH')
+    ]),
+    expectedBenefit: Type.String(),
+    examples: Type.Array(Type.String())
+  }))
+})
+
+// Warehouse sustainability metrics schema
+export const WarehouseSustainabilitySchema = Type.Object({
+  warehouseId: Type.String(),
+  reportingPeriod: Type.Object({
+    start: Type.Number(),
+    end: Type.Number()
+  }),
+  
+  environmental: Type.Object({
+    carbonFootprint: Type.Object({
+      totalEmissions: Type.Number({ minimum: 0, description: 'tons CO2 equivalent' }),
+      emissionsPerOrder: Type.Number({ minimum: 0, description: 'kg CO2 per order' }),
+      emissionsPerSqMeter: PerAreaSchema,
+      reductionTargets: Type.Number({ description: 'percentage reduction target' }),
+      currentReduction: Type.Number({ description: 'percentage reduction achieved' })
+    }),
+    
+    energyConsumption: Type.Object({
+      totalEnergyUsed: PerTimeSchema,
+      renewableEnergyPercent: Type.Number({ minimum: 0, maximum: 100 }),
+      energyEfficiencyRating: Type.Union([
+        Type.Literal('A'),
+        Type.Literal('B'),
+        Type.Literal('C'),
+        Type.Literal('D'),
+        Type.Literal('E')
+      ]),
+      energyPerOrder: Type.Number({ minimum: 0, description: 'kWh per order' })
+    }),
+    
+    wasteManagement: Type.Object({
+      totalWasteGenerated: WeightSchema,
+      wasteRecycled: WeightSchema,
+      recyclingRate: Type.Number({ minimum: 0, maximum: 100, description: 'percentage' }),
+      wastePerOrder: Type.Number({ minimum: 0, description: 'kg per order' })
+    }),
+    
+    waterUsage: Type.Object({
+      totalWaterUsed: VolumeSchema,
+      waterConservationMeasures: Type.Array(Type.String()),
+      waterEfficiencyRating: Type.Number({ minimum: 0, maximum: 100 })
+    })
+  }),
+  
+  social: Type.Object({
+    employeeWelfare: Type.Object({
+      workplaceSafetyScore: Type.Number({ minimum: 0, maximum: 100 }),
+      employeeSatisfactionScore: Type.Number({ minimum: 0, maximum: 100 }),
+      trainingHoursPerEmployee: Type.Number({ minimum: 0 }),
+      diversityIndex: Type.Number({ minimum: 0, maximum: 100 })
+    }),
+    
+    communityImpact: Type.Object({
+      localEmployment: Type.Number({ minimum: 0, description: 'number of local employees' }),
+      communityInvestment: MoneySchema,
+      localSourcing: Type.Number({ minimum: 0, maximum: 100, description: 'percentage' })
+    })
+  }),
+  
+  governance: Type.Object({
+    complianceScore: Type.Number({ minimum: 0, maximum: 100 }),
+    auditResults: Type.Array(Type.Object({
+      auditType: Type.String(),
+      result: Type.Union([
+        Type.Literal('PASSED'),
+        Type.Literal('PASSED_WITH_CONDITIONS'),
+        Type.Literal('FAILED')
+      ]),
+      date: Type.Number(),
+      nextAudit: Type.Number()
+    })),
+    sustainabilityCertifications: Type.Array(Type.String()),
+    sustainabilityReporting: Type.Boolean()
+  }),
+  
+  targets: Type.Object({
+    carbonNeutralityTarget: Type.Optional(Type.Number({ description: 'target year' })),
+    renewableEnergyTarget: Type.Number({ minimum: 0, maximum: 100, description: 'percentage target' }),
+    wasteReductionTarget: Type.Number({ minimum: 0, maximum: 100, description: 'percentage reduction' }),
+    sustainabilityInvestment: MoneySchema
+  }),
+  
+  overallScore: Type.Number({ minimum: 0, maximum: 100 }),
+  rating: Type.Union([
+    Type.Literal('EXCELLENT'),
+    Type.Literal('GOOD'),
+    Type.Literal('FAIR'),
+    Type.Literal('POOR')
+  ]),
+  improvementRecommendations: Type.Array(Type.String())
+})
+
+// Warehouse capability assessment schema
+export const WarehouseCapabilityAssessmentSchema = Type.Object({
+  warehouseId: Type.String(),
+  assessmentDate: Type.Number(),
+  assessedBy: Type.String(),
+  capabilities: WarehouseCapabilitiesSchema,
+  
+  scores: Type.Object({
+    overall: Type.Number({ minimum: 0, maximum: 100 }),
+    storage: Type.Number({ minimum: 0, maximum: 100 }),
+    handling: Type.Number({ minimum: 0, maximum: 100 }),
+    processing: Type.Number({ minimum: 0, maximum: 100 }),
+    technology: Type.Number({ minimum: 0, maximum: 100 }),
+    compliance: Type.Number({ minimum: 0, maximum: 100 }),
+    sustainability: Type.Number({ minimum: 0, maximum: 100 }),
+    network: Type.Number({ minimum: 0, maximum: 100 })
+  }),
+  
+  recommendations: Type.Array(Type.Object({
+    category: Type.Union([
+      Type.Literal('STORAGE'),
+      Type.Literal('HANDLING'),
+      Type.Literal('PROCESSING'),
+      Type.Literal('TECHNOLOGY'),
+      Type.Literal('COMPLIANCE'),
+      Type.Literal('SUSTAINABILITY'),
+      Type.Literal('NETWORK'),
+      Type.Literal('SERVICE_LEVELS')
+    ]),
+    priority: Type.Union([
+      Type.Literal('LOW'),
+      Type.Literal('MEDIUM'),
+      Type.Literal('HIGH'),
+      Type.Literal('CRITICAL')
+    ]),
+    recommendation: Type.String(),
+    estimatedCost: Type.Optional(MoneySchema),
+    estimatedROI: Type.Optional(Type.String()),
+    timeline: Type.Optional(Type.String())
+  })),
+  
+  benchmarks: Type.Optional(Type.Object({
+    industryAverage: Type.Partial(WarehouseCapabilitiesSchema),
+    topPerformers: Type.Partial(WarehouseCapabilitiesSchema),
+    minimumStandards: Type.Partial(WarehouseCapabilitiesSchema)
+  }))
+})
+
+// Warehouse capability matching schema
+export const WarehouseCapabilityMatchingSchema = Type.Object({
+  requirements: Type.Partial(WarehouseCapabilitiesSchema),
+  weightings: Type.Optional(Type.Object({
+    storage: Type.Number({ minimum: 0, maximum: 100 }),
+    handling: Type.Number({ minimum: 0, maximum: 100 }),
+    processing: Type.Number({ minimum: 0, maximum: 100 }),
+    technology: Type.Number({ minimum: 0, maximum: 100 }),
+    compliance: Type.Number({ minimum: 0, maximum: 100 }),
+    network: Type.Number({ minimum: 0, maximum: 100 }),
+    sustainability: Type.Number({ minimum: 0, maximum: 100 })
+  })),
+  mustHave: Type.Optional(Type.Array(Type.String())),
+  niceToHave: Type.Optional(Type.Array(Type.String())),
+  dealBreakers: Type.Optional(Type.Array(Type.String()))
+})
+
+// Warehouse risk assessment schema
+export const WarehouseRiskAssessmentSchema = Type.Object({
+  warehouseId: Type.String(),
+  assessmentDate: Type.Number(),
+  assessmentType: Type.Union([
+    Type.Literal('OPERATIONAL_RISK'),
+    Type.Literal('FINANCIAL_RISK'),
+    Type.Literal('STRATEGIC_RISK'),
+    Type.Literal('COMPLIANCE_RISK'),
+    Type.Literal('COMPREHENSIVE_RISK')
+  ]),
+  
+  operationalRisks: Type.Array(Type.Object({
+    riskId: Type.String(),
+    riskCategory: Type.Union([
+      Type.Literal('EQUIPMENT_FAILURE'),
+      Type.Literal('STAFFING_SHORTAGE'),
+      Type.Literal('CAPACITY_OVERLOAD'),
+      Type.Literal('QUALITY_ISSUES'),
+      Type.Literal('SAFETY_INCIDENTS'),
+      Type.Literal('TECHNOLOGY_FAILURE'),
+      Type.Literal('SUPPLY_CHAIN_DISRUPTION'),
+      Type.Literal('WEATHER_EVENTS'),
+      Type.Literal('INVENTORY_DAMAGE'),
+      Type.Literal('FIRE_HAZARD')
+    ]),
+    description: Type.String(),
+    probability: Type.Union([
+      Type.Literal('VERY_LOW'),
+      Type.Literal('LOW'),
+      Type.Literal('MEDIUM'),
+      Type.Literal('HIGH'),
+      Type.Literal('VERY_HIGH')
+    ]),
+    impact: Type.Union([
+      Type.Literal('NEGLIGIBLE'),
+      Type.Literal('MINOR'),
+      Type.Literal('MODERATE'),
+      Type.Literal('MAJOR'),
+      Type.Literal('CATASTROPHIC')
+    ]),
+    riskScore: Type.Number({ minimum: 0, maximum: 25 }),
+    mitigationStrategies: Type.Array(Type.String()),
+    contingencyPlans: Type.Array(Type.String()),
+    responsibleParty: Type.String(),
+    lastReview: Type.Number(),
+    nextReview: Type.Number()
+  })),
+  
+  financialRisks: Type.Array(Type.Object({
+    riskId: Type.String(),
+    riskCategory: Type.Union([
+      Type.Literal('COST_OVERRUN'),
+      Type.Literal('REVENUE_SHORTFALL'),
+      Type.Literal('CURRENCY_FLUCTUATION'),
+      Type.Literal('INSURANCE_CLAIMS'),
+      Type.Literal('CAPITAL_INVESTMENT'),
+      Type.Literal('CASH_FLOW'),
+      Type.Literal('CREDIT_RISK'),
+      Type.Literal('CONTRACT_PENALTIES')
+    ]),
+    description: Type.String(),
+    probability: Type.Union([
+      Type.Literal('VERY_LOW'),
+      Type.Literal('LOW'),
+      Type.Literal('MEDIUM'),
+      Type.Literal('HIGH'),
+      Type.Literal('VERY_HIGH')
+    ]),
+    financialImpact: MoneySchema,
+    mitigationStrategies: Type.Array(Type.String()),
+    responsibleParty: Type.String()
+  })),
+  
+  overallRiskProfile: Type.Object({
+    riskRating: Type.Union([
+      Type.Literal('LOW_RISK'),
+      Type.Literal('MODERATE_RISK'),
+      Type.Literal('HIGH_RISK'),
+      Type.Literal('CRITICAL_RISK')
+    ]),
+    totalRiskScore: Type.Number({ minimum: 0, maximum: 100 }),
+    topRisks: Type.Array(Type.String()),
+    riskTrends: Type.Union([
+      Type.Literal('IMPROVING'),
+      Type.Literal('STABLE'),
+      Type.Literal('DETERIORATING')
+    ]),
+    recommendedActions: Type.Array(Type.String())
+  })
+})
+
+// TypeScript type exports
+export type WarehouseMatchingCriteria = Static<typeof WarehouseMatchingCriteriaSchema>
+export type WarehouseOptimization = Static<typeof WarehouseOptimizationSchema>
+export type WarehouseBenchmarking = Static<typeof WarehouseBenchmarkingSchema>
+export type WarehouseSustainability = Static<typeof WarehouseSustainabilitySchema>
+export type WarehouseCapabilityAssessment = Static<typeof WarehouseCapabilityAssessmentSchema>
+export type WarehouseCapabilityMatching = Static<typeof WarehouseCapabilityMatchingSchema>
+export type WarehouseRiskAssessment = Static<typeof WarehouseRiskAssessmentSchema>