@de./types 1.0.0

package/src/lsp/carrier/capacities.ts

@@ -0,0 +1,723 @@
+import { Type, Static } from '@sinclair/typebox'
+import { ContextSchema } from '../../context'
+import { FleetStatsSchema } from '../fleet'
+import { SPAvailabilitySchema } from '../../context'
+import { DurationSchema, ActionRecordSchema } from '../../time'
+import { WeightSchema, VolumeSchema, ServiceLevelSchema, MoneySchema, AreaSchema, PerTimeSchema, DistanceSchema, PerAreaSchema } from '../../measure'
+
+// Fleet capacity and utilization
+export const CarrierFleetCapacitySchema = Type.Object({
+  type: Type.Literal('FLEET'),
+  serviceId: Type.String(),
+  context: ContextSchema,
+  
+  vehicleCapacity: FleetStatsSchema,
+  
+  loadCapacity: Type.Object({
+    totalWeight: WeightSchema,
+    totalVolume: VolumeSchema,
+    availableWeight: WeightSchema,
+    availableVolume: VolumeSchema,
+    utilizationByWeight: Type.Number({ minimum: 0, maximum: 100 }),
+    utilizationByVolume: Type.Number({ minimum: 0, maximum: 100 }),
+    
+    specialized: Type.Record(Type.String(), Type.Object({
+      weightCapacity: WeightSchema,
+      volumeCapacity: VolumeSchema,
+      vehicleCount: Type.Number({ minimum: 0 }),
+      utilization: Type.Number({ minimum: 0, maximum: 100 }),
+      specialFeatures: Type.Array(Type.String())
+    }))
+  }),
+  
+  agentCapacity: Type.Object({
+    total: Type.Number({ minimum: 0 }),
+    available: Type.Number({ minimum: 0 }),
+    active: Type.Number({ minimum: 0 }),
+    partTime: Type.Number({ minimum: 0 }),
+    contract: Type.Number({ minimum: 0 }),
+    ownerOperators: Type.Number({ minimum: 0 }),
+    agentUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+    
+    qualifications: Type.Object({
+      cdlDrivers: Type.Number({ minimum: 0 }),
+      hazmatCertified: Type.Number({ minimum: 0 }),
+      endorsements: Type.Record(Type.String(), Type.Number({ minimum: 0 })),
+      experienceLevel: Type.Object({
+        newDrivers: Type.Number({ minimum: 0 }),
+        experiencedDrivers: Type.Number({ minimum: 0 }),
+        seniorDrivers: Type.Number({ minimum: 0 })
+      }),
+      safetyRecord: Type.Object({
+        accidentFreeDrivers: Type.Number({ minimum: 0 }),
+        cleanRecord: Type.Number({ minimum: 0 }),
+        violations: Type.Number({ minimum: 0 })
+      })
+    }),
+    
+    availability: Type.Object({
+      hoursPerWeek: Type.Number({ minimum: 0, maximum: 168 }),
+      shiftCapacity: Type.Object({
+        dayShift: Type.Number({ minimum: 0 }),
+        nightShift: Type.Number({ minimum: 0 }),
+        weekendShift: Type.Number({ minimum: 0 }),
+        holidayShift: Type.Number({ minimum: 0 })
+      }),
+      maxDrivingHours: Type.Number({ minimum: 0, maximum: 11 }),
+      maxOnDutyHours: Type.Number({ minimum: 0, maximum: 14 }),
+      requiredRest: DurationSchema,
+      overtimeCapacity: Type.Number({ minimum: 0, description: 'additional hours available' })
+    })
+  }),
+
+  created: ActionRecordSchema,
+  updated: Type.Optional(ActionRecordSchema)
+})
+
+// Service delivery capacity
+export const CarrierServiceCapacitySchema = Type.Object({
+  type: Type.Literal('SERVICE'),
+  serviceId: Type.String(),
+  context: ContextSchema,
+  
+  throughputCapacity: Type.Object({
+    dailyPackage: Type.Number({ minimum: 0 }),
+    dailyShipment: Type.Number({ minimum: 0 }),
+    dailyWeight: WeightSchema,
+    dailyVolume: VolumeSchema,
+    currentLoad: Type.Number({ minimum: 0 }),
+    hourly: Type.Number({ minimum: 0 }),
+    peakHour: Type.Number({ minimum: 0 }),
+    
+    byService: Type.Record(ServiceLevelSchema, Type.Object({
+      dailyCapacity: Type.Number({ minimum: 0 }),
+      currentLoad: Type.Number({ minimum: 0 }),
+      utilization: Type.Number({ minimum: 0, maximum: 100 }),
+      processingTime: DurationSchema,
+      cutoffTime: Type.String({ description: 'HH:MM' })
+    }))
+  }),
+  
+  routeCapacity: Type.Object({
+    totalRoutes: Type.Number({ minimum: 0 }),
+    activeRoutes: Type.Number({ minimum: 0 }),
+    maxStopsPerRoute: Type.Number({ minimum: 0 }),
+    averageStopsPerRoute: Type.Number({ minimum: 0 }),
+    routeOptimizationCapacity: Type.Boolean(),
+    dynamicRoutingCapacity: Type.Boolean(),
+    
+    routesByType: Type.Record(Type.String(), Type.Object({
+      routeCount: Type.Number({ minimum: 0 }),
+      capacity: Type.Number({ minimum: 0 }),
+      utilization: Type.Number({ minimum: 0, maximum: 100 }),
+      frequency: PerTimeSchema,
+      averageDistance: DistanceSchema,
+      averageTime: DurationSchema
+    }))
+  }),
+  
+  pickupCapacity: Type.Object({
+    dailyPickupCapacity: Type.Number({ minimum: 0 }),
+    scheduledPickups: Type.Number({ minimum: 0 }),
+    onDemandPickups: Type.Number({ minimum: 0 }),
+    pickupTimeWindows: Type.Array(Type.Object({
+      startTime: Type.String({ description: 'HH:MM' }),
+      endTime: Type.String({ description: 'HH:MM' }),
+      capacity: Type.Number({ minimum: 0 }),
+      utilization: Type.Number({ minimum: 0, maximum: 100 })
+    })),
+    averagePickupTime: DurationSchema,
+    pickupAccuracy: Type.Number({ minimum: 0, maximum: 100 })
+  }),
+  
+  deliveryCapacity: Type.Object({
+    dailyDeliveryCapacity: Type.Number({ minimum: 0 }),
+    deliveryTimeWindows: Type.Array(Type.Object({
+      startTime: Type.String({ description: 'HH:MM' }),
+      endTime: Type.String({ description: 'HH:MM' }),
+      capacity: Type.Number({ minimum: 0 }),
+      utilization: Type.Number({ minimum: 0, maximum: 100 })
+    })),
+    averageDeliveryTime: DurationSchema,
+    firstAttemptSuccess: Type.Number({ minimum: 0, maximum: 100 }),
+    deliveryAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+    specialDeliveryCapacity: Type.Record(Type.String(), Type.Number({ minimum: 0 }))
+  }),
+
+  created: ActionRecordSchema,
+  updated: Type.Optional(ActionRecordSchema)
+})
+
+// Geographic and network capacity
+export const CarrierNetworkCapacitySchema = Type.Object({
+  type: Type.Literal('NETWORK'),
+  serviceId: Type.String(),
+  context: ContextSchema,
+  
+  coverageCapacity: Type.Object({
+    totalServiceAreas: Type.Number({ minimum: 0 }),
+    activeServiceAreas: Type.Number({ minimum: 0 }),
+    zipCodesServed: Type.Number({ minimum: 0 }),
+    countriesServed: Type.Number({ minimum: 0 }),
+    statesServed: Type.Number({ minimum: 0 }),
+    citiesServed: Type.Number({ minimum: 0 }),
+    
+    byRegion: Type.Record(Type.String(), Type.Object({
+      coverage: Type.Number({ minimum: 0, maximum: 100, description: 'percentage' }),
+      capacity: Type.Number({ minimum: 0 }),
+      utilization: Type.Number({ minimum: 0, maximum: 100 }),
+      serviceLevel: ServiceLevelSchema,
+      transitTime: DurationSchema
+    })),
+    
+    expansionCapacity: Type.Object({
+      newAreasPerYear: Type.Number({ minimum: 0 }),
+      expansionCost: MoneySchema,
+      expansionTimeframe: DurationSchema,
+      marketPenetration: Type.Number({ minimum: 0, maximum: 100 })
+    })
+  }),
+  
+  hubConnectivity: Type.Object({
+    connectedHubs: Type.Number({ minimum: 0 }),
+    hubRoutes: Type.Number({ minimum: 0 }),
+    interHubCapacity: Type.Number({ minimum: 0 }),
+    hubUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+    averageHubDistance: DistanceSchema,
+    averageHubTransitTime: DurationSchema
+  }),
+  
+  partnerNetwork: Type.Object({
+    carrierPartners: Type.Number({ minimum: 0 }),
+    agentNetwork: Type.Number({ minimum: 0 }),
+    franchiseNetwork: Type.Number({ minimum: 0 }),
+    contractorNetwork: Type.Number({ minimum: 0 }),
+    lastMilePartners: Type.Number({ minimum: 0 }),
+    internationalPartners: Type.Number({ minimum: 0 }),
+    
+    partnerCapacity: Type.Record(Type.String(), Type.Object({
+      capacity: Type.Number({ minimum: 0 }),
+      utilization: Type.Number({ minimum: 0, maximum: 100 }),
+      serviceLevel: ServiceLevelSchema,
+      cost: MoneySchema,
+      reliability: Type.Number({ minimum: 0, maximum: 100 })
+    }))
+  }),
+  
+  facilityCapacity: Type.Object({
+    terminalCount: Type.Number({ minimum: 0 }),
+    sortingFacilities: Type.Number({ minimum: 0 }),
+    crossDockFacilities: Type.Number({ minimum: 0 }),
+    warehouseFacilities: Type.Number({ minimum: 0 }),
+    maintenanceFacilities: Type.Number({ minimum: 0 }),
+    customerServiceCenters: Type.Number({ minimum: 0 }),
+    
+    facilityUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+    totalFacilityArea: AreaSchema,
+    operationalArea: AreaSchema,
+    expansionPotential: AreaSchema
+  }),
+
+  created: ActionRecordSchema,
+  updated: Type.Optional(ActionRecordSchema)
+})
+
+// Operational capacity and performance
+export const CarrierOperationalCapacitySchema = Type.Object({
+  type: Type.Literal('OPERATIONAL'),
+  serviceId: Type.String(),
+  context: ContextSchema,
+  
+  processingCapacity: Type.Object({
+    sorting: PerTimeSchema,
+    scanning: PerTimeSchema,
+    loading: PerTimeSchema,
+    unloading: PerTimeSchema,
+    documentProcessing: PerTimeSchema,
+    customsProcessing: PerTimeSchema,
+    
+    processingTime: Type.Object({
+      averageProcessingTime: DurationSchema,
+      maxProcessingTime: DurationSchema,
+      minProcessingTime: DurationSchema,
+      processingAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+      processingVariance: DurationSchema
+    })
+  }),
+  
+  transitCapacity: Type.Object({
+    totalMiles: DistanceSchema,
+    deliveredMiles: DistanceSchema,
+    emptyMiles: DistanceSchema,
+    utilizationByMiles: Type.Number({ minimum: 0, maximum: 100 }),
+    
+    transitTimes: Type.Record(ServiceLevelSchema, Type.Object({
+      averageTransitTime: DurationSchema,
+      minTransitTime: DurationSchema,
+      maxTransitTime: DurationSchema,
+      onTimePerformance: Type.Number({ minimum: 0, maximum: 100 }),
+      transitVariance: DurationSchema
+    })),
+    
+    lineHaul: Type.Object({
+      routes: Type.Number({ minimum: 0 }),
+      capacity: WeightSchema,
+      utilization: Type.Number({ minimum: 0, maximum: 100 }),
+      frequency: PerTimeSchema,
+      reliability: Type.Number({ minimum: 0, maximum: 100 })
+    }),
+    
+    lastMile: Type.Object({
+      deliveryRoutes: Type.Number({ minimum: 0 }),
+      stopsPerRoute: Type.Number({ minimum: 0 }),
+      deliveriesPerDay: Type.Number({ minimum: 0 }),
+      deliveryDensity: PerAreaSchema,
+      serviceRadius: DistanceSchema
+    })
+  }),
+  
+  seasonalCapacity: Type.Object({
+    baseline: Type.Number({ minimum: 0, maximum: 100 }),
+    peak: Type.Number({ minimum: 0, maximum: 300, description: 'percentage of baseline' }),
+    peakSeasonDuration: DurationSchema,
+    capacityFlexibility: Type.Number({ minimum: 0, maximum: 100 }),
+    
+    seasonalAdjustments: Type.Array(Type.Object({
+      season: Type.String(),
+      capacityMultiplier: Type.Number({ minimum: 0 }),
+      durationWeeks: Type.Number({ minimum: 0 }),
+      additionalResources: Type.Object({
+        vehicles: Type.Number({ minimum: 0 }),
+        agents: Type.Number({ minimum: 0 }),
+        facilities: Type.Number({ minimum: 0 }),
+        cost: MoneySchema
+      })
+    }))
+  }),
+  
+  emergencyCapacity: Type.Object({
+    emergencyResponse: Type.Boolean(),
+    disasterRecovery: Type.Boolean(),
+    backupCapacity: Type.Number({ minimum: 0, maximum: 100 }),
+    redundantRoutes: Type.Boolean(),
+    alternativeFacilities: Type.Boolean(),
+    emergencyEquipment: Type.Boolean(),
+    responseTime: DurationSchema,
+    recoveryTime: DurationSchema
+  }),
+
+  created: ActionRecordSchema,
+  updated: Type.Optional(ActionRecordSchema)
+})
+
+// Time-based availability and scheduling capacity
+export const CarrierAvailabilitySchema = Type.Object({
+  type: Type.Literal('AVAILABILITY'),
+  serviceId: Type.String(),
+  context: ContextSchema,
+  
+  operational: SPAvailabilitySchema,
+  
+  operatingSchedule: Type.Object({
+    operationalHoursPerDay: Type.Number({ minimum: 0, maximum: 24 }),
+    operationalDaysPerWeek: Type.Number({ minimum: 0, maximum: 7 }),
+    operationalDaysPerYear: Type.Number({ minimum: 0, maximum: 366 }),
+    holidayOperations: Type.Boolean(),
+    seasonalOperations: Type.Boolean(),
+    extendedHoursCapacity: Type.Number({ minimum: 0, description: 'additional hours available' }),
+    flexibleScheduling: Type.Boolean()
+  }),
+  
+  maintenance: Type.Object({
+    plannedDowntimeHours: PerTimeSchema,
+    unplannedDowntimeHours: PerTimeSchema,
+    systemAvailability: Type.Number({ minimum: 0, maximum: 100, description: 'percentage' }),
+    equipmentUptime: Type.Number({ minimum: 0, maximum: 100, description: 'percentage' }),
+    maintenanceWindows: Type.Array(Type.String()),
+    maintenanceCapacity: Type.Number({ minimum: 0, description: 'equipment units maintainable simultaneously' }),
+    meanTimeBetweenFailures: DurationSchema,
+    meanTimeToRepair: DurationSchema
+  }),
+  
+  booking: Type.Object({
+    totalBookableCapacity: Type.Number({ minimum: 0, maximum: 100 }),
+    currentBookingLevel: Type.Number({ minimum: 0, maximum: 100 }),
+    availableCapacity: Type.Number({ minimum: 0, maximum: 100 }),
+    reservedCapacity: Type.Number({ minimum: 0, maximum: 100 }),
+    contractedCapacity: Type.Number({ minimum: 0, maximum: 100 }),
+    spotCapacity: Type.Number({ minimum: 0, maximum: 100 }),
+    overbookingAllowed: Type.Boolean(),
+    maxOverbookingPercent: Type.Optional(Type.Number({ minimum: 0, maximum: 50 })),
+    advanceBookingRequired: DurationSchema,
+    cancellationNotice: DurationSchema
+  }),
+  
+  created: ActionRecordSchema,
+  updated: Type.Optional(ActionRecordSchema)
+})
+
+// Technology and systems capacity
+export const CarrierTechnologyCapacitySchema = Type.Object({
+  type: Type.Literal('TECHNOLOGY'),
+  serviceId: Type.String(),
+  context: ContextSchema,
+  
+  systemCapacity: Type.Object({
+    maxConcurrentUsers: Type.Number({ minimum: 0 }),
+    maxTransactionsPerHour: Type.Number({ minimum: 0 }),
+    maxPackagesTracked: Type.Number({ minimum: 0 }),
+    databaseCapacity: Type.Number({ minimum: 0, description: 'GB' }),
+    apiCallsPerHour: Type.Number({ minimum: 0 }),
+    webhookCapacity: Type.Number({ minimum: 0 }),
+    
+    systemPerformance: Type.Object({
+      uptime: Type.Number({ minimum: 0, maximum: 100, description: 'percentage' }),
+      responseTime: Type.Number({ minimum: 0, description: 'milliseconds' }),
+      throughput: PerTimeSchema,
+      reliability: Type.Number({ minimum: 0, maximum: 100 }),
+      scalability: Type.Union([
+        Type.Literal('LIMITED'),
+        Type.Literal('MODERATE'),
+        Type.Literal('HIGH'),
+        Type.Literal('ELASTIC')
+      ])
+    })
+  }),
+  
+  trackingCapacity: Type.Object({
+    devicesTracked: Type.Number({ minimum: 0 }),
+    trackingPoints: Type.Number({ minimum: 0 }),
+    updateFrequency: PerTimeSchema,
+    dataRetention: DurationSchema,
+    trackingAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+    batteryLife: DurationSchema,
+    coverageArea: AreaSchema,
+    signalReliability: Type.Number({ minimum: 0, maximum: 100 })
+  }),
+  
+  communicationCapacity: Type.Object({
+    mobileDevices: Type.Number({ minimum: 0 }),
+    vehicleDevices: Type.Number({ minimum: 0 }),
+    dataPlans: Type.Number({ minimum: 0 }),
+    bandwidth: Type.Number({ minimum: 0, description: 'Mbps' }),
+    coverage: Type.Number({ minimum: 0, maximum: 100, description: 'percentage' }),
+    reliability: Type.Number({ minimum: 0, maximum: 100 }),
+    
+    notification: Type.Object({
+      smsPerDay: Type.Number({ minimum: 0 }),
+      emailsPerDay: Type.Number({ minimum: 0 }),
+      pushNotifications: Type.Number({ minimum: 0 }),
+      callsPerDay: Type.Number({ minimum: 0 }),
+      deliveryRate: Type.Number({ minimum: 0, maximum: 100 })
+    })
+  }),
+  
+  integrationCapacity: Type.Object({
+    activeIntegrations: Type.Number({ minimum: 0 }),
+    maxIntegrations: Type.Number({ minimum: 0 }),
+    apiConnections: Type.Number({ minimum: 0 }),
+    ediConnections: Type.Number({ minimum: 0 }),
+    webhookEndpoints: Type.Number({ minimum: 0 }),
+    dataProcessing: PerTimeSchema,
+    
+    cloud: Type.Object({
+      computeCapacity: Type.Number({ minimum: 0, description: 'vCPUs' }),
+      storageCapacity: Type.Number({ minimum: 0, description: 'GB' }),
+      networkBandwidth: Type.Number({ minimum: 0, description: 'Mbps' }),
+      scalingCapacity: Type.Union([
+        Type.Literal('MANUAL'),
+        Type.Literal('AUTOMATIC'),
+        Type.Literal('ELASTIC'),
+        Type.Literal('UNLIMITED')
+      ])
+    })
+  }),
+
+  created: ActionRecordSchema,
+  updated: Type.Optional(ActionRecordSchema)
+})
+
+// Financial capacity and constraints
+export const CarrierFinancialCapacitySchema = Type.Object({
+  type: Type.Literal('FINANCIAL'),
+  serviceId: Type.String(),
+  context: ContextSchema,
+  
+  operatingCosts: Type.Object({
+    fixedCostsPerMonth: MoneySchema,
+    variableCostPerMile: MoneySchema,
+    variableCostPerPackage: MoneySchema,
+    fuelCostPerMile: MoneySchema,
+    laborCostPerHour: MoneySchema,
+    vehicleCostPerMile: MoneySchema,
+    facilityCostPerSqFt: MoneySchema,
+    technologyCostPerMonth: MoneySchema,
+    insuranceCostPerMonth: MoneySchema,
+    maintenanceCostPerVehicle: MoneySchema
+  }),
+  
+  pricingCapacity: Type.Object({
+    basePricing: Type.Record(ServiceLevelSchema, MoneySchema),
+    distancePricing: Type.Record(Type.String(), MoneySchema),
+    weightPricing: Type.Record(Type.String(), MoneySchema),
+    volumePricing: Type.Record(Type.String(), MoneySchema),
+    specialServicePricing: Type.Record(Type.String(), MoneySchema),
+    
+    volumeDiscounts: Type.Array(Type.Object({
+      minimumVolume: Type.Number({ minimum: 0 }),
+      discountPercentage: Type.Number({ minimum: 0, maximum: 100 }),
+      applicableServices: Type.Array(ServiceLevelSchema)
+    })),
+    
+    contractPricing: Type.Object({
+      minimumCommitment: MoneySchema,
+      discountStructure: Type.Record(Type.String(), Type.Number()),
+      paymentTerms: Type.Array(Type.String()),
+      pricingFlexibility: Type.Union([
+        Type.Literal('FIXED'),
+        Type.Literal('INDEXED'),
+        Type.Literal('NEGOTIABLE'),
+        Type.Literal('DYNAMIC')
+      ])
+    }),
+    
+    surcharges: Type.Record(Type.String(), MoneySchema),
+    fuelSurcharge: Type.Object({
+      applicable: Type.Boolean(),
+      calculationMethod: Type.String(),
+      basePrice: MoneySchema,
+      adjustmentFrequency: PerTimeSchema
+    })
+  }),
+  
+  revenueCapacity: Type.Object({
+    maxRevenueCapacity: MoneySchema,
+    currentRevenue: MoneySchema,
+    revenuePerMile: MoneySchema,
+    revenuePerPackage: MoneySchema,
+    profitMargin: Type.Number({ minimum: 0, maximum: 100 }),
+    breakEvenVolume: Type.Number({ minimum: 0 }),
+    
+    revenueStreams: Type.Record(Type.String(), Type.Object({
+      revenue: MoneySchema,
+      volume: Type.Number({ minimum: 0 }),
+      growth: Type.Number({ description: 'percentage' }),
+      profitability: Type.Number({ minimum: 0, maximum: 100 })
+    }))
+  }),
+  
+  capitalCapacity: Type.Object({
+    availableCapital: MoneySchema,
+    creditLimit: MoneySchema,
+    investmentCapacity: MoneySchema,
+    cashFlow: MoneySchema,
+    workingCapital: MoneySchema,
+    
+    capitalExpenditure: Type.Object({
+      vehicleInvestment: MoneySchema,
+      technologyInvestment: MoneySchema,
+      facilityInvestment: MoneySchema,
+      equipmentInvestment: MoneySchema,
+      totalBudget: MoneySchema,
+      utilizationRate: Type.Number({ minimum: 0, maximum: 100 })
+    }),
+    
+    financing: Type.Object({
+      debtCapacity: MoneySchema,
+      equityCapacity: MoneySchema,
+      leasingCapacity: MoneySchema,
+      creditRating: Type.Optional(Type.String()),
+      interestRate: Type.Number({ minimum: 0 }),
+      paymentTerms: Type.String()
+    })
+  }),
+  
+  insurance: Type.Object({
+    totalCoverage: MoneySchema,
+    remainingCoverage: MoneySchema,
+    claimsHistory: Type.Array(Type.Object({
+      claimType: Type.String(),
+      claimAmount: MoneySchema,
+      date: Type.Number(),
+      status: Type.String()
+    })),
+    premiumCosts: Type.Record(Type.String(), MoneySchema),
+    deductibles: Type.Record(Type.String(), MoneySchema),
+    riskProfile: Type.Union([
+      Type.Literal('LOW'),
+      Type.Literal('MODERATE'),
+      Type.Literal('HIGH'),
+      Type.Literal('CRITICAL')
+    ])
+  }),
+
+  created: ActionRecordSchema,
+  updated: Type.Optional(ActionRecordSchema)
+})
+
+// Combined carrier capacity schema
+export const CarrierCapacitySchema = Type.Object({
+  fleet: CarrierFleetCapacitySchema,
+  service: CarrierServiceCapacitySchema,
+  network: CarrierNetworkCapacitySchema,
+  availability: CarrierAvailabilitySchema,
+  operational: CarrierOperationalCapacitySchema,
+  technology: CarrierTechnologyCapacitySchema,
+  financial: CarrierFinancialCapacitySchema
+})
+
+// Carrier Capacities Types
+export type CarrierFleetCapacity = Static<typeof CarrierFleetCapacitySchema>
+export type CarrierServiceCapacity = Static<typeof CarrierServiceCapacitySchema>
+export type CarrierNetworkCapacity = Static<typeof CarrierNetworkCapacitySchema>
+export type CarrierOperationalCapacity = Static<typeof CarrierOperationalCapacitySchema>
+export type CarrierAvailability = Static<typeof CarrierAvailabilitySchema>
+export type CarrierTechnologyCapacity = Static<typeof CarrierTechnologyCapacitySchema>
+export type CarrierFinancialCapacity = Static<typeof CarrierFinancialCapacitySchema>
+export type CarrierCapacity = Static<typeof CarrierCapacitySchema>
+// ─── Request Validation Schemas ───────────────────────────────────────────────
+
+import {
+	APIErrorSchema,
+	APIHeadersSchema,
+	APIResponseBaseSchema,
+	APIResponseDataSchemaFactory
+} from '../../api'
+
+export const CarrierCapacityTypeSchema = Type.Union([
+	Type.Literal('fleet'),
+	Type.Literal('service'),
+	Type.Literal('network'),
+	Type.Literal('operational'),
+	Type.Literal('technology'),
+	Type.Literal('financial')
+])
+
+export const CarrierBulkCapacitiesUpdateSchema = Type.Object({
+	capacities:   Type.Optional(Type.Record(CarrierCapacityTypeSchema, Type.Any())),
+	syncWithFleet: Type.Optional(Type.Boolean()),
+	reason:       Type.Optional(Type.String({ maxLength: 500 }))
+})
+
+const CapacitySetResponse = APIResponseDataSchemaFactory({ capacity: Type.Any() })
+
+export const LSPCarrierGetFleetCapacityRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	response: APIResponseDataSchemaFactory({
+		capacity:     CarrierFleetCapacitySchema,
+		utilization:  Type.Object({ current: Type.Number({ minimum: 0, maximum: 100 }), peak: Type.Number({ minimum: 0, maximum: 100 }), trend: Type.Union([Type.Literal('INCREASING'), Type.Literal('STABLE'), Type.Literal('DECREASING')]) }),
+		completeness: Type.Number({ minimum: 0, maximum: 100 }),
+		lastUpdated:  Type.Number()
+	})
+}
+
+export const LSPCarrierSetFleetCapacityRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     Type.Any(),
+	response: CapacitySetResponse
+}
+
+export const LSPCarrierGetServiceCapacityRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	response: APIResponseDataSchemaFactory({
+		capacity:     CarrierServiceCapacitySchema,
+		utilization:  Type.Object({ overall: Type.Number({ minimum: 0, maximum: 100 }), byServiceLevel: Type.Record(Type.String(), Type.Number({ minimum: 0, maximum: 100 })) }),
+		completeness: Type.Number({ minimum: 0, maximum: 100 }),
+		lastUpdated:  Type.Number()
+	})
+}
+
+export const LSPCarrierSetServiceCapacityRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     Type.Any(),
+	response: CapacitySetResponse
+}
+
+export const LSPCarrierGetOperationalCapacityRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	response: APIResponseDataSchemaFactory({ capacity: CarrierOperationalCapacitySchema, completeness: Type.Number({ minimum: 0, maximum: 100 }), lastUpdated: Type.Number() })
+}
+
+export const LSPCarrierSetOperationalCapacityRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     Type.Any(),
+	response: CapacitySetResponse
+}
+
+export const LSPCarrierGetNetworkCapacityRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	response: APIResponseDataSchemaFactory({ capacity: CarrierNetworkCapacitySchema, completeness: Type.Number({ minimum: 0, maximum: 100 }), lastUpdated: Type.Number() })
+}
+
+export const LSPCarrierSetNetworkCapacityRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     Type.Any(),
+	response: CapacitySetResponse
+}
+
+export const LSPCarrierGetTechnologyCapacityRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	response: APIResponseDataSchemaFactory({ capacity: CarrierTechnologyCapacitySchema, completeness: Type.Number({ minimum: 0, maximum: 100 }), lastUpdated: Type.Number() })
+}
+
+export const LSPCarrierSetTechnologyCapacityRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     Type.Any(),
+	response: CapacitySetResponse
+}
+
+export const LSPCarrierGetFinancialCapacityRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	response: APIResponseDataSchemaFactory({ capacity: CarrierFinancialCapacitySchema, completeness: Type.Number({ minimum: 0, maximum: 100 }), lastUpdated: Type.Number() })
+}
+
+export const LSPCarrierSetFinancialCapacityRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     Type.Any(),
+	response: CapacitySetResponse
+}
+
+export const LSPCarrierGetAllCapacitiesRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	response: APIResponseDataSchemaFactory({
+		capacities: Type.Object({
+			fleet:       Type.Optional(CarrierFleetCapacitySchema),
+			service:     Type.Optional(CarrierServiceCapacitySchema),
+			operational: Type.Optional(CarrierOperationalCapacitySchema),
+			network:     Type.Optional(CarrierNetworkCapacitySchema),
+			technology:  Type.Optional(CarrierTechnologyCapacitySchema),
+			financial:   Type.Optional(CarrierFinancialCapacitySchema)
+		}),
+		missingTypes: Type.Array(CarrierCapacityTypeSchema),
+		completeness: Type.Number({ minimum: 0, maximum: 100 }),
+		summary:      Type.Object({ overallUtilization: Type.Number({ minimum: 0, maximum: 100 }), capacityScore: Type.Number({ minimum: 0, maximum: 100 }), bottlenecks: Type.Array(Type.String()) }),
+		lastUpdated:  Type.Number()
+	})
+}
+
+export type LSPCarrierGetFleetCapacityValidation       = { headers: Static<typeof LSPCarrierGetFleetCapacityRVS.headers>, params: Static<typeof LSPCarrierGetFleetCapacityRVS.params>, response: Static<typeof LSPCarrierGetFleetCapacityRVS.response> }
+export type LSPCarrierSetFleetCapacityValidation       = { headers: Static<typeof LSPCarrierSetFleetCapacityRVS.headers>, params: Static<typeof LSPCarrierSetFleetCapacityRVS.params>, body: Static<typeof LSPCarrierSetFleetCapacityRVS.body>, response: Static<typeof LSPCarrierSetFleetCapacityRVS.response> }
+export type LSPCarrierGetServiceCapacityValidation     = { headers: Static<typeof LSPCarrierGetServiceCapacityRVS.headers>, params: Static<typeof LSPCarrierGetServiceCapacityRVS.params>, response: Static<typeof LSPCarrierGetServiceCapacityRVS.response> }
+export type LSPCarrierSetServiceCapacityValidation     = { headers: Static<typeof LSPCarrierSetServiceCapacityRVS.headers>, params: Static<typeof LSPCarrierSetServiceCapacityRVS.params>, body: Static<typeof LSPCarrierSetServiceCapacityRVS.body>, response: Static<typeof LSPCarrierSetServiceCapacityRVS.response> }
+export type LSPCarrierGetOperationalCapacityValidation = { headers: Static<typeof LSPCarrierGetOperationalCapacityRVS.headers>, params: Static<typeof LSPCarrierGetOperationalCapacityRVS.params>, response: Static<typeof LSPCarrierGetOperationalCapacityRVS.response> }
+export type LSPCarrierSetOperationalCapacityValidation = { headers: Static<typeof LSPCarrierSetOperationalCapacityRVS.headers>, params: Static<typeof LSPCarrierSetOperationalCapacityRVS.params>, body: Static<typeof LSPCarrierSetOperationalCapacityRVS.body>, response: Static<typeof LSPCarrierSetOperationalCapacityRVS.response> }
+export type LSPCarrierGetNetworkCapacityValidation     = { headers: Static<typeof LSPCarrierGetNetworkCapacityRVS.headers>, params: Static<typeof LSPCarrierGetNetworkCapacityRVS.params>, response: Static<typeof LSPCarrierGetNetworkCapacityRVS.response> }
+export type LSPCarrierSetNetworkCapacityValidation     = { headers: Static<typeof LSPCarrierSetNetworkCapacityRVS.headers>, params: Static<typeof LSPCarrierSetNetworkCapacityRVS.params>, body: Static<typeof LSPCarrierSetNetworkCapacityRVS.body>, response: Static<typeof LSPCarrierSetNetworkCapacityRVS.response> }
+export type LSPCarrierGetTechnologyCapacityValidation  = { headers: Static<typeof LSPCarrierGetTechnologyCapacityRVS.headers>, params: Static<typeof LSPCarrierGetTechnologyCapacityRVS.params>, response: Static<typeof LSPCarrierGetTechnologyCapacityRVS.response> }
+export type LSPCarrierSetTechnologyCapacityValidation  = { headers: Static<typeof LSPCarrierSetTechnologyCapacityRVS.headers>, params: Static<typeof LSPCarrierSetTechnologyCapacityRVS.params>, body: Static<typeof LSPCarrierSetTechnologyCapacityRVS.body>, response: Static<typeof LSPCarrierSetTechnologyCapacityRVS.response> }
+export type LSPCarrierGetFinancialCapacityValidation   = { headers: Static<typeof LSPCarrierGetFinancialCapacityRVS.headers>, params: Static<typeof LSPCarrierGetFinancialCapacityRVS.params>, response: Static<typeof LSPCarrierGetFinancialCapacityRVS.response> }
+export type LSPCarrierSetFinancialCapacityValidation   = { headers: Static<typeof LSPCarrierSetFinancialCapacityRVS.headers>, params: Static<typeof LSPCarrierSetFinancialCapacityRVS.params>, body: Static<typeof LSPCarrierSetFinancialCapacityRVS.body>, response: Static<typeof LSPCarrierSetFinancialCapacityRVS.response> }
+export type LSPCarrierGetAllCapacitiesValidation       = { headers: Static<typeof LSPCarrierGetAllCapacitiesRVS.headers>, params: Static<typeof LSPCarrierGetAllCapacitiesRVS.params>, response: Static<typeof LSPCarrierGetAllCapacitiesRVS.response> }