@de./types 1.0.0

package/src/lsp/hub/utilities.ts

@@ -0,0 +1,560 @@
+import { Type, Static } from '@sinclair/typebox'
+import { CoverageTransitModeSchema } from '../coverage'
+import { DurationSchema } from '../../time'
+import { ServiceLevelSchema, MoneySchema } from '../../measure'
+import { HubCapabilitySchema } from './capabilities'
+import { HubCapacitySchema } from './capacities'
+
+// Hub network optimization schema
+export const HubNetworkOptimizationSchema = Type.Object({
+  networkId: Type.String(),
+  optimizationDate: Type.Number(),
+  optimizationType: Type.Union([
+    Type.Literal('COST_OPTIMIZATION'),
+    Type.Literal('TIME_OPTIMIZATION'),
+    Type.Literal('CAPACITY_OPTIMIZATION'),
+    Type.Literal('SERVICE_OPTIMIZATION'),
+    Type.Literal('MULTI_OBJECTIVE')
+  ]),
+  
+  currentNetwork: Type.Object({
+    hubs: Type.Array(Type.String()),
+    routes: Type.Array(Type.Object({
+      routeId: Type.String(),
+      originHub: Type.String(),
+      destinationHub: Type.String(),
+      transportMode: Type.String(),
+      capacity: Type.Number(),
+      utilization: Type.Number({ minimum: 0, maximum: 100 }),
+      cost: MoneySchema,
+      transitTime: Type.Number({ description: 'hours' })
+    })),
+    totalCapacity: Type.Number(),
+    totalUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+    totalCost: MoneySchema,
+    averageTransitTime: Type.Number({ description: 'hours' }),
+    serviceLevel: Type.Number({ minimum: 0, maximum: 100 })
+  }),
+  
+  constraints: Type.Object({
+    maxNetworkCost: Type.Optional(MoneySchema),
+    maxTransitTime: Type.Optional(Type.Number({ description: 'hours' })),
+    minServiceLevel: Type.Optional(Type.Number({ minimum: 0, maximum: 100 })),
+    minCapacityUtilization: Type.Optional(Type.Number({ minimum: 0, maximum: 100 })),
+    maxCapacityUtilization: Type.Optional(Type.Number({ minimum: 0, maximum: 100 })),
+    requiredHubs: Type.Optional(Type.Array(Type.String())),
+    forbiddenRoutes: Type.Optional(Type.Array(Type.String())),
+    capacityConstraints: Type.Optional(Type.Record(Type.String(), Type.Number()))
+  }),
+  
+  objectives: Type.Object({
+    primary: Type.Union([
+      Type.Literal('MINIMIZE_COST'),
+      Type.Literal('MINIMIZE_TIME'),
+      Type.Literal('MAXIMIZE_CAPACITY'),
+      Type.Literal('MAXIMIZE_SERVICE_LEVEL'),
+      Type.Literal('MINIMIZE_ENVIRONMENTAL_IMPACT')
+    ]),
+    secondary: Type.Optional(Type.Array(Type.Union([
+      Type.Literal('MINIMIZE_COST'),
+      Type.Literal('MINIMIZE_TIME'),
+      Type.Literal('MAXIMIZE_CAPACITY'),
+      Type.Literal('MAXIMIZE_SERVICE_LEVEL'),
+      Type.Literal('MINIMIZE_ENVIRONMENTAL_IMPACT')
+    ]))),
+    weights: Type.Optional(Type.Object({
+      cost: Type.Number({ minimum: 0, maximum: 100 }),
+      time: Type.Number({ minimum: 0, maximum: 100 }),
+      capacity: Type.Number({ minimum: 0, maximum: 100 }),
+      serviceLevel: Type.Number({ minimum: 0, maximum: 100 }),
+      environmentalImpact: Type.Number({ minimum: 0, maximum: 100 })
+    }))
+  }),
+  
+  optimizedNetwork: Type.Object({
+    hubs: Type.Array(Type.String()),
+    routes: Type.Array(Type.Object({
+      routeId: Type.String(),
+      originHub: Type.String(),
+      destinationHub: Type.String(),
+      transportMode: Type.String(),
+      recommendedCapacity: Type.Number(),
+      projectedUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+      estimatedCost: MoneySchema,
+      estimatedTransitTime: Type.Number({ description: 'hours' }),
+      priority: Type.Number({ minimum: 1, maximum: 10 })
+    })),
+    projectedCapacity: Type.Number(),
+    projectedUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+    projectedCost: MoneySchema,
+    projectedTransitTime: Type.Number({ description: 'hours' }),
+    projectedServiceLevel: Type.Number({ minimum: 0, maximum: 100 })
+  }),
+  
+  results: Type.Object({
+    improvementMetrics: Type.Object({
+      costReduction: Type.Optional(MoneySchema),
+      timeReduction: Type.Optional(Type.Number({ description: 'hours' })),
+      capacityIncrease: Type.Optional(Type.Number({ description: 'percentage' })),
+      serviceLevelImprovement: Type.Optional(Type.Number({ description: 'percentage' })),
+      utilizationImprovement: Type.Optional(Type.Number({ description: 'percentage' }))
+    }),
+    roi: Type.Optional(Type.Number({ description: 'percentage' })),
+    paybackPeriod: Type.Optional(Type.Number({ description: 'months' })),
+    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: Type.Number({ description: 'weeks' }),
+    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' })
+    }))
+  })
+})
+
+// Hub performance benchmarking schema
+export const HubBenchmarkingSchema = Type.Object({
+  hubId: 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({
+      hubValue: Type.Number(),
+      benchmarkValue: Type.Number(),
+      variance: Type.Number({ description: 'percentage' }),
+      percentile: Type.Number({ minimum: 0, maximum: 100 })
+    }),
+    accuracy: Type.Object({
+      hubValue: 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({
+      hubValue: 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({
+      hubValue: MoneySchema,
+      benchmarkValue: MoneySchema,
+      variance: Type.Number({ description: 'percentage' }),
+      percentile: Type.Number({ minimum: 0, maximum: 100 })
+    })
+  }),
+  
+  capabilityComparison: Type.Object({
+    automationLevel: Type.Object({
+      hubLevel: Type.String(),
+      benchmarkLevel: Type.String(),
+      gap: Type.String()
+    }),
+    technologyAdoption: Type.Object({
+      hubScore: Type.Number({ minimum: 0, maximum: 100 }),
+      benchmarkScore: Type.Number({ minimum: 0, maximum: 100 }),
+      gap: Type.Number({ description: 'percentage points' })
+    }),
+    serviceOfferings: Type.Object({
+      hubServices: Type.Number(),
+      benchmarkServices: Type.Number(),
+      gap: Type.Number()
+    })
+  }),
+  
+  improvementOpportunities: Type.Array(Type.Object({
+    area: Type.String(),
+    currentGap: Type.Number(),
+    targetImprovement: Type.Number(),
+    estimatedCost: Type.Optional(MoneySchema),
+    estimatedTimeline: Type.Number({ description: 'months' }),
+    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())
+  }))
+})
+
+// Hub sustainability metrics schema
+export const HubSustainabilitySchema = Type.Object({
+  hubId: 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' }),
+      emissionsPerPackage: Type.Number({ minimum: 0, description: 'kg CO2 per package' }),
+      emissionsPerSqMeter: Type.Number({ minimum: 0, description: 'kg CO2 per sq meter' }),
+      reductionTargets: Type.Number({ description: 'percentage reduction target' }),
+      currentReduction: Type.Number({ description: 'percentage reduction achieved' })
+    }),
+    
+    energyConsumption: Type.Object({
+      totalEnergyUsed: Type.Number({ minimum: 0, description: 'kWh' }),
+      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')
+      ]),
+      energyPerPackage: Type.Number({ minimum: 0, description: 'kWh per package' })
+    }),
+    
+    wasteManagement: Type.Object({
+      totalWasteGenerated: Type.Number({ minimum: 0, description: 'kg' }),
+      wasteRecycled: Type.Number({ minimum: 0, description: 'kg' }),
+      recyclingRate: Type.Number({ minimum: 0, maximum: 100, description: 'percentage' }),
+      wastePerPackage: Type.Number({ minimum: 0, description: 'kg per package' })
+    }),
+    
+    waterUsage: Type.Object({
+      totalWaterUsed: Type.Number({ minimum: 0, description: 'liters' }),
+      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())
+})
+
+// Hub risk assessment schema
+export const HubRiskAssessmentSchema = Type.Object({
+  hubId: 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')
+    ]),
+    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')
+    ]),
+    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())
+  })
+})
+
+// Hub matching and selection criteria
+export const HubMatchingCriteriaSchema = Type.Object({
+  requiredCapability: Type.Partial(HubCapabilitySchema),
+  requiredCapacity: Type.Partial(HubCapacitySchema),
+  
+  serviceRequirements: Type.Object({
+    serviceLevels: Type.Array(ServiceLevelSchema),
+    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())
+  }),
+  
+  networkRequirements: Type.Optional(Type.Object({
+    connectedHubs: Type.Array(Type.String()),
+    requiredRoutes: Type.Array(Type.String()),
+    transitMode: CoverageTransitModeSchema,
+    maxTransitTime: DurationSchema,
+    networkReliability: Type.Number({ minimum: 0, maximum: 100 }),
+    carrierPreferences: Type.Array(Type.String()),
+    routeOptimization: Type.Boolean()
+  })),
+  
+  performanceRequirements: Type.Optional(Type.Object({
+    minimumEfficiency: Type.Number({ minimum: 0, maximum: 100 }),
+    minimumAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+    minimumUptime: Type.Number({ minimum: 0, maximum: 100 }),
+    maximumErrorRate: Type.Number({ minimum: 0, maximum: 100 }),
+    minimumCustomerSatisfaction: Type.Number({ minimum: 0, maximum: 100 }),
+    slaRequirements: Type.Record(ServiceLevelSchema, Type.Object({
+      onTimePerformance: Type.Number({ minimum: 0, maximum: 100 }),
+      processingTime: Type.Number({ minimum: 0 }),
+      qualityStandard: Type.Number({ minimum: 0, maximum: 100 })
+    }))
+  })),
+  
+  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())
+  })),
+  
+  locationRequirements: Type.Optional(Type.Object({
+    preferredRegions: Type.Array(Type.String()),
+    maxDistanceFromOrigin: Type.Number({ minimum: 0, description: 'kilometers' }),
+    accessibilityRequirements: Type.Array(Type.String()),
+    timeZonePreference: Type.Optional(Type.String()),
+    proximityToAirports: Type.Optional(Type.Number({ description: 'kilometers' })),
+    proximityToSeaports: Type.Optional(Type.Number({ description: 'kilometers' })),
+    railAccess: Type.Boolean(),
+    highwayAccess: Type.Boolean()
+  })),
+  
+  weightings: Type.Optional(Type.Object({
+    capability: 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 }),
+    reliability: 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({
+    maxHandlingCost: MoneySchema,
+    maxServiceCost: 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: Type.Number({ minimum: 0, description: 'months' })
+    }))
+  })),
+  
+  riskPreferences: Type.Optional(Type.Object({
+    riskTolerance: Type.Union([
+      Type.Literal('LOW'),
+      Type.Literal('MEDIUM'),
+      Type.Literal('HIGH')
+    ]),
+    redundancyRequirement: Type.Boolean(),
+    backupHubRequired: Type.Boolean(),
+    businessContinuityRequirement: Type.Boolean(),
+    insuranceRequirements: Type.Optional(Type.Object({
+      minimumCoverage: MoneySchema,
+      liabilityRequirements: Type.Array(Type.String())
+    }))
+  }))
+})
+
+export type HubNetworkOptimization = Static<typeof HubNetworkOptimizationSchema>
+export type HubBenchmarking = Static<typeof HubBenchmarkingSchema>
+export type HubSustainability = Static<typeof HubSustainabilitySchema>
+export type HubRiskAssessment = Static<typeof HubRiskAssessmentSchema>
+export type HubMatchingCriteria = Static<typeof HubMatchingCriteriaSchema>

package/src/lsp/index.ts

@@ -0,0 +1,125 @@
+import { Type, Static } from '@sinclair/typebox'
+import { HubTypeSchema } from './hub'
+import { CarrierTypeSchema } from './carrier'
+import { TerminalTypeSchema } from './terminal'
+import { WarehouseTypeSchema } from './warehouse'
+import { PodTypeSchema } from './pod'
+import { SPProfileSchema } from '../context'
+import { AddressSchema } from '../geo'
+
+export const LSPTypeSchema = Type.Union([
+  Type.Literal('FLEET'),
+  Type.Literal('CARRIER'),
+  Type.Literal('WAREHOUSE'),
+  Type.Literal('TERMINAL'),
+  Type.Literal('HUB'),
+  Type.Literal('POD'),       // Smart-locker / drone-pad pod operator
+  Type.Literal('BROKER'),
+  Type.Literal('FORWARDER'),
+  Type.Literal('3PL'),
+  Type.Literal('4PL')
+])
+
+// LSP Schema
+export const LSPSchema = Type.Composite([
+  SPProfileSchema,
+  Type.Object({
+    type: LSPTypeSchema
+  })
+])
+export const LSPUpdateSchema = Type.Partial(Type.Omit(LSPSchema, ['xcode', 'created', 'updated']))
+
+export const LSPNeworkFacilityTypeSchema = Type.Union([
+  Type.Literal('HUB'),
+  Type.Literal('TERMINAL'),
+  Type.Literal('WAREHOUSE'),
+  Type.Literal('POD')        // Physical smart-locker / drone-pad node
+])
+// Service Provider Schema
+export const LSPServiceContextSchema = Type.Object({
+  providerType: LSPTypeSchema,
+  type: Type.Union([
+    ...CarrierTypeSchema.anyOf,
+    ...HubTypeSchema.anyOf,
+    ...WarehouseTypeSchema.anyOf,
+    ...TerminalTypeSchema.anyOf,
+    ...PodTypeSchema.anyOf    // THERMAL_LOCKER | STANDARD_LOCKER | DRONE_PAD | HYBRID
+  ]),
+  id: Type.String(),
+  description: Type.Optional(Type.String({ minLength: 10, maxLength: 250 }))
+})
+
+export const LSPNetworkNodeSchema = Type.Object({
+  type: Type.Union([
+    ...LSPNeworkFacilityTypeSchema.anyOf,
+    Type.Literal('BARRIER'),
+    Type.Literal('STOP'),
+    Type.Literal('ANY')
+  ]),
+  address: Type.Optional(AddressSchema),
+  id: Type.Optional(Type.String({ description: 'link node definition ID' })),
+  description: Type.Optional(Type.String({ minLength: 10, maxLength: 250 }))
+}, {
+  additionalProperties: false,
+  oneOf: [
+    { required: ['type', 'id'] },
+    { required: ['type', 'address'] }
+  ]
+})
+
+export const LSPOperatorRoleSchema = Type.Union([
+  Type.Literal('ADMIN'),
+  Type.Literal('READONLY'),
+  Type.Literal('MANAGER'),
+  Type.Literal('SUPERVISOR'),
+  Type.Literal('COORDINATOR'),
+  Type.Literal('DISPATCHER'),
+  Type.Literal('TECHNICIAN'),
+  Type.Literal('SERVICE')    // Programmatic / service-to-service access (e.g. Rally intake, IoTSP webhooks)
+])
+
+export const LSPOrderTypeSchema = Type.Union([
+  Type.Literal('FIRST-MILE'),
+  Type.Literal('MIDDLE-MILE'),
+  Type.Literal('LAST-MILE'),
+
+  Type.Literal('SHORT-MILE'),
+  Type.Literal('LONG-MILE'),
+  
+  Type.Literal('WAREHOUSING')
+])
+
+// Generate TypeScript types from schemas
+export type LSP = Static<typeof LSPSchema>
+export type LSPType = Static<typeof LSPTypeSchema>
+export type LSPUpdate = Static<typeof LSPUpdateSchema>
+export type LSPServiceContext = Static<typeof LSPServiceContextSchema>
+export type LSPNetworkNode = Static<typeof LSPNetworkNodeSchema>
+export type LSPNeworkFacilityType = Static<typeof LSPNeworkFacilityTypeSchema>
+export type LSPOperatorRole = Static<typeof LSPOperatorRoleSchema>
+export type LSPOrderType = Static<typeof LSPOrderTypeSchema>
+
+export const LSPQuoteRequestSchema = Type.Object({
+  origin: Type.String(),
+  destination: Type.String(),
+  serviceType: Type.String(),
+  urgency: Type.Union([
+    Type.Literal('STANDARD'),
+    Type.Literal('EXPRESS'),
+    Type.Literal('URGENT')
+  ]),
+  cargo: Type.Object({
+    weight: Type.Number({ minimum: 0 }),
+    dimensions: Type.Optional(Type.Object({
+      length: Type.Number({ minimum: 0 }),
+      width: Type.Number({ minimum: 0 }),
+      height: Type.Number({ minimum: 0 })
+    })),
+    category: Type.Optional(Type.String()),
+    hazardous: Type.Optional(Type.Boolean())
+  })
+})
+
+export type LSPQuoteRequest = Static<typeof LSPQuoteRequestSchema>
+
+export * from './order/management'