@de./types 1.0.0

package/src/lsp/warehouse/capacities.ts

@@ -0,0 +1,538 @@
+import { Type, Static } from '@sinclair/typebox'
+import { ContextSchema } from '../../context'
+import { ActionRecordSchema } from '../../time'
+import { SPAvailabilitySchema } from '../../context'
+import { DurationSchema } from '../../time'
+import { DimensionsSchema, WeightSchema, VolumeSchema, TemperatureSchema, MoneySchema, AreaSchema, CapacityRecordSchema, LengthSchema, PerTimeSchema, MemorySchema, PowerSchema, PerAreaSchema, BandwidthSchema } from '../../measure';
+import {
+  PSLZoneTypeSchema,
+  PSLVelocitySchema
+} from '../psl'
+
+// Physical space capacity
+export const WarehousePhysicalCapacitySchema = Type.Object({
+  type: Type.Literal('PHYSICAL'),
+  serviceId: Type.String(),
+  context: ContextSchema,
+  
+  totalSpace: Type.Object({
+    totalArea: AreaSchema,
+    storageArea: AreaSchema,
+    operationalArea: AreaSchema,
+    officeArea: AreaSchema,
+    dockArea: AreaSchema,
+    ceilingHeight: LengthSchema,
+    maxStorageHeight: LengthSchema,
+    expandableArea: Type.Optional(AreaSchema)
+  }),
+  
+  storageCapacity: Type.Object({
+    volume: CapacityRecordSchema(VolumeSchema),
+    weight: CapacityRecordSchema(WeightSchema),
+    area: CapacityRecordSchema(AreaSchema),
+    palletPositions: CapacityRecordSchema(Type.Number()),
+    rackLevels: Type.Number({ minimum: 1, maximum: 50 }),
+    zones: Type.Number({ minimum: 0 }),
+    aisles: Type.Number({ minimum: 0 }),
+    bays: Type.Number({ minimum: 0 }),
+    slots: Type.Number({ minimum: 0 })
+  }),
+  
+  limits: Type.Object({
+    maxItemDimensions: DimensionsSchema,
+    maxItemWeight: WeightSchema,
+    maxPalletHeight: LengthSchema,
+    maxPalletWeight: WeightSchema,
+    maxContainerSize: Type.Optional(DimensionsSchema),
+    doorSizes: Type.Array(DimensionsSchema)
+  }),
+  
+  utilization: Type.Object({
+    utilizationPercentage: Type.Number({ minimum: 0, maximum: 100 }),
+    occupiedSlots: Type.Number({ minimum: 0 }),
+    reservedSlots: Type.Number({ minimum: 0 }),
+    availableSlots: Type.Number({ minimum: 0 }),
+    blockedSlots: Type.Number({ minimum: 0 }),
+    utilizationByZone: Type.Record(Type.String(), Type.Object({
+      zoneType: PSLZoneTypeSchema,
+      utilization: Type.Number({ minimum: 0, maximum: 100 }),
+      capacity: Type.Number({ minimum: 0 }),
+      used: Type.Number({ minimum: 0 }),
+      reserved: Type.Number({ minimum: 0 })
+    }))
+  }),
+  
+  created: ActionRecordSchema,
+  updated: Type.Optional(ActionRecordSchema)
+})
+
+// Operational throughput capacity
+export const WarehouseOperationalCapacitySchema = Type.Object({
+  type: Type.Literal('OPERATIONAL'),
+  serviceId: Type.String(),
+  context: ContextSchema,
+  
+  receiving: Type.Object({
+    maxDailyReceipts: Type.Number({ minimum: 0 }),
+    maxReceivingRate: PerTimeSchema,
+    maxPalletRate: PerTimeSchema,
+    receivingDoors: Type.Number({ minimum: 0 }),
+    maxTrucksPerDay: Type.Number({ minimum: 0 }),
+    maxContainersPerDay: Type.Number({ minimum: 0 }),
+    averageUnloadTime: DurationSchema
+  }),
+  
+  putaway: Type.Object({
+    maxPutawayRate: PerTimeSchema,
+    maxPalletPutawayRate: PerTimeSchema,
+    averagePutawayTime: DurationSchema,
+    putawayAccuracy: Type.Number({ minimum: 0, maximum: 100, description: 'percentage' })
+  }),
+  
+  picking: Type.Object({
+    maxOrdersPerDay: Type.Number({ minimum: 0 }),
+    maxOrdersPerHour: Type.Number({ minimum: 0 }),
+    maxPicksPerHour: Type.Number({ minimum: 0 }),
+    maxLinesPerOrder: Type.Number({ minimum: 0 }),
+    maxLinesPerHour: Type.Number({ minimum: 0 }),
+    pickingStations: Type.Number({ minimum: 0 }),
+    averagePickTime: Type.Number({ minimum: 0, description: 'seconds per pick' }),
+    pickingAccuracy: Type.Number({ minimum: 0, maximum: 100, description: 'percentage' }),
+    pickingVelocity: Type.Record(PSLVelocitySchema, Type.Number())
+  }),
+  
+  packing: Type.Object({
+    maxPackagesPerDay: Type.Number({ minimum: 0 }),
+    maxPackagesPerHour: Type.Number({ minimum: 0 }),
+    packingStations: Type.Number({ minimum: 0 }),
+    packingLines: Type.Number({ minimum: 0 }),
+    averagePackTime: Type.Number({ minimum: 0, description: 'minutes per package' }),
+    packingAccuracy: Type.Number({ minimum: 0, maximum: 100, description: 'percentage' }),
+    customPackagingCapacity: Type.Number({ minimum: 0 })
+  }),
+  
+  shipping: Type.Object({
+    maxShipmentsPerDay: Type.Number({ minimum: 0 }),
+    maxShipmentsPerHour: Type.Number({ minimum: 0 }),
+    shippingDoors: Type.Number({ minimum: 0 }),
+    maxTrucksPerDay: Type.Number({ minimum: 0 }),
+    maxContainersPerDay: Type.Number({ minimum: 0 }),
+    averageLoadTime: DurationSchema,
+    onTimeShipment: Type.Number({ minimum: 0, maximum: 100, description: 'percentage' })
+  }),
+  
+  orderProcessing: Type.Object({
+    maxConcurrentOrders: Type.Number({ minimum: 0 }),
+    orderCycleTime: DurationSchema,
+    maxOrdersPerHour: Type.Number({ minimum: 0 }),
+    maxOrderLines: Type.Number({ minimum: 0 }),
+    batchSizes: Type.Object({
+      maxBatchSize: Type.Number({ minimum: 0 }),
+      averageBatchSize: Type.Number({ minimum: 0 }),
+      optimalBatchSize: Type.Number({ minimum: 0 })
+    })
+  }),
+  
+  created: ActionRecordSchema,
+  updated: Type.Optional(ActionRecordSchema)
+})
+
+// Service level capacity
+export const WarehouseServiceLevelsCapacitySchema = Type.Object({
+  type: Type.Literal('SERVICE_LEVELS'),
+  serviceId: Type.String(),
+  context: ContextSchema,
+  
+  serviceCapacity: Type.Record(Type.Union([
+    Type.Literal('SAME_DAY'),
+    Type.Literal('NEXT_DAY'),
+    Type.Literal('STANDARD'),
+    Type.Literal('ECONOMY'),
+    Type.Literal('EXPRESS'),
+    Type.Literal('EXPEDITED')
+  ]), Type.Object({
+    maxDailyVolume: Type.Number({ minimum: 0 }),
+    maxHourlyVolume: Type.Number({ minimum: 0 }),
+    processingTime: DurationSchema,
+    cutoffTime: Type.String({ description: 'HH:MM' }),
+    slaCompliance: Type.Number({ minimum: 0, maximum: 100 }),
+    priorityLevel: Type.Number({ minimum: 1, maximum: 10 }),
+    resourceAllocation: Type.Number({ minimum: 0, maximum: 100, description: 'percentage of capacity' })
+  })),
+  
+  processingTimes: Type.Record(Type.Union([
+    Type.Literal('SAME_DAY'),
+    Type.Literal('NEXT_DAY'),
+    Type.Literal('STANDARD'),
+    Type.Literal('ECONOMY')
+  ]), Type.Object({
+    minProcessingTime: DurationSchema,
+    maxProcessingTime: DurationSchema,
+    averageProcessingTime: DurationSchema,
+    onTimePerformance: Type.Number({ minimum: 0, maximum: 100 }),
+    processingTimeVariance: DurationSchema
+  })),
+  
+  capacityAllocation: Type.Object({
+    totalCapacity: Type.Number({ minimum: 0, maximum: 100 }),
+    allocatedCapacity: Type.Number({ minimum: 0, maximum: 100 }),
+    reservedCapacity: Type.Number({ minimum: 0, maximum: 100 }),
+    availableCapacity: Type.Number({ minimum: 0, maximum: 100 }),
+    peakCapacityReserve: Type.Number({ minimum: 0, maximum: 100 })
+  }),
+  
+  created: ActionRecordSchema,
+  updated: Type.Optional(ActionRecordSchema)
+})
+
+// Resource capacity
+export const WarehouseResourcesCapacitySchema = Type.Object({
+  type: Type.Literal('RESOURCES'),
+  serviceId: Type.String(),
+  context: ContextSchema,
+  
+  equipment: Type.Object({
+    forklifts: Type.Object({
+      total: Type.Number({ minimum: 0 }),
+      available: Type.Number({ minimum: 0 }),
+      inUse: Type.Number({ minimum: 0 }),
+      maintenance: Type.Number({ minimum: 0 }),
+      maxLiftHeight: LengthSchema,
+      maxCapacity: WeightSchema,
+      utilizationRate: Type.Number({ minimum: 0, maximum: 100 })
+    }),
+    
+    conveyors: Type.Object({
+      totalLength: LengthSchema,
+      maxThroughput: PerTimeSchema,
+      currentThroughput: PerTimeSchema,
+      utilizationRate: Type.Number({ minimum: 0, maximum: 100 })
+    }),
+    
+    robotics: Type.Optional(Type.Object({
+      agvs: Type.Number({ minimum: 0 }),
+      pickingRobots: Type.Number({ minimum: 0 }),
+      sortingRobots: Type.Number({ minimum: 0 }),
+      robotUtilization: Type.Number({ minimum: 0, maximum: 100 })
+    })),
+    
+    docks: Type.Object({
+      receivingDocks: Type.Number({ minimum: 0 }),
+      shippingDocks: Type.Number({ minimum: 0 }),
+      crossDockPositions: Type.Number({ minimum: 0 }),
+      dockUtilization: Type.Number({ minimum: 0, maximum: 100 })
+    }),
+    
+    advancedEquipment: Type.Optional(Type.Object({
+      scanningEquipment: Type.Object({
+        scanners: Type.Number({ minimum: 0 }),
+        scanningRate: PerTimeSchema,
+        scanningAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+        dimensioningStations: Type.Number({ minimum: 0 }),
+        weighingStations: Type.Number({ minimum: 0 })
+      }),
+      
+      packagingEquipment: Type.Object({
+        packagingMachines: Type.Number({ minimum: 0 }),
+        labelPrinters: Type.Number({ minimum: 0 }),
+        sealingMachines: Type.Number({ minimum: 0 }),
+        shrinkWrapMachines: Type.Number({ minimum: 0 })
+      }),
+      
+      qualityControlEquipment: Type.Object({
+        inspectionStations: Type.Number({ minimum: 0 }),
+        testingEquipment: Type.Number({ minimum: 0 }),
+        photographyStations: Type.Number({ minimum: 0 }),
+        measurementDevices: Type.Number({ minimum: 0 })
+      })
+    }))
+  }),
+  
+  staffing: Type.Object({
+    maxStaffCapacity: Type.Number({ minimum: 0 }),
+    currentStaffing: Type.Number({ minimum: 0 }),
+    availableStaff: Type.Number({ minimum: 0 }),
+    staffUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+    
+    shiftCapacity: Type.Object({
+      firstShift: Type.Number({ minimum: 0 }),
+      secondShift: Type.Number({ minimum: 0 }),
+      thirdShift: Type.Number({ minimum: 0 }),
+      weekendShift: Type.Number({ minimum: 0 }),
+      holidayShift: Type.Number({ minimum: 0 })
+    }),
+    
+    skillCapacity: Type.Object({
+      generalLabor: Type.Number({ minimum: 0 }),
+      forkliftOperators: Type.Number({ minimum: 0 }),
+      qualityInspectors: Type.Number({ minimum: 0 }),
+      supervisors: Type.Number({ minimum: 0 }),
+      technicians: Type.Number({ minimum: 0 })
+    }),
+    
+    productivity: Type.Object({
+      itemsPerWorkerHour: Type.Number({ minimum: 0 }),
+      ordersPerWorkerHour: Type.Number({ minimum: 0 }),
+      picksPerWorkerHour: Type.Number({ minimum: 0 }),
+      packsPerWorkerHour: Type.Number({ minimum: 0 }),
+      accuracyPerWorker: Type.Number({ minimum: 0, maximum: 100 })
+    })
+  }),
+  
+  systems: Type.Object({
+    wmsCapacity: Type.Object({
+      maxConcurrentUsers: Type.Number({ minimum: 0 }),
+      maxTransactionsPerHour: Type.Number({ minimum: 0 }),
+      databaseCapacity: MemorySchema,
+      apiCallsPerHour: Type.Number({ minimum: 0 }),
+      systemUptime: Type.Number({ minimum: 0, maximum: 100, description: 'percentage' })
+    }),
+    
+    networkCapacity: Type.Object({
+      bandwidth: BandwidthSchema,
+      maxConnectedDevices: Type.Number({ minimum: 0 }),
+      networkUptime: Type.Number({ minimum: 0, maximum: 100, description: 'percentage' })
+    }),
+    
+    powerCapacity: Type.Object({
+      totalPowerCapacity: PowerSchema,
+      currentPowerUsage: PowerSchema,
+      backupPowerCapacity: DurationSchema,
+      uninterruptiblePowerSupply: Type.Boolean()
+    }),
+    
+    technologyCapacity: Type.Object({
+      dataProcessingCapacity: PerTimeSchema,
+      integrationCapacity: Type.Number({ minimum: 0, description: 'max concurrent integrations' }),
+      apiRateLimit: PerTimeSchema,
+      webhookCapacity: PerTimeSchema,
+      analyticsProcessing: PerTimeSchema
+    })
+  }),
+  
+  created: ActionRecordSchema,
+  updated: Type.Optional(ActionRecordSchema)
+})
+
+// Environmental capacity and conditions
+export const WarehouseEnvironmentalCapacitySchema = Type.Object({
+  type: Type.Literal('ENVIRONMENTAL'),
+  serviceId: Type.String(),
+  context: ContextSchema,
+  
+  temperatureZones: Type.Optional(Type.Array(Type.Object({
+    zoneId: Type.String(),
+    zoneType: PSLZoneTypeSchema,
+    minTemperature: TemperatureSchema,
+    maxTemperature: TemperatureSchema,
+    currentTemperature: TemperatureSchema,
+    tolerance: Type.Number({ description: 'degrees' }),
+    capacity: VolumeSchema,
+    currentLoad: VolumeSchema,
+    utilizationRate: Type.Number({ minimum: 0, maximum: 100 })
+  }))),
+  
+  humidityControl: Type.Optional(Type.Object({
+    minHumidity: Type.Number({ minimum: 0, maximum: 100 }),
+    maxHumidity: Type.Number({ minimum: 0, maximum: 100 }),
+    currentHumidity: Type.Number({ minimum: 0, maximum: 100 }),
+    tolerance: Type.Number({ description: 'percentage points' }),
+    controlledZones: Type.Number({ minimum: 0 })
+  })),
+  
+  cleanRoomCapacity: Type.Optional(Type.Object({
+    totalCleanRoomArea: AreaSchema,
+    availableCleanRoomArea: AreaSchema,
+    maxParticleCount: Type.Number({ minimum: 0 }),
+    airChangesPerHour: Type.Number({ minimum: 0 }),
+    maxOccupancy: Type.Number({ minimum: 0 })
+  })),
+  
+  sustainabilityMetrics: Type.Optional(Type.Object({
+    carbonFootprint: Type.Number({ minimum: 0, description: 'tons CO2 equivalent per year' }),
+    energyConsumption: Type.Number({ minimum: 0, description: 'kWh per year' }),
+    waterUsage: Type.Number({ minimum: 0, description: 'liters per year' }),
+    wasteGeneration: Type.Number({ minimum: 0, description: 'kg per year' }),
+    recyclingRate: Type.Number({ minimum: 0, maximum: 100, description: 'percentage' }),
+    renewableEnergyUsage: Type.Number({ minimum: 0, maximum: 100, description: 'percentage' })
+  })),
+  
+  created: ActionRecordSchema,
+  updated: Type.Optional(ActionRecordSchema)
+})
+
+// Time-based availability and scheduling capacity
+export const WarehouseAvailabilitySchema = Type.Object({
+  type: Type.Literal('AVAILABILITY'),
+  serviceId: Type.String(),
+  context: ContextSchema,
+
+  operational: SPAvailabilitySchema,
+
+  operatingSchedule: Type.Object({
+    hoursPerDay: Type.Number({ minimum: 0, maximum: 24 }),
+    daysPerWeek: Type.Number({ minimum: 0, maximum: 7 }),
+    operatingDaysPerYear: Type.Number({ minimum: 0, maximum: 366 }),
+    holidayOperations: Type.Boolean(),
+    seasonalAdjustments: Type.Boolean(),
+    extendedHoursCapacity: Type.Number({ minimum: 0, description: 'additional hours available' })
+  }),
+  
+  maintenance: Type.Object({
+    plannedDowntimeHours: PerTimeSchema,
+    unplannedDowntimeHours: PerTimeSchema,
+    systemAvailability: Type.Number({ minimum: 0, maximum: 100, description: 'percentage' }),
+    maintenanceWindows: Type.Array(Type.String()),
+    preventiveMaintenanceSchedule: Type.Boolean()
+  }),
+  
+  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 }),
+    overbookingAllowed: Type.Boolean(),
+    maxOverbookingPercent: Type.Optional(Type.Number({ minimum: 0, maximum: 50 })),
+    advanceBookingRequired: DurationSchema,
+    cancellationPolicy: Type.Number({ minimum: 0, description: 'hours notice required' })
+  })
+})
+
+// Scalability and expansion capacity
+export const WarehouseScalabilitySchema = Type.Object({
+  type: Type.Literal('AVAILABILITY'),
+  serviceId: Type.String(),
+  context: ContextSchema,
+
+  physicalExpansion: Type.Object({
+    expandable: Type.Boolean(),
+    maxExpansionArea: Type.Optional(AreaSchema),
+    maxExpansionVolume: Type.Optional(VolumeSchema),
+    expansionTimeframe: Type.Optional(DurationSchema),
+    expandableDirections: Type.Array(Type.Union([
+      Type.Literal('HORIZONTAL'),
+      Type.Literal('VERTICAL'),
+      Type.Literal('MEZZANINE'),
+      Type.Literal('ADJACENT_BUILDING')
+    ]))
+  }),
+  
+  operationalScaling: Type.Object({
+    peakCapacityMultiplier: Type.Number({ minimum: 1 }),
+    seasonalCapacityIncrease: Type.Number({ minimum: 0, maximum: 200 }),
+    temporaryStaffingCapacity: Type.Number({ minimum: 0 }),
+    equipmentScalingCapacity: Type.Number({ minimum: 0, maximum: 200 }),
+    outsourcingCapacity: Type.Number({ minimum: 0, description: 'percentage of operations' }),
+    thirdPartyLogisticsIntegration: Type.Boolean()
+  }),
+  
+  technologyScaling: Type.Object({
+    cloudScalability: Type.Boolean(),
+    autoScaling: Type.Boolean(),
+    loadBalancingCapacity: Type.Boolean(),
+    dataProcessingCapacity: PerTimeSchema,
+    integrationCapacity: Type.Number({ minimum: 0, description: 'max concurrent integrations' }),
+    apiRateLimit: PerTimeSchema
+  })
+})
+
+// Financial capacity and constraints
+export const WarehouseFinancialCapacitySchema = Type.Object({
+  type: Type.Literal('FINANCIAL'),
+  serviceId: Type.String(),
+  context: ContextSchema,
+  
+  operatingCosts: Type.Object({
+    fixedCostsPerMonth: MoneySchema,
+    variableCostPerUnit: MoneySchema,
+    laborCostPerHour: MoneySchema,
+    utilityCostPerSqFt: MoneySchema,
+    equipmentCostPerHour: MoneySchema
+  }),
+  
+  capitalInvestment: Type.Object({
+    availableCapitalBudget: MoneySchema,
+    maxInvestmentPerProject: MoneySchema,
+    roiRequirement: Type.Number({ minimum: 0, description: 'percentage' }),
+    paybackPeriod: DurationSchema
+  }),
+  
+  insurance: Type.Object({
+    generalLiabilityLimit: MoneySchema,
+    cargoInsuranceLimit: MoneySchema,
+    propertyInsuranceLimit: MoneySchema,
+    maxClaimPerIncident: MoneySchema,
+    deductibleAmount: MoneySchema
+  }),
+  
+  revenueCapacity: Type.Object({
+    maxRevenueCapacity: MoneySchema,
+    currentRevenue: MoneySchema,
+    revenuePerOrder: MoneySchema,
+    profitMargin: Type.Number({ minimum: 0, maximum: 100 }),
+    breakEvenVolume: Type.Number({ minimum: 0 }),
+    maxProfitableVolume: Type.Number({ minimum: 0 })
+  }),
+  
+  created: ActionRecordSchema,
+  updated: Type.Optional(ActionRecordSchema)
+})
+
+// Combined warehouse capacity schema
+export const WarehouseCapacitySchema = Type.Object({
+  physical: WarehousePhysicalCapacitySchema,
+  operational: WarehouseOperationalCapacitySchema,
+  serviceLevels: WarehouseServiceLevelsCapacitySchema,
+  resources: WarehouseResourcesCapacitySchema,
+  environmental: WarehouseEnvironmentalCapacitySchema,
+  availability: WarehouseAvailabilitySchema,
+  scalability: WarehouseScalabilitySchema,
+  financial: Type.Optional(WarehouseFinancialCapacitySchema)
+})
+
+// TypeScript type exports
+export type WarehousePhysicalCapacity = Static<typeof WarehousePhysicalCapacitySchema>
+export type WarehouseOperationalCapacity = Static<typeof WarehouseOperationalCapacitySchema>
+export type WarehouseServiceLevelsCapacity = Static<typeof WarehouseServiceLevelsCapacitySchema>
+export type WarehouseResourcesCapacity = Static<typeof WarehouseResourcesCapacitySchema>
+export type WarehouseEnvironmentalCapacity = Static<typeof WarehouseEnvironmentalCapacitySchema>
+export type WarehouseAvailability = Static<typeof WarehouseAvailabilitySchema>
+export type WarehouseScalability = Static<typeof WarehouseScalabilitySchema>
+export type WarehouseFinancialCapacity = Static<typeof WarehouseFinancialCapacitySchema>
+export type WarehouseCapacity = Static<typeof WarehouseCapacitySchema>
+
+// ─── Request Validation Schemas ───────────────────────────────────────────────
+
+import {
+	APIHeadersSchema,
+	APIResponseDataSchemaFactory
+} from '../../api'
+
+const GetCapacityResponse = APIResponseDataSchemaFactory({ capacity: Type.Any() })
+const SetCapacityResponse = APIResponseDataSchemaFactory({ capacity: Type.Any() })
+
+export const LSPWarehouseGetPhysicalCapacityRVS      = { headers: APIHeadersSchema, params: Type.Object({ id: Type.String() }), response: GetCapacityResponse }
+export const LSPWarehouseSetPhysicalCapacityRVS      = { headers: APIHeadersSchema, params: Type.Object({ id: Type.String() }), body: Type.Any(), response: SetCapacityResponse }
+export const LSPWarehouseGetOperationalCapacityRVS   = { headers: APIHeadersSchema, params: Type.Object({ id: Type.String() }), response: GetCapacityResponse }
+export const LSPWarehouseSetOperationalCapacityRVS   = { headers: APIHeadersSchema, params: Type.Object({ id: Type.String() }), body: Type.Any(), response: SetCapacityResponse }
+export const LSPWarehouseGetServiceLevelsCapacityRVS = { headers: APIHeadersSchema, params: Type.Object({ id: Type.String() }), response: GetCapacityResponse }
+export const LSPWarehouseSetServiceLevelsCapacityRVS = { headers: APIHeadersSchema, params: Type.Object({ id: Type.String() }), body: Type.Any(), response: SetCapacityResponse }
+export const LSPWarehouseGetResourcesCapacityRVS     = { headers: APIHeadersSchema, params: Type.Object({ id: Type.String() }), response: GetCapacityResponse }
+export const LSPWarehouseSetResourcesCapacityRVS     = { headers: APIHeadersSchema, params: Type.Object({ id: Type.String() }), body: Type.Any(), response: SetCapacityResponse }
+export const LSPWarehouseGetEnvironmentalCapacityRVS = { headers: APIHeadersSchema, params: Type.Object({ id: Type.String() }), response: GetCapacityResponse }
+export const LSPWarehouseSetEnvironmentalCapacityRVS = { headers: APIHeadersSchema, params: Type.Object({ id: Type.String() }), body: Type.Any(), response: SetCapacityResponse }
+export const LSPWarehouseGetFinancialCapacityRVS     = { headers: APIHeadersSchema, params: Type.Object({ id: Type.String() }), response: GetCapacityResponse }
+export const LSPWarehouseSetFinancialCapacityRVS     = { headers: APIHeadersSchema, params: Type.Object({ id: Type.String() }), body: Type.Any(), response: SetCapacityResponse }
+
+export type LSPWarehouseGetPhysicalCapacityValidation      = { headers: Static<typeof LSPWarehouseGetPhysicalCapacityRVS.headers>, params: Static<typeof LSPWarehouseGetPhysicalCapacityRVS.params>, response: Static<typeof LSPWarehouseGetPhysicalCapacityRVS.response> }
+export type LSPWarehouseSetPhysicalCapacityValidation      = { headers: Static<typeof LSPWarehouseSetPhysicalCapacityRVS.headers>, params: Static<typeof LSPWarehouseSetPhysicalCapacityRVS.params>, body: Static<typeof LSPWarehouseSetPhysicalCapacityRVS.body>, response: Static<typeof LSPWarehouseSetPhysicalCapacityRVS.response> }
+export type LSPWarehouseGetOperationalCapacityValidation   = { headers: Static<typeof LSPWarehouseGetOperationalCapacityRVS.headers>, params: Static<typeof LSPWarehouseGetOperationalCapacityRVS.params>, response: Static<typeof LSPWarehouseGetOperationalCapacityRVS.response> }
+export type LSPWarehouseSetOperationalCapacityValidation   = { headers: Static<typeof LSPWarehouseSetOperationalCapacityRVS.headers>, params: Static<typeof LSPWarehouseSetOperationalCapacityRVS.params>, body: Static<typeof LSPWarehouseSetOperationalCapacityRVS.body>, response: Static<typeof LSPWarehouseSetOperationalCapacityRVS.response> }
+export type LSPWarehouseGetServiceLevelsCapacityValidation = { headers: Static<typeof LSPWarehouseGetServiceLevelsCapacityRVS.headers>, params: Static<typeof LSPWarehouseGetServiceLevelsCapacityRVS.params>, response: Static<typeof LSPWarehouseGetServiceLevelsCapacityRVS.response> }
+export type LSPWarehouseSetServiceLevelsCapacityValidation = { headers: Static<typeof LSPWarehouseSetServiceLevelsCapacityRVS.headers>, params: Static<typeof LSPWarehouseSetServiceLevelsCapacityRVS.params>, body: Static<typeof LSPWarehouseSetServiceLevelsCapacityRVS.body>, response: Static<typeof LSPWarehouseSetServiceLevelsCapacityRVS.response> }
+export type LSPWarehouseGetResourcesCapacityValidation     = { headers: Static<typeof LSPWarehouseGetResourcesCapacityRVS.headers>, params: Static<typeof LSPWarehouseGetResourcesCapacityRVS.params>, response: Static<typeof LSPWarehouseGetResourcesCapacityRVS.response> }
+export type LSPWarehouseSetResourcesCapacityValidation     = { headers: Static<typeof LSPWarehouseSetResourcesCapacityRVS.headers>, params: Static<typeof LSPWarehouseSetResourcesCapacityRVS.params>, body: Static<typeof LSPWarehouseSetResourcesCapacityRVS.body>, response: Static<typeof LSPWarehouseSetResourcesCapacityRVS.response> }
+export type LSPWarehouseGetEnvironmentalCapacityValidation = { headers: Static<typeof LSPWarehouseGetEnvironmentalCapacityRVS.headers>, params: Static<typeof LSPWarehouseGetEnvironmentalCapacityRVS.params>, response: Static<typeof LSPWarehouseGetEnvironmentalCapacityRVS.response> }
+export type LSPWarehouseSetEnvironmentalCapacityValidation = { headers: Static<typeof LSPWarehouseSetEnvironmentalCapacityRVS.headers>, params: Static<typeof LSPWarehouseSetEnvironmentalCapacityRVS.params>, body: Static<typeof LSPWarehouseSetEnvironmentalCapacityRVS.body>, response: Static<typeof LSPWarehouseSetEnvironmentalCapacityRVS.response> }
+export type LSPWarehouseGetFinancialCapacityValidation     = { headers: Static<typeof LSPWarehouseGetFinancialCapacityRVS.headers>, params: Static<typeof LSPWarehouseGetFinancialCapacityRVS.params>, response: Static<typeof LSPWarehouseGetFinancialCapacityRVS.response> }
+export type LSPWarehouseSetFinancialCapacityValidation     = { headers: Static<typeof LSPWarehouseSetFinancialCapacityRVS.headers>, params: Static<typeof LSPWarehouseSetFinancialCapacityRVS.params>, body: Static<typeof LSPWarehouseSetFinancialCapacityRVS.body>, response: Static<typeof LSPWarehouseSetFinancialCapacityRVS.response> }