@de./types 1.0.0

package/src/lsp/fleet/parking.ts

@@ -0,0 +1,582 @@
+import { Type, Static } from '@sinclair/typebox'
+import { ContextSchema } from '../../context'
+import { ActionRecordSchema, DateTimeZoneSchema, DateTimeRangeSchema, DurationSchema } from '../../time'
+import { MoneySchema, DimensionsSchema, WeightSchema, LengthSchema, PerTimeSchema } from '../../measure'
+import { AddressSchema, ContactsSchema, CoordinatesSchema } from '../../geo'
+import { OperatingHoursSchema } from '../../entity'
+import { VehicleTypeSchema } from './vehicle'
+
+// Parking Type Schema
+export const ParkingTypeSchema = Type.Union([
+  // FACILITY TYPES
+  Type.Literal('DEPOT'),                // Main fleet depot/garage
+  Type.Literal('YARD'),                 // Open parking yard
+  Type.Literal('GARAGE'),               // Covered garage
+  Type.Literal('LOT'),                  // Parking lot
+  Type.Literal('STRUCTURE'),            // Multi-level parking structure
+  
+  // OPERATIONAL TYPES
+  Type.Literal('MAINTENANCE_FACILITY'), // Service/maintenance depot
+  Type.Literal('TERMINAL'),             // Transport terminal parking
+  Type.Literal('LAYOVER'),              // Driver rest/layover area
+  Type.Literal('STAGING'),              // Pre-trip staging area
+  Type.Literal('OVERFLOW'),             // Temporary/overflow parking
+  
+  // SPECIALIZED
+  Type.Literal('CHARGING_STATION'),     // EV charging depot
+  Type.Literal('FUEL_DEPOT'),           // Refueling facility
+  Type.Literal('WASH_BAY'),             // Vehicle wash facility
+  Type.Literal('SECURE_COMPOUND'),      // High-security parking
+
+  // MICRO-MOBILITY
+  Type.Literal('DOCKING_STATION'),      // E-scooter/e-bike docking hub
+  Type.Literal('BIKE_RACK'),            // Bicycle parking rack
+  Type.Literal('SCOOTER_ZONE'),         // Designated e-scooter parking zone
+  Type.Literal('MICRO_MOBILITY_HUB'),   // Multi-modal micro-mobility parking
+  Type.Literal('CHARGING_DOCK'),        // Charging dock station for e-scooters/e-bikes
+  
+  // TEMPORARY
+  Type.Literal('STREET_PARKING'),       // On-street parking
+  Type.Literal('TEMPORARY'),            // Temporary parking location
+  
+  Type.Literal('OTHER')
+])
+
+// Parking Status Schema
+export const ParkingStatusSchema = Type.Union([
+  Type.Literal('OPERATIONAL'),          // Actively in use
+  Type.Literal('MAINTENANCE'),          // Under maintenance
+  Type.Literal('FULL'),                 // At capacity
+  Type.Literal('CLOSED'),                // Temporarily closed
+  Type.Literal('DECOMMISSIONED')        // Permanently closed
+])
+
+// Parking Access Schema
+export const ParkingAccessSchema = Type.Union([
+  Type.Literal('24_7'),                 // Round-the-clock access
+  Type.Literal('SCHEDULED'),            // Specific hours
+  Type.Literal('ON_DEMAND'),            // By arrangement
+  Type.Literal('RESTRICTED')            // Limited/controlled access
+])
+
+// Parking Security Level Schema
+export const ParkingSecurityLevelSchema = Type.Union([
+  Type.Literal('BASIC'),                // Open/minimal security
+  Type.Literal('STANDARD'),             // Fenced with basic monitoring
+  Type.Literal('ENHANCED'),             // CCTV, security personnel
+  Type.Literal('MAXIMUM')               // High-security compound
+])
+
+// Parking Amenities Schema
+export const ParkingAmenitiesSchema = Type.Object({
+  // Basic Facilities
+  covered: Type.Boolean({ default: false }),
+  lighting: Type.Boolean({ default: false }),
+  fenced: Type.Boolean({ default: false }),
+  paved: Type.Boolean({ default: false }),
+  
+  // Security
+  cctv: Type.Boolean({ default: false }),
+  securityPersonnel: Type.Boolean({ default: false }),
+  gatedAccess: Type.Boolean({ default: false }),
+  
+  // Services
+  electricCharging: Type.Optional(Type.Object({
+    available: Type.Boolean(),
+    chargingPoints: Type.Number({ minimum: 0 }),
+    maxPower: Type.Optional(Type.String()), // e.g., "150kW"
+    connectorTypes: Type.Optional(Type.Array(Type.String())) // e.g., ["CCS", "CHAdeMO"]
+  })),
+  fuelStation: Type.Optional(Type.Object({
+    available: Type.Boolean(),
+    fuelTypes: Type.Array(Type.String()) // e.g., ["diesel", "gasoline", "CNG"]
+  })),
+  washBay: Type.Boolean({ default: false }),
+  maintenanceBay: Type.Boolean({ default: false }),
+  
+  // Micro-Mobility Specific
+  microMobility: Type.Optional(Type.Object({
+    dockingStations: Type.Optional(Type.Number({ minimum: 0 })),
+    chargingDocks: Type.Optional(Type.Number({ minimum: 0 })),
+    bikeRacks: Type.Optional(Type.Number({ minimum: 0 })),
+    lockingMechanism: Type.Optional(Type.Union([
+      Type.Literal('PHYSICAL_LOCK'),
+      Type.Literal('ELECTRONIC_DOCK'),
+      Type.Literal('QR_CODE'),
+      Type.Literal('GEOFENCE')
+    ])),
+    swapStation: Type.Optional(Type.Boolean()), // Battery swap capability
+    repairStation: Type.Optional(Type.Boolean()) // On-site repair tools
+  })),
+  
+  // Driver Facilities
+  restroom: Type.Boolean({ default: false }),
+  restArea: Type.Boolean({ default: false }),
+  office: Type.Boolean({ default: false }),
+  wifi: Type.Boolean({ default: false }),
+  
+  // Access
+  wheelchairAccessible: Type.Boolean({ default: false }),
+  truckAccess: Type.Boolean({ default: false }),
+  heightClearance: Type.Optional(LengthSchema)
+})
+
+// Parking Space Schema
+const ParkingSpaceTypeSchema = Type.Union([
+  Type.Literal('STANDARD'),
+  Type.Literal('COMPACT'),
+  Type.Literal('OVERSIZED'),
+  Type.Literal('ACCESSIBLE'),
+  Type.Literal('EV_CHARGING'),
+  Type.Literal('BIKE_SLOT'),           // Bicycle parking slot
+  Type.Literal('SCOOTER_SLOT'),        // E-scooter parking slot
+  Type.Literal('DOCKING_SLOT'),        // Electronic docking slot
+  Type.Literal('MICRO_MOBILITY'),      // General micro-mobility space
+  Type.Literal('MAINTENANCE')
+])
+const ParkingSpaceStatusSchema = Type.Union([
+  Type.Literal('AVAILABLE'),
+  Type.Literal('OCCUPIED'),
+  Type.Literal('RESERVED'),
+  Type.Literal('MAINTENANCE'),
+  Type.Literal('OUT_OF_SERVICE')
+])
+export const ParkingSpaceSchema = Type.Object({
+  id: Type.String(),
+  zone: Type.Optional(Type.String()), // e.g., "Zone A", "Bay 1"
+  spaceNumber: Type.String(),
+  dimensions: Type.Optional(DimensionsSchema),
+  
+  // Space Specifications
+  type: ParkingSpaceTypeSchema,
+  // Availability
+  status: ParkingSpaceStatusSchema,
+  // Current Occupant
+  occupiedBy: Type.Optional(Type.Object({
+    vid: Type.String(),
+    since: DateTimeZoneSchema,
+    expectedDeparture: Type.Optional(DateTimeZoneSchema)
+  })),
+  // Restrictions
+  restrictions: Type.Optional(Type.Object({
+    vehicleTypes: Type.Optional(Type.Array(VehicleTypeSchema)),
+    maxWeight: Type.Optional(WeightSchema),
+    maxHeight: Type.Optional(LengthSchema)
+  })),
+  // Features
+  hasCharging: Type.Boolean({ default: false }),
+  isCovered: Type.Boolean({ default: false }),
+  accessible: Type.Boolean({ default: false })
+})
+
+// Parking Assignment Schema
+export const ParkingAssignmentTypeSchema = Type.Union([
+  Type.Literal('PERMANENT'),          // Long-term assigned space
+  Type.Literal('TEMPORARY'),          // Short-term parking
+  Type.Literal('OVERNIGHT'),          // Overnight parking
+  Type.Literal('MAINTENANCE'),        // For maintenance/repair
+  Type.Literal('LAYOVER')             // Driver rest period
+])
+export const ParkingAssignmentStatusSchema = Type.Union([
+  Type.Literal('ACTIVE'),
+  Type.Literal('COMPLETED'),
+  Type.Literal('CANCELLED'),
+  Type.Literal('NO_SHOW')
+])
+export const ParkingAssignmentSchema = Type.Object({
+  id: Type.String(),
+  parkingId: Type.String(),
+  spaceId: Type.Optional(Type.String()),
+  vid: Type.String(),
+  
+  // Assignment Details
+  type: ParkingAssignmentTypeSchema,
+  // Status
+  status: ParkingAssignmentStatusSchema,
+  
+  period: Type.Object({
+    start: DateTimeZoneSchema,
+    end: Type.Optional(DateTimeZoneSchema)
+  }),
+  
+  // Check-in/out
+  checkIn: Type.Optional(Type.Composite([
+    ActionRecordSchema,
+    Type.Object({
+      agentId: Type.String(),
+      mileage: Type.Optional(Type.Number())
+    })
+  ])),
+  checkOut: Type.Optional(Type.Composite([
+    ActionRecordSchema,
+    Type.Object({
+      agentId: Type.String(),
+      mileage: Type.Optional(Type.Number())
+    })
+  ])),
+  
+  // Additional Info
+  purpose: Type.Optional(Type.String({ maxLength: 200 })),
+  notes: Type.Optional(Type.String({ maxLength: 500 })),
+  
+  created: ActionRecordSchema,
+  updated: Type.Optional(ActionRecordSchema)
+})
+
+// Main Parking Facility Schema
+export const ParkingFacilitySchema = Type.Object({
+  context: ContextSchema,
+  id: Type.String(),
+  
+  // Basic Information
+  name: Type.String({ maxLength: 100 }),
+  type: ParkingTypeSchema,
+  status: ParkingStatusSchema,
+  
+  // Location
+  address: AddressSchema,
+  
+  // Capacity
+  capacity: Type.Object({
+    total: Type.Number({ minimum: 0 }),
+    available: Type.Number({ minimum: 0 }),
+    occupied: Type.Number({ minimum: 0 }),
+    reserved: Type.Number({ minimum: 0 }),
+    outOfService: Type.Number({ minimum: 0 })
+  }),
+  
+  // Breakdown by vehicle type
+  capacityByType: Type.Optional(Type.Record(Type.String(), Type.Object({
+    total: Type.Number({ minimum: 0 }),
+    available: Type.Number({ minimum: 0 })
+  }))),
+  
+  // Spaces
+  spaces: Type.Optional(Type.Array(ParkingSpaceSchema)),
+  
+  // Access & Security
+  access: Type.Object({
+    type: ParkingAccessSchema,
+    hours: Type.Optional(Type.Object({
+      weekday: Type.Optional(Type.String()), // e.g., "06:00-22:00"
+      weekend: Type.Optional(Type.String()),
+      holiday: Type.Optional(Type.String())
+    })),
+    restrictions: Type.Optional(Type.Array(Type.String()))
+  }),
+  
+  securityLevel: ParkingSecurityLevelSchema,
+  
+  // Amenities
+  amenities: ParkingAmenitiesSchema,
+  
+  // Contact & Management
+  contacts: Type.Optional(ContactsSchema),
+  managedBy: Type.Optional(Type.String()), // Manager/Company ID
+  
+  // Financial
+  costs: Type.Optional(Type.Object({
+    dailyRate: Type.Optional(MoneySchema),
+    monthlyRate: Type.Optional(MoneySchema),
+    maintenanceBudget: Type.Optional(MoneySchema)
+  })),
+  
+  // Operational
+  operationalHours: Type.Optional(OperatingHoursSchema),
+  
+  // Connected Facilities
+  nearbyFacilities: Type.Optional(Type.Array(Type.Object({
+    type: Type.String(), // e.g., "fuel_station", "maintenance_facility"
+    id: Type.String(),
+    distance: LengthSchema
+  }))),
+  
+  // Fleet Assignment
+  assignedFleets: Type.Optional(Type.Array(Type.String())), // Fleet IDs
+  
+  // Metadata
+  notes: Type.Optional(Type.String({ maxLength: 1000 })),
+  tags: Type.Optional(Type.Array(Type.String())),
+  
+  created: ActionRecordSchema,
+  updated: Type.Optional(ActionRecordSchema)
+}, { additionalProperties: false })
+
+// Parking Utilization Schema
+export const ParkingUtilizationSchema = Type.Object({
+  parkingId: Type.String(),
+  period: DateTimeRangeSchema,
+  
+  // Utilization Metrics
+  metrics: Type.Object({
+    averageOccupancy: Type.Number({ minimum: 0, maximum: 100, description: 'percentage' }),
+    peakOccupancy: Type.Number({ minimum: 0, maximum: 100 }),
+    averageDuration: DurationSchema, // hours
+    totalVehicles: Type.Number({ minimum: 0 }),
+    turnoverRate: PerTimeSchema // Vehicles per day
+  }),
+  
+  // Time-based Analysis
+  occupancyByHour: Type.Optional(Type.Record(Type.String(), Type.Number())),
+  occupancyByDay: Type.Optional(Type.Record(Type.String(), Type.Number())),
+  
+  // Vehicle Type Distribution
+  byVehicleType: Type.Optional(Type.Record(Type.String(), Type.Object({
+    count: Type.Number({ minimum: 0 }),
+    averageDuration: Type.Number({ minimum: 0 })
+  }))),
+  
+  // Revenue (if applicable)
+  revenue: Type.Optional(MoneySchema),
+  
+  // Issues
+  incidents: Type.Optional(Type.Object({
+    unauthorized: Type.Number({ minimum: 0 }),
+    violations: Type.Number({ minimum: 0 }),
+    damages: Type.Number({ minimum: 0 })
+  }))
+})
+
+// Parking Reservation Schema
+export const ParkingReservationStatusSchema = Type.Union([
+  Type.Literal('PENDING'),
+  Type.Literal('CONFIRMED'),
+  Type.Literal('ACTIVE'),
+  Type.Literal('COMPLETED'),
+  Type.Literal('CANCELLED'),
+  Type.Literal('NO_SHOW')
+])
+export const ParkingReservationSchema = Type.Object({
+  id: Type.String(),
+  parkingId: Type.String(),
+  spaceId: Type.Optional(Type.String()),
+  
+  // Reservation Details
+  vid: Type.String(),
+  fleetId: Type.Optional(Type.String()),
+  
+  period: DateTimeRangeSchema,
+  
+  // Status
+  status: ParkingReservationStatusSchema,
+  
+  // Requester
+  requested: ActionRecordSchema,
+  purpose: Type.Optional(Type.String({ maxLength: 200 })),
+  
+  // Pricing
+  cost: Type.Optional(MoneySchema),
+  
+  // Special Requirements
+  requirements: Type.Optional(Type.Object({
+    charging: Type.Boolean({ default: false }),
+    covered: Type.Boolean({ default: false }),
+    maintenance: Type.Boolean({ default: false }),
+    security: Type.Optional(ParkingSecurityLevelSchema)
+  })),
+  
+  notes: Type.Optional(Type.String({ maxLength: 500 })),
+  
+  created: ActionRecordSchema,
+  updated: Type.Optional(ActionRecordSchema)
+})
+
+// Update Schemas
+export const ParkingFacilityUpdateSchema = Type.Partial(Type.Omit(ParkingFacilitySchema, ['id', 'context', 'created']))
+export const ParkingSpaceUpdateSchema = Type.Partial(Type.Omit(ParkingSpaceSchema, ['id']))
+export const ParkingAssignmentUpdateSchema = Type.Partial(Type.Omit(ParkingAssignmentSchema, ['id', 'created']))
+export const ParkingReservationUpdateSchema = Type.Partial(Type.Omit(ParkingReservationSchema, ['id', 'created']))
+
+// TypeScript Types
+export type ParkingType = Static<typeof ParkingTypeSchema>
+export type ParkingStatus = Static<typeof ParkingStatusSchema>
+export type ParkingAccess = Static<typeof ParkingAccessSchema>
+export type ParkingSecurityLevel = Static<typeof ParkingSecurityLevelSchema>
+export type ParkingAmenities = Static<typeof ParkingAmenitiesSchema>
+export type ParkingSpaceType = Static<typeof ParkingSpaceTypeSchema>
+export type ParkingSpaceStatus = Static<typeof ParkingSpaceStatusSchema>
+export type ParkingSpace = Static<typeof ParkingSpaceSchema>
+export type ParkingAssignmentType = Static<typeof ParkingAssignmentTypeSchema>
+export type ParkingAssignmentStatus = Static<typeof ParkingAssignmentStatusSchema>
+export type ParkingAssignment = Static<typeof ParkingAssignmentSchema>
+export type ParkingFacility = Static<typeof ParkingFacilitySchema>
+export type ParkingUtilization = Static<typeof ParkingUtilizationSchema>
+export type ParkingReservationStatus = Static<typeof ParkingReservationStatusSchema>
+export type ParkingReservation = Static<typeof ParkingReservationSchema>
+export type ParkingFacilityUpdate = Static<typeof ParkingFacilityUpdateSchema>
+export type ParkingSpaceUpdate = Static<typeof ParkingSpaceUpdateSchema>
+export type ParkingAssignmentUpdate = Static<typeof ParkingAssignmentUpdateSchema>
+export type ParkingReservationUpdate = Static<typeof ParkingReservationUpdateSchema>
+// ─── Request Validation Schemas ───────────────────────────────────────────────
+
+import {
+	APIHeadersSchema,
+	APIResponseBaseSchema,
+	APIResponseDataSchemaFactory,
+	FetchByQueryRequestSchema,
+	FetchByQueryRequest
+} from '../../api'
+
+export const LSPFleetParkingAddFacilityRVS = {
+	headers:  APIHeadersSchema,
+	body:     Type.Omit(ParkingFacilitySchema, ['id', 'context', 'capacity', 'created', 'updated']),
+	response: APIResponseDataSchemaFactory({ parkingId: Type.String() })
+}
+
+export const LSPFleetParkingRetrieveFacilityRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	response: APIResponseDataSchemaFactory({ parking: ParkingFacilitySchema })
+}
+
+export const LSPFleetParkingFetchFacilitiesRVS = {
+	headers:     APIHeadersSchema,
+	querystring: FetchByQueryRequestSchema,
+	response: APIResponseDataSchemaFactory({ parkings: Type.Array(ParkingFacilitySchema) })
+}
+
+export const LSPFleetParkingUpdateFacilityRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     ParkingFacilityUpdateSchema,
+	response: APIResponseDataSchemaFactory({ parking: ParkingFacilitySchema })
+}
+
+export const LSPFleetParkingRemoveFacilityRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     Type.Object({ reason: Type.String() }),
+	response: APIResponseBaseSchema
+}
+
+export const LSPFleetParkingAddSpaceRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     Type.Omit(ParkingSpaceSchema, ['id', 'status', 'occupiedBy']),
+	response: APIResponseDataSchemaFactory({ spaceId: Type.String() })
+}
+
+export const LSPFleetParkingUpdateSpaceRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String(), spaceId: Type.String() }),
+	body:     ParkingSpaceUpdateSchema,
+	response: APIResponseDataSchemaFactory({ space: ParkingSpaceSchema })
+}
+
+export const LSPFleetParkingRemoveSpaceRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String(), spaceId: Type.String() }),
+	response: APIResponseBaseSchema
+}
+
+export const LSPFleetParkingCreateAssignmentRVS = {
+	headers:  APIHeadersSchema,
+	body:     Type.Omit(ParkingAssignmentSchema, ['id', 'status', 'checkIn', 'checkOut', 'created', 'updated']),
+	response: APIResponseDataSchemaFactory({ assignmentId: Type.String() })
+}
+
+export const LSPFleetParkingRetrieveAssignmentRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	response: APIResponseDataSchemaFactory({ assignment: ParkingAssignmentSchema })
+}
+
+export const LSPFleetParkingFetchAssignmentsRVS = {
+	headers:     APIHeadersSchema,
+	querystring: FetchByQueryRequestSchema,
+	response: APIResponseDataSchemaFactory({ assignments: Type.Array(ParkingAssignmentSchema) })
+}
+
+export const LSPFleetParkingUpdateAssignmentRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     ParkingAssignmentUpdateSchema,
+	response: APIResponseDataSchemaFactory({ assignment: ParkingAssignmentSchema })
+}
+
+export const LSPFleetParkingCheckInRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     Type.Object({ mileage: Type.Optional(Type.Number()) }),
+	response: APIResponseBaseSchema
+}
+
+export const LSPFleetParkingCheckOutRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     Type.Object({ mileage: Type.Optional(Type.Number()) }),
+	response: APIResponseBaseSchema
+}
+
+export const LSPFleetParkingCancelAssignmentRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	response: APIResponseBaseSchema
+}
+
+export const LSPFleetParkingCreateReservationRVS = {
+	headers:  APIHeadersSchema,
+	body:     Type.Omit(ParkingReservationSchema, ['id', 'status', 'created', 'updated']),
+	response: APIResponseDataSchemaFactory({ reservationId: Type.String() })
+}
+
+export const LSPFleetParkingRetrieveReservationRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	response: APIResponseDataSchemaFactory({ reservation: ParkingReservationSchema })
+}
+
+export const LSPFleetParkingFetchReservationsRVS = {
+	headers:     APIHeadersSchema,
+	querystring: FetchByQueryRequestSchema,
+	response: APIResponseDataSchemaFactory({ reservations: Type.Array(ParkingReservationSchema) })
+}
+
+export const LSPFleetParkingUpdateReservationRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     ParkingReservationUpdateSchema,
+	response: APIResponseDataSchemaFactory({ reservation: ParkingReservationSchema })
+}
+
+export const LSPFleetParkingConfirmReservationRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	response: APIResponseBaseSchema
+}
+
+export const LSPFleetParkingCancelReservationRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	response: APIResponseBaseSchema
+}
+
+export const LSPFleetParkingGetUtilizationRVS = {
+	headers:     APIHeadersSchema,
+	params:      Type.Object({ id: Type.String() }),
+	querystring: Type.Object({ start: Type.String(), end: Type.String() }),
+	response: APIResponseDataSchemaFactory({ utilization: ParkingUtilizationSchema })
+}
+
+export type LSPFleetParkingAddFacilityValidation        = { headers: Static<typeof LSPFleetParkingAddFacilityRVS.headers>, body: Static<typeof LSPFleetParkingAddFacilityRVS.body>, response: Static<typeof LSPFleetParkingAddFacilityRVS.response> }
+export type LSPFleetParkingRetrieveFacilityValidation   = { headers: Static<typeof LSPFleetParkingRetrieveFacilityRVS.headers>, params: Static<typeof LSPFleetParkingRetrieveFacilityRVS.params>, response: Static<typeof LSPFleetParkingRetrieveFacilityRVS.response> }
+export type LSPFleetParkingFetchFacilitiesValidation    = { headers: Static<typeof LSPFleetParkingFetchFacilitiesRVS.headers>, querystring: Static<typeof LSPFleetParkingFetchFacilitiesRVS.querystring>, response: Static<typeof LSPFleetParkingFetchFacilitiesRVS.response> }
+export type LSPFleetParkingUpdateFacilityValidation     = { headers: Static<typeof LSPFleetParkingUpdateFacilityRVS.headers>, params: Static<typeof LSPFleetParkingUpdateFacilityRVS.params>, body: Static<typeof LSPFleetParkingUpdateFacilityRVS.body>, response: Static<typeof LSPFleetParkingUpdateFacilityRVS.response> }
+export type LSPFleetParkingRemoveFacilityValidation     = { headers: Static<typeof LSPFleetParkingRemoveFacilityRVS.headers>, params: Static<typeof LSPFleetParkingRemoveFacilityRVS.params>, body: Static<typeof LSPFleetParkingRemoveFacilityRVS.body>, response: Static<typeof LSPFleetParkingRemoveFacilityRVS.response> }
+export type LSPFleetParkingAddSpaceValidation           = { headers: Static<typeof LSPFleetParkingAddSpaceRVS.headers>, params: Static<typeof LSPFleetParkingAddSpaceRVS.params>, body: Static<typeof LSPFleetParkingAddSpaceRVS.body>, response: Static<typeof LSPFleetParkingAddSpaceRVS.response> }
+export type LSPFleetParkingUpdateSpaceValidation        = { headers: Static<typeof LSPFleetParkingUpdateSpaceRVS.headers>, params: Static<typeof LSPFleetParkingUpdateSpaceRVS.params>, body: Static<typeof LSPFleetParkingUpdateSpaceRVS.body>, response: Static<typeof LSPFleetParkingUpdateSpaceRVS.response> }
+export type LSPFleetParkingRemoveSpaceValidation        = { headers: Static<typeof LSPFleetParkingRemoveSpaceRVS.headers>, params: Static<typeof LSPFleetParkingRemoveSpaceRVS.params>, response: Static<typeof LSPFleetParkingRemoveSpaceRVS.response> }
+export type LSPFleetParkingCreateAssignmentValidation   = { headers: Static<typeof LSPFleetParkingCreateAssignmentRVS.headers>, body: Static<typeof LSPFleetParkingCreateAssignmentRVS.body>, response: Static<typeof LSPFleetParkingCreateAssignmentRVS.response> }
+export type LSPFleetParkingRetrieveAssignmentValidation = { headers: Static<typeof LSPFleetParkingRetrieveAssignmentRVS.headers>, params: Static<typeof LSPFleetParkingRetrieveAssignmentRVS.params>, response: Static<typeof LSPFleetParkingRetrieveAssignmentRVS.response> }
+export type LSPFleetParkingFetchAssignmentsValidation   = { headers: Static<typeof LSPFleetParkingFetchAssignmentsRVS.headers>, querystring: Static<typeof LSPFleetParkingFetchAssignmentsRVS.querystring>, response: Static<typeof LSPFleetParkingFetchAssignmentsRVS.response> }
+export type LSPFleetParkingUpdateAssignmentValidation   = { headers: Static<typeof LSPFleetParkingUpdateAssignmentRVS.headers>, params: Static<typeof LSPFleetParkingUpdateAssignmentRVS.params>, body: Static<typeof LSPFleetParkingUpdateAssignmentRVS.body>, response: Static<typeof LSPFleetParkingUpdateAssignmentRVS.response> }
+export type LSPFleetParkingCheckInValidation            = { headers: Static<typeof LSPFleetParkingCheckInRVS.headers>, params: Static<typeof LSPFleetParkingCheckInRVS.params>, body: Static<typeof LSPFleetParkingCheckInRVS.body>, response: Static<typeof LSPFleetParkingCheckInRVS.response> }
+export type LSPFleetParkingCheckOutValidation           = { headers: Static<typeof LSPFleetParkingCheckOutRVS.headers>, params: Static<typeof LSPFleetParkingCheckOutRVS.params>, body: Static<typeof LSPFleetParkingCheckOutRVS.body>, response: Static<typeof LSPFleetParkingCheckOutRVS.response> }
+export type LSPFleetParkingCancelAssignmentValidation   = { headers: Static<typeof LSPFleetParkingCancelAssignmentRVS.headers>, params: Static<typeof LSPFleetParkingCancelAssignmentRVS.params>, response: Static<typeof LSPFleetParkingCancelAssignmentRVS.response> }
+export type LSPFleetParkingCreateReservationValidation  = { headers: Static<typeof LSPFleetParkingCreateReservationRVS.headers>, body: Static<typeof LSPFleetParkingCreateReservationRVS.body>, response: Static<typeof LSPFleetParkingCreateReservationRVS.response> }
+export type LSPFleetParkingRetrieveReservationValidation = { headers: Static<typeof LSPFleetParkingRetrieveReservationRVS.headers>, params: Static<typeof LSPFleetParkingRetrieveReservationRVS.params>, response: Static<typeof LSPFleetParkingRetrieveReservationRVS.response> }
+export type LSPFleetParkingFetchReservationsValidation  = { headers: Static<typeof LSPFleetParkingFetchReservationsRVS.headers>, querystring: Static<typeof LSPFleetParkingFetchReservationsRVS.querystring>, response: Static<typeof LSPFleetParkingFetchReservationsRVS.response> }
+export type LSPFleetParkingUpdateReservationValidation  = { headers: Static<typeof LSPFleetParkingUpdateReservationRVS.headers>, params: Static<typeof LSPFleetParkingUpdateReservationRVS.params>, body: Static<typeof LSPFleetParkingUpdateReservationRVS.body>, response: Static<typeof LSPFleetParkingUpdateReservationRVS.response> }
+export type LSPFleetParkingConfirmReservationValidation = { headers: Static<typeof LSPFleetParkingConfirmReservationRVS.headers>, params: Static<typeof LSPFleetParkingConfirmReservationRVS.params>, response: Static<typeof LSPFleetParkingConfirmReservationRVS.response> }
+export type LSPFleetParkingCancelReservationValidation  = { headers: Static<typeof LSPFleetParkingCancelReservationRVS.headers>, params: Static<typeof LSPFleetParkingCancelReservationRVS.params>, response: Static<typeof LSPFleetParkingCancelReservationRVS.response> }
+export type LSPFleetParkingGetUtilizationValidation     = { headers: Static<typeof LSPFleetParkingGetUtilizationRVS.headers>, params: Static<typeof LSPFleetParkingGetUtilizationRVS.params>, querystring: Static<typeof LSPFleetParkingGetUtilizationRVS.querystring>, response: Static<typeof LSPFleetParkingGetUtilizationRVS.response> }