@de./types 1.0.0

package/src/lsp/coverage.ts

@@ -0,0 +1,869 @@
+import { Type, Static } from '@sinclair/typebox'
+import { LSPNetworkNodeSchema } from '.'
+import { VehicleTypeSchema } from './fleet/vehicle'
+import { ParkingTypeSchema } from './fleet/parking'
+import { ActionRecordSchema, DateTimeZoneSchema, DurationRangeSchema, TimeSchema, WeekDaySchema } from '../time'
+import { DistanceSchema, MoneySchema, PerTimeSchema, ServiceLevelSchema, VolumeSchema, WeightSchema } from '../measure'
+import { ContextSchema } from '../context'
+import { EntityStatusSchema } from '../entity'
+import { GeoBoundarySchema } from '../geo'
+
+export const CoverageReachSchema = Type.Union([
+  Type.Literal('INTERNATIONAL'),
+  Type.Literal('INTERSTATE'),
+  Type.Literal('NATIONAL'),
+  Type.Literal('REGIONAL'),
+  Type.Literal('LOCAL'),
+  Type.Literal('MICRO')
+])
+export const CoverageTransitModeSchema = Type.Union([
+  Type.Literal('ROAD'), // Road freight transport
+  Type.Literal('AIR'), // Air freight transport
+  Type.Literal('RAIL'), // Rail freight transport
+  Type.Literal('SEA'), // Sea freight transport
+  Type.Literal('BARGE'), // Inland waterway transport
+  Type.Literal('PIPELINE'), // Pipeline transport (oil, gas, liquids)
+])
+export const CoverageTransitTypeSchema = Type.Union([
+  Type.Literal('CROSS_BORDER'),
+  Type.Literal('INTERMODAL'),
+  Type.Literal('MULTIMODAL'),
+  Type.Literal('LAST_MILE'),
+  Type.Literal('MIDDLE_MILE'),
+  Type.Literal('LONG_HAUL'),
+  Type.Literal('LINEHAUL'),
+  // REVIEW
+  Type.Literal('PICKUP_DELIVERY'),
+
+  Type.Literal('HUB_TO_HUB'),
+  Type.Literal('HUB_TO_TERMINAL'),
+  Type.Literal('HUB_TO_WAREHOUSE'),
+
+  Type.Literal('TERMINAL_TO_TERMINAL'),
+  Type.Literal('TERMINAL_TO_HUB'),
+  Type.Literal('TERMINAL_TO_WAREHOUSE'),
+
+  Type.Literal('WAREHOUSE_TO_WAREHOUSE'),
+  Type.Literal('WAREHOUSE_TO_TERMINAL'),
+  Type.Literal('WAREHOUSE_TO_HUB'),
+
+  Type.Literal('POINT_TO_POINT'),
+  Type.Literal('MULTI_STOP'),
+  Type.Literal('MILK_RUN'),
+  Type.Literal('CONSOLIDATION'),
+  Type.Literal('DECONSOLIDATION')
+])
+export const CoverageTransitSchema = Type.Object({
+  type: CoverageTransitTypeSchema,
+  mode: CoverageTransitModeSchema,
+  time: DurationRangeSchema, // in Hours
+  /**
+   * Declare other hubs/terminals/warehouses/points
+   * directly linked to this point of the coverage.
+   */
+  nodes: Type.Optional(Type.Array(LSPNetworkNodeSchema))
+})
+export const CoverageScheduleSchema = Type.Object({
+  frequency: Type.Union([
+    Type.Literal('HOURLY'),
+    Type.Literal('DAILY'),
+    Type.Literal('WEEKLY'),
+    Type.Literal('ON_DEMAND')
+  ]),
+  departureTimes: Type.Array(TimeSchema),
+  arrivalTimes: Type.Optional(Type.Array(TimeSchema)),
+  operatingDays: Type.Array(WeekDaySchema)
+})
+export const CoverageCapacitySchema = Type.Object({
+  freight:  Type.Object({
+    volume: VolumeSchema,
+    weight: WeightSchema,
+    packages: Type.Optional(Type.Number({ minimum: 0 }))
+  }),
+  passenger:  Type.Object({
+    seats: Type.Number({ minimum: 0 }),
+    weight: Type.Optional(WeightSchema),
+    packages: Type.Optional(Type.Number({ minimum: 0 }))
+  })
+})
+export const CoverageRestrictionTypeSchema = Type.Union([
+  Type.Literal('SPEED_LIMIT'),
+  Type.Literal('NO_GO_ZONE'),
+  Type.Literal('PARKING'),
+  Type.Literal('TIME_RESTRICTION'),
+  Type.Literal('VEHICLE_TYPE'),
+  Type.Literal('WEIGHT_LIMIT'),
+  Type.Literal('HEIGHT_LIMIT'),
+  Type.Literal('OTHER')
+])
+export const CoverageRestrictionSchema = Type.Object({
+  type: CoverageRestrictionTypeSchema,
+  code: Type.String(),
+  label: Type.String(),
+  reason: Type.String(),
+  alternativeOptions: Type.Optional(Type.Array(Type.String())),
+  
+  // Vehicle-specific restrictions (for mobility, fleet, e-scooters)
+  vehicleType: Type.Optional(VehicleTypeSchema),
+  speedLimit: Type.Optional(Type.Object({
+    value: Type.Number({ minimum: 0 }),
+    unit: Type.Union([
+      Type.Literal('KM_PER_HOUR'),
+      Type.Literal('MPH')
+    ])
+  })),
+  allowed: Type.Optional(Type.Boolean()),
+  activeHours: Type.Optional(Type.Object({
+    start: TimeSchema,
+    end: TimeSchema,
+    days: Type.Optional(Type.Array(WeekDaySchema))
+  })),
+  severity: Type.Optional(Type.Union([
+    Type.Literal('WARNING'),
+    Type.Literal('ENFORCED'),
+    Type.Literal('CRITICAL')
+  ])),
+  
+  // Parking-specific restrictions (when type = 'PARKING')
+  parkingTypes: Type.Optional(Type.Array(ParkingTypeSchema)),  // Allowed/restricted parking types
+  parkingCapacity: Type.Optional(Type.Object({
+    max: Type.Number({ minimum: 0 }),
+    unit: Type.Union([
+      Type.Literal('VEHICLES'),
+      Type.Literal('SPACES')
+    ])
+  })),
+  chargingRequired: Type.Optional(Type.Boolean()),  // Must park at charging dock when battery low
+  minimumBatteryLevel: Type.Optional(Type.Number({ minimum: 0, maximum: 100 }))  // % threshold for charging enforcement
+})
+export const CoveragePerformanceSchema = Type.Object({
+  reliability: Type.Number({ minimum: 0, maximum: 100, description: 'percentage' }),
+  averageDelay: PerTimeSchema, // minutes,
+  capacityUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+  cost: Type.Optional(MoneySchema)
+})
+
+export const CoverageSegmentTypeSchema = Type.Union([
+  Type.Literal('AREA'), 
+  Type.Literal('ROUTE')
+])
+export const CoverageSegmentBaseSchema = Type.Object({
+  context: ContextSchema,
+  id: Type.String(),
+  code: Type.String(),
+  name: Type.String(),
+  status: EntityStatusSchema,
+  reach: CoverageReachSchema,
+  serviceLevel: ServiceLevelSchema,
+  transit: CoverageTransitSchema,
+  cutoffTime: Type.Optional(DateTimeZoneSchema), // "15:00"
+  schedules: CoverageScheduleSchema,
+  capacity: CoverageCapacitySchema,
+  restrictions: Type.Optional(Type.Array(CoverageRestrictionSchema)),
+  isGuaranteed: Type.Boolean(),
+
+  // Performance
+  performance: Type.Optional(CoveragePerformanceSchema),
+
+  added: ActionRecordSchema,
+  updated: Type.Optional(ActionRecordSchema)
+}, { additionalProperties: false })
+
+export const CoverageAreaTypeSchema = Type.Union([
+  Type.Literal('CITY'),
+  Type.Literal('TOWN'),
+  Type.Literal('METROPOLITAN'),
+  Type.Literal('COUNTY'),
+  Type.Literal('STATE'),
+  Type.Literal('REGION'),
+  Type.Literal('COUNTRY'),
+  Type.Literal('CUSTOM_ZONE')
+])
+export const CoverageCityAreaSchema = Type.Composite([
+  CoverageSegmentBaseSchema,
+  Type.Object({
+    type: Type.Literal('AREA'),
+    areaType: Type.Literal('CITY'),
+    linkedTo: Type.Array(LSPNetworkNodeSchema),
+
+    country: Type.String({ minLength: 2, maxLength: 2 }),
+    region: Type.String({ minLength: 1, maxLength: 100 }),
+    state: Type.Optional(Type.String({ minLength: 1, maxLength: 100 })),
+    city: Type.String({ minLength: 1, maxLength: 100 }),
+  }, { additionalProperties: false })
+])
+export const CoverageTownAreaSchema = Type.Composite([
+  CoverageSegmentBaseSchema,
+  Type.Object({
+    type: Type.Literal('AREA'),
+    areaType: Type.Literal('TOWN'),
+    linkedTo: Type.Array(LSPNetworkNodeSchema),
+
+    country: Type.String({ minLength: 2, maxLength: 2 }),
+    region: Type.String({ minLength: 1, maxLength: 100 }),
+    state: Type.Optional(Type.String({ minLength: 1, maxLength: 100 })),
+    town: Type.String({ minLength: 1, maxLength: 100 }),
+  }, { additionalProperties: false })
+])
+export const CoverageMetropolitanAreaSchema = Type.Composite([
+  CoverageSegmentBaseSchema,
+  Type.Object({
+    type: Type.Literal('AREA'),
+    areaType: Type.Literal('METROPOLITAN'),
+    linkedTo: Type.Array(LSPNetworkNodeSchema),
+
+    country: Type.String({ minLength: 2, maxLength: 2 }), // Country code
+    region: Type.String({ minLength: 1, maxLength: 100 }),
+    state: Type.Optional(Type.String({ minLength: 1, maxLength: 100 })),
+    metropolitan: Type.String({ minLength: 1, maxLength: 100 })
+  }, { additionalProperties: false })
+])
+export const CoverageCountyAreaSchema = Type.Composite([
+  CoverageSegmentBaseSchema,
+  Type.Object({
+    type: Type.Literal('AREA'),
+    areaType: Type.Literal('COUNTY'),
+    linkedTo: Type.Array(LSPNetworkNodeSchema),
+    
+    country: Type.String({ minLength: 2, maxLength: 2 }), // Country code
+    region: Type.String({ minLength: 1, maxLength: 100 }),
+    state: Type.Optional(Type.String({ minLength: 1, maxLength: 100 })),
+    county: Type.String({ minLength: 1, maxLength: 100 })
+  }, { additionalProperties: false })
+])
+export const CoverageStateAreaSchema = Type.Composite([
+  CoverageSegmentBaseSchema,
+  Type.Object({
+    type: Type.Literal('AREA'),
+    areaType: Type.Literal('STATE'),
+    linkedTo: Type.Array(LSPNetworkNodeSchema),
+    
+    country: Type.String({ minLength: 2, maxLength: 2 }), // Country code
+    state: Type.String({ minLength: 1, maxLength: 100 })
+  }, { additionalProperties: false })
+])
+export const CoverageRegionAreaSchema = Type.Composite([
+  CoverageSegmentBaseSchema,
+  Type.Object({
+    type: Type.Literal('AREA'),
+    areaType: Type.Literal('REGION'),
+    linkedTo: Type.Array(LSPNetworkNodeSchema),
+
+    country: Type.String({ minLength: 2, maxLength: 2 }), // Country code
+    region: Type.String({ minLength: 1, maxLength: 100 })
+  }, { additionalProperties: false })
+])
+export const CoverageCountryAreaSchema = Type.Composite([
+  CoverageSegmentBaseSchema,
+  Type.Object({
+    type: Type.Literal('AREA'),
+    areaType: Type.Literal('COUNTRY'),
+    linkedTo: Type.Array(LSPNetworkNodeSchema),
+
+    country: Type.String({ minLength: 2, maxLength: 2 }) // Country code
+  }, { additionalProperties: false })
+])
+export const CoverageCustomAreaSchema = Type.Composite([
+  CoverageSegmentBaseSchema,
+  Type.Object({
+    type: Type.Literal('AREA'),
+    areaType: Type.Literal('CUSTOM_ZONE'),
+    linkedTo: Type.Array(LSPNetworkNodeSchema),
+    boundary: GeoBoundarySchema
+  }, { additionalProperties: false })
+])
+
+export const CoverageRouteTypeSchema = Type.Union([
+  Type.Literal('POINT_BASED'),
+  Type.Literal('GEOJSON_BASED')
+])
+export const CoveragePointsRouteSchema = Type.Composite([
+  CoverageSegmentBaseSchema,
+  Type.Object({
+    type: Type.Literal('ROUTE'),
+    routeType: Type.Literal('POINT_BASED'),
+    origin: LSPNetworkNodeSchema,
+    destination: LSPNetworkNodeSchema,
+    distance: DistanceSchema
+  })
+])
+export const CoverageGeoJsonRouteSchema = Type.Composite([
+  CoverageSegmentBaseSchema,
+  Type.Object({
+    type: Type.Literal('ROUTE'),
+    routeType: Type.Literal('GEOJSON_BASED'),
+    geojson: Type.Any(),
+    distance: DistanceSchema
+  })
+])
+
+// LSP Hub Coverage Operation Schema
+export const CoverageOperationSchema = Type.Object({
+  id: Type.String(),
+  name: Type.String(),
+  type: Type.Union([
+    Type.Literal('CAPACITY_BALANCING'),
+    Type.Literal('ROUTE_OPTIMIZATION'),
+    Type.Literal('EMERGENCY_REROUTING'),
+    Type.Literal('COVERAGE_MAINTENANCE'),
+    Type.Literal('SERVICE_DISRUPTION'),
+    Type.Literal('PEAK_MANAGEMENT')
+  ]),
+  
+  // Operation scope
+  scope: Type.Object({
+    affectedHubs: Type.Array(Type.String()),
+    affectedRoutes: Type.Array(Type.String()),
+    affectedServiceLevels: Type.Array(ServiceLevelSchema),
+    estimatedImpact: Type.Union([
+      Type.Literal('LOW'),
+      Type.Literal('MEDIUM'),
+      Type.Literal('HIGH'),
+      Type.Literal('CRITICAL')
+    ])
+  }),
+  
+  // Operation details
+  details: Type.Object({
+    triggerReason: Type.String({ maxLength: 500 }),
+    description: Type.String({ maxLength: 1000 }),
+    executionPlan: Type.Array(Type.Object({
+      step: Type.Number(),
+      action: Type.String(),
+      hubId: Type.Optional(Type.String()),
+      estimatedDuration: Type.Number({ description: 'minutes' }),
+      dependencies: Type.Array(Type.String()),
+      status: Type.Union([
+        Type.Literal('PENDING'),
+        Type.Literal('IN_PROGRESS'),
+        Type.Literal('COMPLETED'),
+        Type.Literal('FAILED'),
+        Type.Literal('SKIPPED')
+      ])
+    }))
+  }),
+  
+  // Operation scheduling
+  scheduling: Type.Object({
+    scheduledAt: Type.Number(),
+    startedAt: Type.Optional(Type.Number()),
+    completedAt: Type.Optional(Type.Number()),
+    priority: Type.Union([
+      Type.Literal('LOW'),
+      Type.Literal('NORMAL'),
+      Type.Literal('HIGH'),
+      Type.Literal('URGENT')
+    ])
+  }),
+  
+  // Operation status
+  status: Type.Union([
+    Type.Literal('PLANNED'),
+    Type.Literal('APPROVED'),
+    Type.Literal('EXECUTING'),
+    Type.Literal('COMPLETED'),
+    Type.Literal('FAILED'),
+    Type.Literal('CANCELLED'),
+    Type.Literal('ROLLED_BACK')
+  ]),
+  
+  created: ActionRecordSchema,
+  updated: Type.Optional(ActionRecordSchema)
+})
+
+export type CoverageTransitType = Static<typeof CoverageTransitTypeSchema>
+export type CoverageTransitMode = Static<typeof CoverageTransitModeSchema>
+export type CoverageTransit = Static<typeof CoverageTransitSchema>
+export type CoverageReach = Static<typeof CoverageReachSchema>
+export type CoverageSchedule = Static<typeof CoverageScheduleSchema>
+export type CoverageCapacity = Static<typeof CoverageCapacitySchema>
+export type CoverageRestrictionType = Static<typeof CoverageRestrictionTypeSchema>
+export type CoverageRestriction = Static<typeof CoverageRestrictionSchema>
+export type CoverageSegmentType = Static<typeof CoverageSegmentTypeSchema>
+export type CoverageCityArea = Static<typeof CoverageCityAreaSchema>
+export type CoverageTownArea = Static<typeof CoverageTownAreaSchema>
+export type CoverageMetropolitanArea = Static<typeof CoverageMetropolitanAreaSchema>
+export type CoverageCountyArea = Static<typeof CoverageCountyAreaSchema>
+export type CoverageStateArea = Static<typeof CoverageStateAreaSchema>
+export type CoverageRegionArea = Static<typeof CoverageRegionAreaSchema>
+export type CoverageCountryArea = Static<typeof CoverageCountryAreaSchema>
+export type CoverageCustomArea = Static<typeof CoverageCustomAreaSchema>
+export type CoverageAreaType = Static<typeof CoverageAreaTypeSchema>
+export type CoverageArea = CoverageCityArea
+                          | CoverageTownArea
+                          | CoverageMetropolitanArea
+                          | CoverageCountyArea
+                          | CoverageStateArea
+                          | CoverageRegionArea
+                          | CoverageCountryArea
+                          | CoverageCustomArea
+export type CoveragePointsRoute = Static<typeof CoveragePointsRouteSchema>
+export type CoverageRouteType = Static<typeof CoverageRouteTypeSchema>
+export type CoverageGeoJsonRoute = Static<typeof CoverageGeoJsonRouteSchema>
+export type CoverageRoute = CoveragePointsRoute
+                            | CoverageGeoJsonRoute
+// export type CoverageSegment = Static<typeof CoverageSegmentSchema>
+export type CoveragePerformance = Static<typeof CoveragePerformanceSchema>
+
+export type CoverageOperation = Static<typeof CoverageOperationSchema>
+
+// ─── Request Validation Schemas ───────────────────────────────────────────────
+
+import {
+	APIErrorSchema,
+	APIHeadersSchema,
+	APIResponseBaseSchema,
+	APIResponseDataSchemaFactory,
+	FetchByQueryRequestSchema
+} from '../api'
+import { CoordinatesSchema } from '../geo'
+
+const AREA_OMIT  = ['id', 'context', 'type', 'areaType', 'status', 'transit.nodes', 'linkedTo', 'performance', 'added', 'updated'] as const
+const ROUTE_OMIT = ['id', 'context', 'type', 'routeType', 'status', 'transit.nodes', 'performance', 'added', 'updated'] as const
+
+const AreaCreatedResponse  = { 201: APIResponseDataSchemaFactory({ areaId: Type.String() }), '4XX': APIErrorSchema }
+const RouteCreatedResponse = { 201: APIResponseDataSchemaFactory({ routeId: Type.String() }), '4XX': APIErrorSchema }
+
+// ── Overview ──────────────────────────────────────────────────────────────────
+
+export const LSPCoverageOverviewRVS = {
+	headers:     APIHeadersSchema,
+	querystring: Type.Object({
+		type:   Type.Optional(CoverageSegmentTypeSchema),
+		status: Type.Optional(EntityStatusSchema)
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({ coverage: Type.Array(Type.Any()), total: Type.Number() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+// ── Areas — Add ───────────────────────────────────────────────────────────────
+
+export const LSPCoverageAddCityAreaRVS        = { headers: APIHeadersSchema, body: Type.Omit(CoverageCityAreaSchema, AREA_OMIT),         response: AreaCreatedResponse }
+export const LSPCoverageAddTownAreaRVS        = { headers: APIHeadersSchema, body: Type.Omit(CoverageTownAreaSchema, AREA_OMIT),         response: AreaCreatedResponse }
+export const LSPCoverageAddMetroAreaRVS       = { headers: APIHeadersSchema, body: Type.Omit(CoverageMetropolitanAreaSchema, AREA_OMIT), response: AreaCreatedResponse }
+export const LSPCoverageAddCountyAreaRVS      = { headers: APIHeadersSchema, body: Type.Omit(CoverageCountyAreaSchema, AREA_OMIT),       response: AreaCreatedResponse }
+export const LSPCoverageAddStateAreaRVS       = { headers: APIHeadersSchema, body: Type.Omit(CoverageStateAreaSchema, AREA_OMIT),        response: AreaCreatedResponse }
+export const LSPCoverageAddRegionAreaRVS      = { headers: APIHeadersSchema, body: Type.Omit(CoverageRegionAreaSchema, AREA_OMIT),       response: AreaCreatedResponse }
+export const LSPCoverageAddCountryAreaRVS     = { headers: APIHeadersSchema, body: Type.Omit(CoverageCountryAreaSchema, AREA_OMIT),      response: AreaCreatedResponse }
+export const LSPCoverageAddCustomAreaRVS      = { headers: APIHeadersSchema, body: Type.Omit(CoverageCustomAreaSchema, AREA_OMIT),       response: AreaCreatedResponse }
+
+// ── Areas — Update ────────────────────────────────────────────────────────────
+
+const AreaUpdateParams = Type.Object({ id: Type.String() })
+
+export const LSPCoverageUpdateCityAreaRVS    = { headers: APIHeadersSchema, params: AreaUpdateParams, body: Type.Partial(Type.Omit(CoverageCityAreaSchema, AREA_OMIT)),         response: { 200: APIResponseDataSchemaFactory({ area: CoverageCityAreaSchema }),         '4XX': APIErrorSchema } }
+export const LSPCoverageUpdateTownAreaRVS    = { headers: APIHeadersSchema, params: AreaUpdateParams, body: Type.Partial(Type.Omit(CoverageTownAreaSchema, AREA_OMIT)),         response: { 200: APIResponseDataSchemaFactory({ area: CoverageTownAreaSchema }),         '4XX': APIErrorSchema } }
+export const LSPCoverageUpdateMetroAreaRVS   = { headers: APIHeadersSchema, params: AreaUpdateParams, body: Type.Partial(Type.Omit(CoverageMetropolitanAreaSchema, AREA_OMIT)), response: { 200: APIResponseDataSchemaFactory({ area: CoverageMetropolitanAreaSchema }), '4XX': APIErrorSchema } }
+export const LSPCoverageUpdateCountyAreaRVS  = { headers: APIHeadersSchema, params: AreaUpdateParams, body: Type.Partial(Type.Omit(CoverageCountyAreaSchema, AREA_OMIT)),       response: { 200: APIResponseDataSchemaFactory({ area: CoverageCountyAreaSchema }),       '4XX': APIErrorSchema } }
+export const LSPCoverageUpdateStateAreaRVS   = { headers: APIHeadersSchema, params: AreaUpdateParams, body: Type.Partial(Type.Omit(CoverageStateAreaSchema, AREA_OMIT)),        response: { 200: APIResponseDataSchemaFactory({ area: CoverageStateAreaSchema }),        '4XX': APIErrorSchema } }
+export const LSPCoverageUpdateRegionAreaRVS  = { headers: APIHeadersSchema, params: AreaUpdateParams, body: Type.Partial(Type.Omit(CoverageRegionAreaSchema, AREA_OMIT)),       response: { 200: APIResponseDataSchemaFactory({ area: CoverageRegionAreaSchema }),       '4XX': APIErrorSchema } }
+export const LSPCoverageUpdateCountryAreaRVS = { headers: APIHeadersSchema, params: AreaUpdateParams, body: Type.Partial(Type.Omit(CoverageCountryAreaSchema, AREA_OMIT)),      response: { 200: APIResponseDataSchemaFactory({ area: CoverageCountryAreaSchema }),      '4XX': APIErrorSchema } }
+export const LSPCoverageUpdateCustomAreaRVS  = { headers: APIHeadersSchema, params: AreaUpdateParams, body: Type.Partial(Type.Omit(CoverageCustomAreaSchema, AREA_OMIT)),       response: { 200: APIResponseDataSchemaFactory({ area: CoverageCustomAreaSchema }),       '4XX': APIErrorSchema } }
+
+// ── Areas — Common ────────────────────────────────────────────────────────────
+
+export const LSPCoverageGetAreaRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	response: {
+		200:   APIResponseDataSchemaFactory({ area: Type.Any() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPCoverageGetRouteRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	response: {
+		200:   APIResponseDataSchemaFactory({ route: Type.Any() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPCoverageListAreasRVS = {
+	headers:     APIHeadersSchema,
+	querystring: Type.Composite([
+		FetchByQueryRequestSchema,
+		Type.Object({ status: Type.Optional(EntityStatusSchema) })
+	]),
+	response: {
+		200:   APIResponseDataSchemaFactory({ areas: Type.Array(Type.Any()) }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPCoverageLinkNodeRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     LSPNetworkNodeSchema,
+	response: {
+		200:   APIResponseDataSchemaFactory({ area: Type.Any() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPCoverageUnlinkNodeRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     Type.Object({
+		id:          Type.Optional(Type.String()),
+		addressName: Type.Optional(Type.String())
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({ area: Type.Any() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPCoverageRemoveAreaRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	response: {
+		200:   APIResponseBaseSchema,
+		'4XX': APIErrorSchema
+	}
+}
+
+// ── Routes ────────────────────────────────────────────────────────────────────
+
+export const LSPCoverageAddPointsRouteRVS = { headers: APIHeadersSchema, body: Type.Omit(CoveragePointsRouteSchema, ROUTE_OMIT), response: RouteCreatedResponse }
+export const LSPCoverageAddGeoJsonRouteRVS = { headers: APIHeadersSchema, body: Type.Omit(CoverageGeoJsonRouteSchema, ROUTE_OMIT), response: RouteCreatedResponse }
+
+export const LSPCoverageUpdatePointsRouteRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     Type.Partial(Type.Omit(CoveragePointsRouteSchema, ROUTE_OMIT)),
+	response: {
+		200:   APIResponseDataSchemaFactory({ route: CoveragePointsRouteSchema }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPCoverageUpdateGeoJsonRouteRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     Type.Partial(Type.Omit(CoverageGeoJsonRouteSchema, ROUTE_OMIT)),
+	response: {
+		200:   APIResponseDataSchemaFactory({ route: CoverageGeoJsonRouteSchema }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPCoverageListRoutesRVS = {
+	headers:     APIHeadersSchema,
+	querystring: Type.Composite([
+		FetchByQueryRequestSchema,
+		Type.Object({ status: Type.Optional(EntityStatusSchema) })
+	]),
+	response: {
+		200:   APIResponseDataSchemaFactory({ routes: Type.Array(Type.Any()) }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPCoverageAddRouteNodeRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     LSPNetworkNodeSchema,
+	response: {
+		200:   APIResponseDataSchemaFactory({ route: Type.Any() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPCoverageRemoveRouteNodeRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     Type.Object({
+		id:          Type.Optional(Type.String()),
+		addressName: Type.Optional(Type.String())
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({ route: Type.Any() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPCoverageRemoveRouteRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	response: {
+		200:   APIResponseBaseSchema,
+		'4XX': APIErrorSchema
+	}
+}
+
+// ── Checks ────────────────────────────────────────────────────────────────────
+
+export const LSPCoverageCheckRVS = {
+	headers:  APIHeadersSchema,
+	body:     Type.Object({
+		location:    Type.Object({ coordinates: CoordinatesSchema, country: Type.String({ minLength: 2, maxLength: 2 }), city: Type.Optional(Type.String()) }),
+		serviceType: Type.Optional(Type.String())
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({ isCovered: Type.Boolean(), matchingAreas: Type.Array(Type.Any()) }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPCoverageFindAreasRVS = {
+	headers:  APIHeadersSchema,
+	body:     Type.Object({
+		location: Type.Object({ coordinates: CoordinatesSchema, country: Type.Optional(Type.String()) }),
+		filters:  Type.Optional(Type.Any())
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({ areas: Type.Array(Type.Any()), total: Type.Number() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPCoverageGetServiceabilityRVS = {
+	headers:     APIHeadersSchema,
+	querystring: Type.Object({
+		lat:     Type.String(),
+		lng:     Type.String(),
+		country: Type.Optional(Type.String())
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({ serviceability: Type.Any() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPCoverageValidateBoundaryRVS = {
+	headers:  APIHeadersSchema,
+	body:     Type.Object({ boundary: Type.Any() }),
+	response: {
+		200:   APIResponseDataSchemaFactory({ valid: Type.Boolean() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPCoverageFindNearestRVS = {
+	headers:  APIHeadersSchema,
+	body:     Type.Object({
+		location: Type.Object({ coordinates: CoordinatesSchema, country: Type.Optional(Type.String()) })
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({ nearestArea: Type.Any() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPCoverageCheckRestrictionsRVS = {
+	headers:  APIHeadersSchema,
+	body:     Type.Object({
+		location:        Type.Object({ coordinates: CoordinatesSchema }),
+		vehicleType:     Type.Optional(VehicleTypeSchema),
+		restrictionType: Type.Optional(CoverageRestrictionTypeSchema)
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({ location: CoordinatesSchema, restrictions: Type.Array(Type.Any()), summary: Type.Any() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPCoverageFindParkingZonesRVS = {
+	headers:  APIHeadersSchema,
+	body:     Type.Object({
+		location:    Type.Object({ coordinates: CoordinatesSchema }),
+		vehicleType: VehicleTypeSchema,
+		radius:      Type.Optional(DistanceSchema)
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({ location: CoordinatesSchema, vehicleType: VehicleTypeSchema, radius: DistanceSchema, zones: Type.Array(Type.Any()), total: Type.Number() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+// ── Analytics ─────────────────────────────────────────────────────────────────
+
+export const LSPCoverageGetAnalyticsRVS                 = { headers: APIHeadersSchema, response: { 200: APIResponseDataSchemaFactory({ analytics: Type.Any() }) } }
+export const LSPCoverageGetParkingCapacityAnalyticsRVS  = {
+	headers: APIHeadersSchema,
+	body: Type.Object({ vehicleType: Type.Optional(Type.String()), includeOccupancy: Type.Optional(Type.Boolean()) }),
+	response: { 200: APIResponseDataSchemaFactory({ zones: Type.Array(Type.Any()), total: Type.Number() }) }
+}
+export const LSPCoverageTrackViolationRVS = {
+	headers:  APIHeadersSchema,
+	body:     Type.Object({
+		location:        CoordinatesSchema,
+		vehicleType:     Type.String(),
+		restrictionType: Type.String(),
+		severity:        Type.Union([Type.Literal('WARNING'), Type.Literal('ENFORCED'), Type.Literal('CRITICAL')]),
+		zoneId:          Type.String(),
+		zoneName:        Type.String()
+	}),
+	response: { 200: APIResponseBaseSchema }
+}
+export const LSPCoverageGetViolationStatsRVS = {
+	headers: APIHeadersSchema,
+	body: Type.Object({
+		startDate:       Type.Optional(Type.String({ format: 'date-time' })),
+		endDate:         Type.Optional(Type.String({ format: 'date-time' })),
+		vehicleType:     Type.Optional(Type.String()),
+		restrictionType: Type.Optional(Type.String()),
+		zoneId:          Type.Optional(Type.String())
+	}),
+	response: { 200: APIResponseDataSchemaFactory({ stats: Type.Any() }) }
+}
+export const LSPCoverageGetZoneCapacityRVS = {
+	headers: APIHeadersSchema,
+	body: Type.Object({ vehicleType: Type.String() }),
+	response: { 200: APIResponseDataSchemaFactory({ zones: Type.Array(Type.Any()), total: Type.Number() }) }
+}
+export const LSPCoverageGetRebalancingRecommendationsRVS = {
+	headers: APIHeadersSchema,
+	body: Type.Object({ vehicleType: Type.String(), maxDistance: Type.Optional(DistanceSchema) }),
+	response: { 200: APIResponseDataSchemaFactory({ recommendations: Type.Array(Type.Any()), total: Type.Number() }) }
+}
+export const LSPCoverageAnalyzeDistributionRVS = {
+	headers: APIHeadersSchema,
+	body: Type.Object({ vehicleType: Type.String() }),
+	response: { 200: APIResponseDataSchemaFactory({ analysis: Type.Any() }) }
+}
+export const LSPCoverageFindChargingZonesRVS = {
+	headers: APIHeadersSchema,
+	body: Type.Object({
+		location:    CoordinatesSchema,
+		vehicleType: Type.String(),
+		batteryLevel: Type.Number({ minimum: 0, maximum: 100 }),
+		maxDistance: Type.Optional(DistanceSchema)
+	}),
+	response: { 200: APIResponseDataSchemaFactory({ chargingZones: Type.Array(Type.Any()), total: Type.Number() }) }
+}
+export const LSPCoverageGenerateComplianceReportRVS = {
+	headers: APIHeadersSchema,
+	body: Type.Object({
+		startDate:   Type.String({ format: 'date-time' }),
+		endDate:     Type.String({ format: 'date-time' }),
+		vehicleType: Type.Optional(Type.String()),
+		zoneId:      Type.Optional(Type.String())
+	}),
+	response: { 200: APIResponseDataSchemaFactory({ report: Type.Any() }) }
+}
+export const LSPCoverageGenerateParkingComplianceReportRVS = {
+	headers: APIHeadersSchema,
+	body: Type.Object({
+		startDate:   Type.String({ format: 'date-time' }),
+		endDate:     Type.String({ format: 'date-time' }),
+		vehicleType: Type.String()
+	}),
+	response: { 200: APIResponseDataSchemaFactory({ report: Type.Any() }) }
+}
+export const LSPCoverageGenerateSpeedComplianceReportRVS = {
+	headers: APIHeadersSchema,
+	body: Type.Object({
+		startDate:   Type.String({ format: 'date-time' }),
+		endDate:     Type.String({ format: 'date-time' }),
+		vehicleType: Type.Optional(Type.String())
+	}),
+	response: { 200: APIResponseDataSchemaFactory({ report: Type.Any() }) }
+}
+export const LSPCoverageExportComplianceDataRVS = {
+	headers: APIHeadersSchema,
+	body: Type.Object({
+		startDate:      Type.String({ format: 'date-time' }),
+		endDate:        Type.String({ format: 'date-time' }),
+		format:         Type.Union([Type.Literal('JSON'), Type.Literal('CSV'), Type.Literal('PDF')]),
+		includeDetails: Type.Optional(Type.Boolean())
+	}),
+	response: { 200: APIResponseDataSchemaFactory({ export: Type.Any() }) }
+}
+
+// ── Validation ────────────────────────────────────────────────────────────────
+
+export const LSPCoverageValidateRouteRVS = {
+	headers:  APIHeadersSchema,
+	body:     Type.Object({
+		waypoints:              Type.Array(CoordinatesSchema, { minItems: 2 }),
+		vehicleType:            Type.String(),
+		checkTimeRestrictions:  Type.Optional(Type.Boolean()),
+		currentTime:            Type.Optional(Type.String({ format: 'date-time' })),
+		strictMode:             Type.Optional(Type.Boolean())
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({ isCompliant: Type.Boolean(), totalDistance: DistanceSchema, waypoints: Type.Array(Type.Any()), summary: Type.Any(), alternatives: Type.Optional(Type.Array(Type.Any())) }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPCoverageFindCompliantWaypointsRVS = {
+	headers:  APIHeadersSchema,
+	body:     Type.Object({
+		start:        CoordinatesSchema,
+		end:          CoordinatesSchema,
+		vehicleType:  Type.String(),
+		samplePoints: Type.Optional(Type.Number({ minimum: 2, maximum: 50 }))
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({ compliantWaypoints: Type.Array(CoordinatesSchema), total: Type.Number() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+// ─── Validation types ─────────────────────────────────────────────────────────
+
+export type LSPCoverageOverviewValidation                    = { querystring: Static<typeof LSPCoverageOverviewRVS.querystring>, response: Static<(typeof LSPCoverageOverviewRVS.response)[200]> }
+
+export type LSPCoverageAddCityAreaValidation                 = { body: Static<typeof LSPCoverageAddCityAreaRVS.body>, response: Static<(typeof LSPCoverageAddCityAreaRVS.response)[201]> }
+export type LSPCoverageAddTownAreaValidation                 = { body: Static<typeof LSPCoverageAddTownAreaRVS.body>, response: Static<(typeof LSPCoverageAddTownAreaRVS.response)[201]> }
+export type LSPCoverageAddMetroAreaValidation                = { body: Static<typeof LSPCoverageAddMetroAreaRVS.body>, response: Static<(typeof LSPCoverageAddMetroAreaRVS.response)[201]> }
+export type LSPCoverageAddCountyAreaValidation               = { body: Static<typeof LSPCoverageAddCountyAreaRVS.body>, response: Static<(typeof LSPCoverageAddCountyAreaRVS.response)[201]> }
+export type LSPCoverageAddStateAreaValidation                = { body: Static<typeof LSPCoverageAddStateAreaRVS.body>, response: Static<(typeof LSPCoverageAddStateAreaRVS.response)[201]> }
+export type LSPCoverageAddRegionAreaValidation               = { body: Static<typeof LSPCoverageAddRegionAreaRVS.body>, response: Static<(typeof LSPCoverageAddRegionAreaRVS.response)[201]> }
+export type LSPCoverageAddCountryAreaValidation              = { body: Static<typeof LSPCoverageAddCountryAreaRVS.body>, response: Static<(typeof LSPCoverageAddCountryAreaRVS.response)[201]> }
+export type LSPCoverageAddCustomAreaValidation               = { body: Static<typeof LSPCoverageAddCustomAreaRVS.body>, response: Static<(typeof LSPCoverageAddCustomAreaRVS.response)[201]> }
+
+export type LSPCoverageUpdateCityAreaValidation              = { params: Static<typeof LSPCoverageUpdateCityAreaRVS.params>, body: Static<typeof LSPCoverageUpdateCityAreaRVS.body>, response: Static<(typeof LSPCoverageUpdateCityAreaRVS.response)[200]> }
+export type LSPCoverageUpdateTownAreaValidation              = { params: Static<typeof LSPCoverageUpdateTownAreaRVS.params>, body: Static<typeof LSPCoverageUpdateTownAreaRVS.body>, response: Static<(typeof LSPCoverageUpdateTownAreaRVS.response)[200]> }
+export type LSPCoverageUpdateMetroAreaValidation             = { params: Static<typeof LSPCoverageUpdateMetroAreaRVS.params>, body: Static<typeof LSPCoverageUpdateMetroAreaRVS.body>, response: Static<(typeof LSPCoverageUpdateMetroAreaRVS.response)[200]> }
+export type LSPCoverageUpdateCountyAreaValidation            = { params: Static<typeof LSPCoverageUpdateCountyAreaRVS.params>, body: Static<typeof LSPCoverageUpdateCountyAreaRVS.body>, response: Static<(typeof LSPCoverageUpdateCountyAreaRVS.response)[200]> }
+export type LSPCoverageUpdateStateAreaValidation            = { params: Static<typeof LSPCoverageUpdateStateAreaRVS.params>, body: Static<typeof LSPCoverageUpdateStateAreaRVS.body>, response: Static<(typeof LSPCoverageUpdateStateAreaRVS.response)[200]> }
+export type LSPCoverageUpdateRegionAreaValidation           = { params: Static<typeof LSPCoverageUpdateRegionAreaRVS.params>, body: Static<typeof LSPCoverageUpdateRegionAreaRVS.body>, response: Static<(typeof LSPCoverageUpdateRegionAreaRVS.response)[200]> }
+export type LSPCoverageUpdateCountryAreaValidation          = { params: Static<typeof LSPCoverageUpdateCountryAreaRVS.params>, body: Static<typeof LSPCoverageUpdateCountryAreaRVS.body>, response: Static<(typeof LSPCoverageUpdateCountryAreaRVS.response)[200]> }
+export type LSPCoverageUpdateCustomAreaValidation           = { params: Static<typeof LSPCoverageUpdateCustomAreaRVS.params>, body: Static<typeof LSPCoverageUpdateCustomAreaRVS.body>, response: Static<(typeof LSPCoverageUpdateCustomAreaRVS.response)[200]> }
+
+export type LSPCoverageGetAreaValidation                     = { params: Static<typeof LSPCoverageGetAreaRVS.params>, response: Static<(typeof LSPCoverageGetAreaRVS.response)[200]> }
+export type LSPCoverageGetRouteValidation                    = { params: Static<typeof LSPCoverageGetRouteRVS.params>, response: Static<(typeof LSPCoverageGetRouteRVS.response)[200]> }
+export type LSPCoverageListAreasValidation                   = { querystring: Static<typeof LSPCoverageListAreasRVS.querystring>, response: Static<(typeof LSPCoverageListAreasRVS.response)[200]> }
+export type LSPCoverageLinkNodeValidation                    = { params: Static<typeof LSPCoverageLinkNodeRVS.params>, body: Static<typeof LSPCoverageLinkNodeRVS.body>, response: Static<(typeof LSPCoverageLinkNodeRVS.response)[200]> }
+export type LSPCoverageUnlinkNodeValidation                  = { params: Static<typeof LSPCoverageUnlinkNodeRVS.params>, body: Static<typeof LSPCoverageUnlinkNodeRVS.body>, response: Static<(typeof LSPCoverageUnlinkNodeRVS.response)[200]> }
+export type LSPCoverageRemoveAreaValidation                  = { params: Static<typeof LSPCoverageRemoveAreaRVS.params>, response: Static<(typeof LSPCoverageRemoveAreaRVS.response)[200]> }
+
+export type LSPCoverageAddPointsRouteValidation              = { body: Static<typeof LSPCoverageAddPointsRouteRVS.body>, response: Static<(typeof LSPCoverageAddPointsRouteRVS.response)[201]> }
+export type LSPCoverageAddGeoJsonRouteValidation             = { body: Static<typeof LSPCoverageAddGeoJsonRouteRVS.body>, response: Static<(typeof LSPCoverageAddGeoJsonRouteRVS.response)[201]> }
+export type LSPCoverageUpdatePointsRouteValidation           = { params: Static<typeof LSPCoverageUpdatePointsRouteRVS.params>, body: Static<typeof LSPCoverageUpdatePointsRouteRVS.body>, response: Static<(typeof LSPCoverageUpdatePointsRouteRVS.response)[200]> }
+export type LSPCoverageUpdateGeoJsonRouteValidation          = { params: Static<typeof LSPCoverageUpdateGeoJsonRouteRVS.params>, body: Static<typeof LSPCoverageUpdateGeoJsonRouteRVS.body>, response: Static<(typeof LSPCoverageUpdateGeoJsonRouteRVS.response)[200]> }
+export type LSPCoverageListRoutesValidation                  = { querystring: Static<typeof LSPCoverageListRoutesRVS.querystring>, response: Static<(typeof LSPCoverageListRoutesRVS.response)[200]> }
+export type LSPCoverageAddRouteNodeValidation                = { params: Static<typeof LSPCoverageAddRouteNodeRVS.params>, body: Static<typeof LSPCoverageAddRouteNodeRVS.body>, response: Static<(typeof LSPCoverageAddRouteNodeRVS.response)[200]> }
+export type LSPCoverageRemoveRouteNodeValidation             = { params: Static<typeof LSPCoverageRemoveRouteNodeRVS.params>, body: Static<typeof LSPCoverageRemoveRouteNodeRVS.body>, response: Static<(typeof LSPCoverageRemoveRouteNodeRVS.response)[200]> }
+export type LSPCoverageRemoveRouteValidation                 = { params: Static<typeof LSPCoverageRemoveRouteRVS.params>, response: Static<(typeof LSPCoverageRemoveRouteRVS.response)[200]> }
+
+export type LSPCoverageCheckValidation                       = { body: Static<typeof LSPCoverageCheckRVS.body>, response: Static<(typeof LSPCoverageCheckRVS.response)[200]> }
+export type LSPCoverageFindAreasValidation                   = { body: Static<typeof LSPCoverageFindAreasRVS.body>, response: Static<(typeof LSPCoverageFindAreasRVS.response)[200]> }
+export type LSPCoverageGetServiceabilityValidation           = { querystring: Static<typeof LSPCoverageGetServiceabilityRVS.querystring>, response: Static<(typeof LSPCoverageGetServiceabilityRVS.response)[200]> }
+export type LSPCoverageValidateBoundaryValidation            = { body: Static<typeof LSPCoverageValidateBoundaryRVS.body>, response: Static<(typeof LSPCoverageValidateBoundaryRVS.response)[200]> }
+export type LSPCoverageFindNearestValidation                 = { body: Static<typeof LSPCoverageFindNearestRVS.body>, response: Static<(typeof LSPCoverageFindNearestRVS.response)[200]> }
+export type LSPCoverageCheckRestrictionsValidation           = { body: Static<typeof LSPCoverageCheckRestrictionsRVS.body>, response: Static<(typeof LSPCoverageCheckRestrictionsRVS.response)[200]> }
+export type LSPCoverageFindParkingZonesValidation            = { body: Static<typeof LSPCoverageFindParkingZonesRVS.body>, response: Static<(typeof LSPCoverageFindParkingZonesRVS.response)[200]> }
+
+export type LSPCoverageGetAnalyticsValidation                = { response: Static<(typeof LSPCoverageGetAnalyticsRVS.response)[200]> }
+export type LSPCoverageGetParkingCapacityAnalyticsValidation = { body: Static<typeof LSPCoverageGetParkingCapacityAnalyticsRVS.body>, response: Static<(typeof LSPCoverageGetParkingCapacityAnalyticsRVS.response)[200]> }
+export type LSPCoverageTrackViolationValidation              = { body: Static<typeof LSPCoverageTrackViolationRVS.body>, response: Static<(typeof LSPCoverageTrackViolationRVS.response)[200]> }
+export type LSPCoverageGetViolationStatsValidation           = { body: Static<typeof LSPCoverageGetViolationStatsRVS.body>, response: Static<(typeof LSPCoverageGetViolationStatsRVS.response)[200]> }
+export type LSPCoverageGetZoneCapacityValidation             = { body: Static<typeof LSPCoverageGetZoneCapacityRVS.body>, response: Static<(typeof LSPCoverageGetZoneCapacityRVS.response)[200]> }
+export type LSPCoverageGetRebalancingRecommendationsValidation = { body: Static<typeof LSPCoverageGetRebalancingRecommendationsRVS.body>, response: Static<(typeof LSPCoverageGetRebalancingRecommendationsRVS.response)[200]> }
+export type LSPCoverageAnalyzeDistributionValidation         = { body: Static<typeof LSPCoverageAnalyzeDistributionRVS.body>, response: Static<(typeof LSPCoverageAnalyzeDistributionRVS.response)[200]> }
+export type LSPCoverageFindChargingZonesValidation           = { body: Static<typeof LSPCoverageFindChargingZonesRVS.body>, response: Static<(typeof LSPCoverageFindChargingZonesRVS.response)[200]> }
+export type LSPCoverageGenerateComplianceReportValidation    = { body: Static<typeof LSPCoverageGenerateComplianceReportRVS.body>, response: Static<(typeof LSPCoverageGenerateComplianceReportRVS.response)[200]> }
+export type LSPCoverageGenerateParkingComplianceReportValidation = { body: Static<typeof LSPCoverageGenerateParkingComplianceReportRVS.body>, response: Static<(typeof LSPCoverageGenerateParkingComplianceReportRVS.response)[200]> }
+export type LSPCoverageGenerateSpeedComplianceReportValidation = { body: Static<typeof LSPCoverageGenerateSpeedComplianceReportRVS.body>, response: Static<(typeof LSPCoverageGenerateSpeedComplianceReportRVS.response)[200]> }
+export type LSPCoverageExportComplianceDataValidation        = { body: Static<typeof LSPCoverageExportComplianceDataRVS.body>, response: Static<(typeof LSPCoverageExportComplianceDataRVS.response)[200]> }
+
+export type LSPCoverageValidateRouteValidation               = { body: Static<typeof LSPCoverageValidateRouteRVS.body>, response: Static<(typeof LSPCoverageValidateRouteRVS.response)[200]> }
+export type LSPCoverageFindCompliantWaypointsValidation      = { body: Static<typeof LSPCoverageFindCompliantWaypointsRVS.body>, response: Static<(typeof LSPCoverageFindCompliantWaypointsRVS.response)[200]> }