@aws-sdk/client-geo-routes 3.891.0 → 3.894.0

package/dist-cjs/index.js

@@ -1,10 +1,4189 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GeoRoutesServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./GeoRoutesClient"), exports);
-tslib_1.__exportStar(require("./GeoRoutes"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-var GeoRoutesServiceException_1 = require("./models/GeoRoutesServiceException");
-Object.defineProperty(exports, "GeoRoutesServiceException", { enumerable: true, get: function () { return GeoRoutesServiceException_1.GeoRoutesServiceException; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AccessDeniedException: () => AccessDeniedException,
+  CalculateIsolinesCommand: () => CalculateIsolinesCommand,
+  CalculateIsolinesRequestFilterSensitiveLog: () => CalculateIsolinesRequestFilterSensitiveLog,
+  CalculateIsolinesResponseFilterSensitiveLog: () => CalculateIsolinesResponseFilterSensitiveLog,
+  CalculateRouteMatrixCommand: () => CalculateRouteMatrixCommand,
+  CalculateRouteMatrixRequestFilterSensitiveLog: () => CalculateRouteMatrixRequestFilterSensitiveLog,
+  CalculateRouteMatrixResponseFilterSensitiveLog: () => CalculateRouteMatrixResponseFilterSensitiveLog,
+  CalculateRoutesCommand: () => CalculateRoutesCommand,
+  CalculateRoutesRequestFilterSensitiveLog: () => CalculateRoutesRequestFilterSensitiveLog,
+  CalculateRoutesResponseFilterSensitiveLog: () => CalculateRoutesResponseFilterSensitiveLog,
+  CircleFilterSensitiveLog: () => CircleFilterSensitiveLog,
+  CorridorFilterSensitiveLog: () => CorridorFilterSensitiveLog,
+  DayOfWeek: () => DayOfWeek,
+  GeoRoutes: () => GeoRoutes,
+  GeoRoutesClient: () => GeoRoutesClient,
+  GeoRoutesServiceException: () => GeoRoutesServiceException,
+  GeometryFormat: () => GeometryFormat,
+  InternalServerException: () => InternalServerException,
+  IsolineAllowOptionsFilterSensitiveLog: () => IsolineAllowOptionsFilterSensitiveLog,
+  IsolineAvoidanceAreaFilterSensitiveLog: () => IsolineAvoidanceAreaFilterSensitiveLog,
+  IsolineAvoidanceAreaGeometryFilterSensitiveLog: () => IsolineAvoidanceAreaGeometryFilterSensitiveLog,
+  IsolineAvoidanceOptionsFilterSensitiveLog: () => IsolineAvoidanceOptionsFilterSensitiveLog,
+  IsolineCarOptionsFilterSensitiveLog: () => IsolineCarOptionsFilterSensitiveLog,
+  IsolineConnectionFilterSensitiveLog: () => IsolineConnectionFilterSensitiveLog,
+  IsolineConnectionGeometryFilterSensitiveLog: () => IsolineConnectionGeometryFilterSensitiveLog,
+  IsolineDestinationOptionsFilterSensitiveLog: () => IsolineDestinationOptionsFilterSensitiveLog,
+  IsolineEngineType: () => IsolineEngineType,
+  IsolineFilterSensitiveLog: () => IsolineFilterSensitiveLog,
+  IsolineGranularityOptionsFilterSensitiveLog: () => IsolineGranularityOptionsFilterSensitiveLog,
+  IsolineHazardousCargoType: () => IsolineHazardousCargoType,
+  IsolineMatchingOptionsFilterSensitiveLog: () => IsolineMatchingOptionsFilterSensitiveLog,
+  IsolineOptimizationObjective: () => IsolineOptimizationObjective,
+  IsolineOriginOptionsFilterSensitiveLog: () => IsolineOriginOptionsFilterSensitiveLog,
+  IsolineScooterOptionsFilterSensitiveLog: () => IsolineScooterOptionsFilterSensitiveLog,
+  IsolineShapeGeometryFilterSensitiveLog: () => IsolineShapeGeometryFilterSensitiveLog,
+  IsolineSideOfStreetOptionsFilterSensitiveLog: () => IsolineSideOfStreetOptionsFilterSensitiveLog,
+  IsolineThresholdsFilterSensitiveLog: () => IsolineThresholdsFilterSensitiveLog,
+  IsolineTrafficOptionsFilterSensitiveLog: () => IsolineTrafficOptionsFilterSensitiveLog,
+  IsolineTrailerOptionsFilterSensitiveLog: () => IsolineTrailerOptionsFilterSensitiveLog,
+  IsolineTravelMode: () => IsolineTravelMode,
+  IsolineTravelModeOptionsFilterSensitiveLog: () => IsolineTravelModeOptionsFilterSensitiveLog,
+  IsolineTruckOptionsFilterSensitiveLog: () => IsolineTruckOptionsFilterSensitiveLog,
+  IsolineTruckType: () => IsolineTruckType,
+  IsolineVehicleLicensePlateFilterSensitiveLog: () => IsolineVehicleLicensePlateFilterSensitiveLog,
+  IsolineZoneCategory: () => IsolineZoneCategory,
+  LocalizedStringFilterSensitiveLog: () => LocalizedStringFilterSensitiveLog,
+  MatchingStrategy: () => MatchingStrategy,
+  MeasurementSystem: () => MeasurementSystem,
+  OptimizeWaypointsCommand: () => OptimizeWaypointsCommand,
+  OptimizeWaypointsRequestFilterSensitiveLog: () => OptimizeWaypointsRequestFilterSensitiveLog,
+  OptimizeWaypointsResponseFilterSensitiveLog: () => OptimizeWaypointsResponseFilterSensitiveLog,
+  PolylineCorridorFilterSensitiveLog: () => PolylineCorridorFilterSensitiveLog,
+  RoadSnapHazardousCargoType: () => RoadSnapHazardousCargoType,
+  RoadSnapNoticeCode: () => RoadSnapNoticeCode,
+  RoadSnapNoticeFilterSensitiveLog: () => RoadSnapNoticeFilterSensitiveLog,
+  RoadSnapSnappedGeometryFilterSensitiveLog: () => RoadSnapSnappedGeometryFilterSensitiveLog,
+  RoadSnapSnappedTracePointFilterSensitiveLog: () => RoadSnapSnappedTracePointFilterSensitiveLog,
+  RoadSnapTracePointFilterSensitiveLog: () => RoadSnapTracePointFilterSensitiveLog,
+  RoadSnapTrailerOptionsFilterSensitiveLog: () => RoadSnapTrailerOptionsFilterSensitiveLog,
+  RoadSnapTravelMode: () => RoadSnapTravelMode,
+  RoadSnapTravelModeOptionsFilterSensitiveLog: () => RoadSnapTravelModeOptionsFilterSensitiveLog,
+  RoadSnapTruckOptionsFilterSensitiveLog: () => RoadSnapTruckOptionsFilterSensitiveLog,
+  RouteAllowOptionsFilterSensitiveLog: () => RouteAllowOptionsFilterSensitiveLog,
+  RouteAvoidanceAreaFilterSensitiveLog: () => RouteAvoidanceAreaFilterSensitiveLog,
+  RouteAvoidanceAreaGeometryFilterSensitiveLog: () => RouteAvoidanceAreaGeometryFilterSensitiveLog,
+  RouteAvoidanceOptionsFilterSensitiveLog: () => RouteAvoidanceOptionsFilterSensitiveLog,
+  RouteAvoidanceZoneCategoryFilterSensitiveLog: () => RouteAvoidanceZoneCategoryFilterSensitiveLog,
+  RouteCarOptionsFilterSensitiveLog: () => RouteCarOptionsFilterSensitiveLog,
+  RouteContinueHighwayStepDetailsFilterSensitiveLog: () => RouteContinueHighwayStepDetailsFilterSensitiveLog,
+  RouteContinueStepDetailsFilterSensitiveLog: () => RouteContinueStepDetailsFilterSensitiveLog,
+  RouteDestinationOptionsFilterSensitiveLog: () => RouteDestinationOptionsFilterSensitiveLog,
+  RouteDirection: () => RouteDirection,
+  RouteDriverOptionsFilterSensitiveLog: () => RouteDriverOptionsFilterSensitiveLog,
+  RouteDriverScheduleIntervalFilterSensitiveLog: () => RouteDriverScheduleIntervalFilterSensitiveLog,
+  RouteEmissionTypeFilterSensitiveLog: () => RouteEmissionTypeFilterSensitiveLog,
+  RouteEngineType: () => RouteEngineType,
+  RouteEnterHighwayStepDetailsFilterSensitiveLog: () => RouteEnterHighwayStepDetailsFilterSensitiveLog,
+  RouteExclusionOptionsFilterSensitiveLog: () => RouteExclusionOptionsFilterSensitiveLog,
+  RouteExitStepDetailsFilterSensitiveLog: () => RouteExitStepDetailsFilterSensitiveLog,
+  RouteFerryAfterTravelStepFilterSensitiveLog: () => RouteFerryAfterTravelStepFilterSensitiveLog,
+  RouteFerryAfterTravelStepType: () => RouteFerryAfterTravelStepType,
+  RouteFerryArrivalFilterSensitiveLog: () => RouteFerryArrivalFilterSensitiveLog,
+  RouteFerryBeforeTravelStepFilterSensitiveLog: () => RouteFerryBeforeTravelStepFilterSensitiveLog,
+  RouteFerryBeforeTravelStepType: () => RouteFerryBeforeTravelStepType,
+  RouteFerryDepartureFilterSensitiveLog: () => RouteFerryDepartureFilterSensitiveLog,
+  RouteFerryLegDetailsFilterSensitiveLog: () => RouteFerryLegDetailsFilterSensitiveLog,
+  RouteFerryNoticeCode: () => RouteFerryNoticeCode,
+  RouteFerryOverviewSummaryFilterSensitiveLog: () => RouteFerryOverviewSummaryFilterSensitiveLog,
+  RouteFerryPlaceFilterSensitiveLog: () => RouteFerryPlaceFilterSensitiveLog,
+  RouteFerrySpanFilterSensitiveLog: () => RouteFerrySpanFilterSensitiveLog,
+  RouteFerrySummaryFilterSensitiveLog: () => RouteFerrySummaryFilterSensitiveLog,
+  RouteFerryTravelOnlySummaryFilterSensitiveLog: () => RouteFerryTravelOnlySummaryFilterSensitiveLog,
+  RouteFerryTravelStepFilterSensitiveLog: () => RouteFerryTravelStepFilterSensitiveLog,
+  RouteFerryTravelStepType: () => RouteFerryTravelStepType,
+  RouteFilterSensitiveLog: () => RouteFilterSensitiveLog,
+  RouteHazardousCargoType: () => RouteHazardousCargoType,
+  RouteKeepStepDetailsFilterSensitiveLog: () => RouteKeepStepDetailsFilterSensitiveLog,
+  RouteLegAdditionalFeature: () => RouteLegAdditionalFeature,
+  RouteLegFilterSensitiveLog: () => RouteLegFilterSensitiveLog,
+  RouteLegGeometryFilterSensitiveLog: () => RouteLegGeometryFilterSensitiveLog,
+  RouteLegTravelMode: () => RouteLegTravelMode,
+  RouteLegType: () => RouteLegType,
+  RouteMajorRoadLabelFilterSensitiveLog: () => RouteMajorRoadLabelFilterSensitiveLog,
+  RouteMatchingOptionsFilterSensitiveLog: () => RouteMatchingOptionsFilterSensitiveLog,
+  RouteMatrixAllowOptionsFilterSensitiveLog: () => RouteMatrixAllowOptionsFilterSensitiveLog,
+  RouteMatrixAutoCircleFilterSensitiveLog: () => RouteMatrixAutoCircleFilterSensitiveLog,
+  RouteMatrixAvoidanceAreaFilterSensitiveLog: () => RouteMatrixAvoidanceAreaFilterSensitiveLog,
+  RouteMatrixAvoidanceAreaGeometryFilterSensitiveLog: () => RouteMatrixAvoidanceAreaGeometryFilterSensitiveLog,
+  RouteMatrixAvoidanceOptionsFilterSensitiveLog: () => RouteMatrixAvoidanceOptionsFilterSensitiveLog,
+  RouteMatrixAvoidanceZoneCategoryFilterSensitiveLog: () => RouteMatrixAvoidanceZoneCategoryFilterSensitiveLog,
+  RouteMatrixBoundaryFilterSensitiveLog: () => RouteMatrixBoundaryFilterSensitiveLog,
+  RouteMatrixBoundaryGeometryFilterSensitiveLog: () => RouteMatrixBoundaryGeometryFilterSensitiveLog,
+  RouteMatrixCarOptionsFilterSensitiveLog: () => RouteMatrixCarOptionsFilterSensitiveLog,
+  RouteMatrixDestinationFilterSensitiveLog: () => RouteMatrixDestinationFilterSensitiveLog,
+  RouteMatrixDestinationOptionsFilterSensitiveLog: () => RouteMatrixDestinationOptionsFilterSensitiveLog,
+  RouteMatrixEntryFilterSensitiveLog: () => RouteMatrixEntryFilterSensitiveLog,
+  RouteMatrixErrorCode: () => RouteMatrixErrorCode,
+  RouteMatrixExclusionOptionsFilterSensitiveLog: () => RouteMatrixExclusionOptionsFilterSensitiveLog,
+  RouteMatrixHazardousCargoType: () => RouteMatrixHazardousCargoType,
+  RouteMatrixMatchingOptionsFilterSensitiveLog: () => RouteMatrixMatchingOptionsFilterSensitiveLog,
+  RouteMatrixOriginFilterSensitiveLog: () => RouteMatrixOriginFilterSensitiveLog,
+  RouteMatrixOriginOptionsFilterSensitiveLog: () => RouteMatrixOriginOptionsFilterSensitiveLog,
+  RouteMatrixScooterOptionsFilterSensitiveLog: () => RouteMatrixScooterOptionsFilterSensitiveLog,
+  RouteMatrixSideOfStreetOptionsFilterSensitiveLog: () => RouteMatrixSideOfStreetOptionsFilterSensitiveLog,
+  RouteMatrixTrafficOptionsFilterSensitiveLog: () => RouteMatrixTrafficOptionsFilterSensitiveLog,
+  RouteMatrixTrailerOptionsFilterSensitiveLog: () => RouteMatrixTrailerOptionsFilterSensitiveLog,
+  RouteMatrixTravelMode: () => RouteMatrixTravelMode,
+  RouteMatrixTravelModeOptionsFilterSensitiveLog: () => RouteMatrixTravelModeOptionsFilterSensitiveLog,
+  RouteMatrixTruckOptionsFilterSensitiveLog: () => RouteMatrixTruckOptionsFilterSensitiveLog,
+  RouteMatrixTruckType: () => RouteMatrixTruckType,
+  RouteMatrixVehicleLicensePlateFilterSensitiveLog: () => RouteMatrixVehicleLicensePlateFilterSensitiveLog,
+  RouteMatrixZoneCategory: () => RouteMatrixZoneCategory,
+  RouteNoticeImpact: () => RouteNoticeImpact,
+  RouteNumberFilterSensitiveLog: () => RouteNumberFilterSensitiveLog,
+  RouteOriginOptionsFilterSensitiveLog: () => RouteOriginOptionsFilterSensitiveLog,
+  RoutePassThroughPlaceFilterSensitiveLog: () => RoutePassThroughPlaceFilterSensitiveLog,
+  RoutePassThroughWaypointFilterSensitiveLog: () => RoutePassThroughWaypointFilterSensitiveLog,
+  RoutePedestrianArrivalFilterSensitiveLog: () => RoutePedestrianArrivalFilterSensitiveLog,
+  RoutePedestrianDepartureFilterSensitiveLog: () => RoutePedestrianDepartureFilterSensitiveLog,
+  RoutePedestrianLegDetailsFilterSensitiveLog: () => RoutePedestrianLegDetailsFilterSensitiveLog,
+  RoutePedestrianNoticeCode: () => RoutePedestrianNoticeCode,
+  RoutePedestrianOptionsFilterSensitiveLog: () => RoutePedestrianOptionsFilterSensitiveLog,
+  RoutePedestrianOverviewSummaryFilterSensitiveLog: () => RoutePedestrianOverviewSummaryFilterSensitiveLog,
+  RoutePedestrianPlaceFilterSensitiveLog: () => RoutePedestrianPlaceFilterSensitiveLog,
+  RoutePedestrianSpanFilterSensitiveLog: () => RoutePedestrianSpanFilterSensitiveLog,
+  RoutePedestrianSummaryFilterSensitiveLog: () => RoutePedestrianSummaryFilterSensitiveLog,
+  RoutePedestrianTravelOnlySummaryFilterSensitiveLog: () => RoutePedestrianTravelOnlySummaryFilterSensitiveLog,
+  RoutePedestrianTravelStepFilterSensitiveLog: () => RoutePedestrianTravelStepFilterSensitiveLog,
+  RoutePedestrianTravelStepType: () => RoutePedestrianTravelStepType,
+  RouteRampStepDetailsFilterSensitiveLog: () => RouteRampStepDetailsFilterSensitiveLog,
+  RouteResponseNoticeCode: () => RouteResponseNoticeCode,
+  RouteRoadFilterSensitiveLog: () => RouteRoadFilterSensitiveLog,
+  RouteRoadType: () => RouteRoadType,
+  RouteRoundaboutEnterStepDetailsFilterSensitiveLog: () => RouteRoundaboutEnterStepDetailsFilterSensitiveLog,
+  RouteRoundaboutExitStepDetailsFilterSensitiveLog: () => RouteRoundaboutExitStepDetailsFilterSensitiveLog,
+  RouteRoundaboutPassStepDetailsFilterSensitiveLog: () => RouteRoundaboutPassStepDetailsFilterSensitiveLog,
+  RouteScooterOptionsFilterSensitiveLog: () => RouteScooterOptionsFilterSensitiveLog,
+  RouteSideOfStreet: () => RouteSideOfStreet,
+  RouteSideOfStreetOptionsFilterSensitiveLog: () => RouteSideOfStreetOptionsFilterSensitiveLog,
+  RouteSignpostFilterSensitiveLog: () => RouteSignpostFilterSensitiveLog,
+  RouteSignpostLabelFilterSensitiveLog: () => RouteSignpostLabelFilterSensitiveLog,
+  RouteSpanAdditionalFeature: () => RouteSpanAdditionalFeature,
+  RouteSpanCarAccessAttribute: () => RouteSpanCarAccessAttribute,
+  RouteSpanDynamicSpeedDetailsFilterSensitiveLog: () => RouteSpanDynamicSpeedDetailsFilterSensitiveLog,
+  RouteSpanGateAttribute: () => RouteSpanGateAttribute,
+  RouteSpanPedestrianAccessAttribute: () => RouteSpanPedestrianAccessAttribute,
+  RouteSpanRailwayCrossingAttribute: () => RouteSpanRailwayCrossingAttribute,
+  RouteSpanRoadAttribute: () => RouteSpanRoadAttribute,
+  RouteSpanScooterAccessAttribute: () => RouteSpanScooterAccessAttribute,
+  RouteSpanSpeedLimitDetailsFilterSensitiveLog: () => RouteSpanSpeedLimitDetailsFilterSensitiveLog,
+  RouteSpanTruckAccessAttribute: () => RouteSpanTruckAccessAttribute,
+  RouteSteeringDirection: () => RouteSteeringDirection,
+  RouteSummaryFilterSensitiveLog: () => RouteSummaryFilterSensitiveLog,
+  RouteTollFilterSensitiveLog: () => RouteTollFilterSensitiveLog,
+  RouteTollOptionsFilterSensitiveLog: () => RouteTollOptionsFilterSensitiveLog,
+  RouteTollPassFilterSensitiveLog: () => RouteTollPassFilterSensitiveLog,
+  RouteTollPassValidityPeriodFilterSensitiveLog: () => RouteTollPassValidityPeriodFilterSensitiveLog,
+  RouteTollPassValidityPeriodType: () => RouteTollPassValidityPeriodType,
+  RouteTollPaymentMethod: () => RouteTollPaymentMethod,
+  RouteTollPaymentSiteFilterSensitiveLog: () => RouteTollPaymentSiteFilterSensitiveLog,
+  RouteTollPriceFilterSensitiveLog: () => RouteTollPriceFilterSensitiveLog,
+  RouteTollPriceSummaryFilterSensitiveLog: () => RouteTollPriceSummaryFilterSensitiveLog,
+  RouteTollPriceValueRangeFilterSensitiveLog: () => RouteTollPriceValueRangeFilterSensitiveLog,
+  RouteTollRateFilterSensitiveLog: () => RouteTollRateFilterSensitiveLog,
+  RouteTollSummaryFilterSensitiveLog: () => RouteTollSummaryFilterSensitiveLog,
+  RouteTollSystemFilterSensitiveLog: () => RouteTollSystemFilterSensitiveLog,
+  RouteTollVehicleCategory: () => RouteTollVehicleCategory,
+  RouteTrafficOptionsFilterSensitiveLog: () => RouteTrafficOptionsFilterSensitiveLog,
+  RouteTrailerOptionsFilterSensitiveLog: () => RouteTrailerOptionsFilterSensitiveLog,
+  RouteTransponderFilterSensitiveLog: () => RouteTransponderFilterSensitiveLog,
+  RouteTravelMode: () => RouteTravelMode,
+  RouteTravelModeOptionsFilterSensitiveLog: () => RouteTravelModeOptionsFilterSensitiveLog,
+  RouteTravelStepType: () => RouteTravelStepType,
+  RouteTruckOptionsFilterSensitiveLog: () => RouteTruckOptionsFilterSensitiveLog,
+  RouteTruckType: () => RouteTruckType,
+  RouteTurnIntensity: () => RouteTurnIntensity,
+  RouteTurnStepDetailsFilterSensitiveLog: () => RouteTurnStepDetailsFilterSensitiveLog,
+  RouteUTurnStepDetailsFilterSensitiveLog: () => RouteUTurnStepDetailsFilterSensitiveLog,
+  RouteVehicleArrivalFilterSensitiveLog: () => RouteVehicleArrivalFilterSensitiveLog,
+  RouteVehicleDepartureFilterSensitiveLog: () => RouteVehicleDepartureFilterSensitiveLog,
+  RouteVehicleIncidentFilterSensitiveLog: () => RouteVehicleIncidentFilterSensitiveLog,
+  RouteVehicleIncidentSeverity: () => RouteVehicleIncidentSeverity,
+  RouteVehicleIncidentType: () => RouteVehicleIncidentType,
+  RouteVehicleLegDetailsFilterSensitiveLog: () => RouteVehicleLegDetailsFilterSensitiveLog,
+  RouteVehicleLicensePlateFilterSensitiveLog: () => RouteVehicleLicensePlateFilterSensitiveLog,
+  RouteVehicleNoticeCode: () => RouteVehicleNoticeCode,
+  RouteVehicleNoticeDetailFilterSensitiveLog: () => RouteVehicleNoticeDetailFilterSensitiveLog,
+  RouteVehicleNoticeFilterSensitiveLog: () => RouteVehicleNoticeFilterSensitiveLog,
+  RouteVehicleOverviewSummaryFilterSensitiveLog: () => RouteVehicleOverviewSummaryFilterSensitiveLog,
+  RouteVehiclePlaceFilterSensitiveLog: () => RouteVehiclePlaceFilterSensitiveLog,
+  RouteVehicleSpanFilterSensitiveLog: () => RouteVehicleSpanFilterSensitiveLog,
+  RouteVehicleSummaryFilterSensitiveLog: () => RouteVehicleSummaryFilterSensitiveLog,
+  RouteVehicleTravelOnlySummaryFilterSensitiveLog: () => RouteVehicleTravelOnlySummaryFilterSensitiveLog,
+  RouteVehicleTravelStepFilterSensitiveLog: () => RouteVehicleTravelStepFilterSensitiveLog,
+  RouteVehicleTravelStepType: () => RouteVehicleTravelStepType,
+  RouteViolatedConstraintsFilterSensitiveLog: () => RouteViolatedConstraintsFilterSensitiveLog,
+  RouteWaypointFilterSensitiveLog: () => RouteWaypointFilterSensitiveLog,
+  RouteWeightConstraintFilterSensitiveLog: () => RouteWeightConstraintFilterSensitiveLog,
+  RouteWeightConstraintType: () => RouteWeightConstraintType,
+  RouteZoneCategory: () => RouteZoneCategory,
+  RouteZoneFilterSensitiveLog: () => RouteZoneFilterSensitiveLog,
+  RoutingObjective: () => RoutingObjective,
+  SideOfStreetMatchingStrategy: () => SideOfStreetMatchingStrategy,
+  SnapToRoadsCommand: () => SnapToRoadsCommand,
+  SnapToRoadsRequestFilterSensitiveLog: () => SnapToRoadsRequestFilterSensitiveLog,
+  SnapToRoadsResponseFilterSensitiveLog: () => SnapToRoadsResponseFilterSensitiveLog,
+  ThrottlingException: () => ThrottlingException,
+  TrafficUsage: () => TrafficUsage,
+  ValidationException: () => ValidationException,
+  ValidationExceptionReason: () => ValidationExceptionReason,
+  WaypointOptimizationAccessHoursEntryFilterSensitiveLog: () => WaypointOptimizationAccessHoursEntryFilterSensitiveLog,
+  WaypointOptimizationAccessHoursFilterSensitiveLog: () => WaypointOptimizationAccessHoursFilterSensitiveLog,
+  WaypointOptimizationAvoidanceAreaFilterSensitiveLog: () => WaypointOptimizationAvoidanceAreaFilterSensitiveLog,
+  WaypointOptimizationAvoidanceAreaGeometryFilterSensitiveLog: () => WaypointOptimizationAvoidanceAreaGeometryFilterSensitiveLog,
+  WaypointOptimizationAvoidanceOptionsFilterSensitiveLog: () => WaypointOptimizationAvoidanceOptionsFilterSensitiveLog,
+  WaypointOptimizationClusteringAlgorithm: () => WaypointOptimizationClusteringAlgorithm,
+  WaypointOptimizationClusteringOptionsFilterSensitiveLog: () => WaypointOptimizationClusteringOptionsFilterSensitiveLog,
+  WaypointOptimizationConnectionFilterSensitiveLog: () => WaypointOptimizationConnectionFilterSensitiveLog,
+  WaypointOptimizationConstraint: () => WaypointOptimizationConstraint,
+  WaypointOptimizationDestinationOptionsFilterSensitiveLog: () => WaypointOptimizationDestinationOptionsFilterSensitiveLog,
+  WaypointOptimizationDriverOptionsFilterSensitiveLog: () => WaypointOptimizationDriverOptionsFilterSensitiveLog,
+  WaypointOptimizationDrivingDistanceOptionsFilterSensitiveLog: () => WaypointOptimizationDrivingDistanceOptionsFilterSensitiveLog,
+  WaypointOptimizationExclusionOptionsFilterSensitiveLog: () => WaypointOptimizationExclusionOptionsFilterSensitiveLog,
+  WaypointOptimizationFailedConstraintFilterSensitiveLog: () => WaypointOptimizationFailedConstraintFilterSensitiveLog,
+  WaypointOptimizationHazardousCargoType: () => WaypointOptimizationHazardousCargoType,
+  WaypointOptimizationImpedingWaypointFilterSensitiveLog: () => WaypointOptimizationImpedingWaypointFilterSensitiveLog,
+  WaypointOptimizationOptimizedWaypointFilterSensitiveLog: () => WaypointOptimizationOptimizedWaypointFilterSensitiveLog,
+  WaypointOptimizationPedestrianOptionsFilterSensitiveLog: () => WaypointOptimizationPedestrianOptionsFilterSensitiveLog,
+  WaypointOptimizationRestCycleDurationsFilterSensitiveLog: () => WaypointOptimizationRestCycleDurationsFilterSensitiveLog,
+  WaypointOptimizationRestCyclesFilterSensitiveLog: () => WaypointOptimizationRestCyclesFilterSensitiveLog,
+  WaypointOptimizationRestProfileFilterSensitiveLog: () => WaypointOptimizationRestProfileFilterSensitiveLog,
+  WaypointOptimizationSequencingObjective: () => WaypointOptimizationSequencingObjective,
+  WaypointOptimizationServiceTimeTreatment: () => WaypointOptimizationServiceTimeTreatment,
+  WaypointOptimizationSideOfStreetOptionsFilterSensitiveLog: () => WaypointOptimizationSideOfStreetOptionsFilterSensitiveLog,
+  WaypointOptimizationTimeBreakdownFilterSensitiveLog: () => WaypointOptimizationTimeBreakdownFilterSensitiveLog,
+  WaypointOptimizationTrailerOptionsFilterSensitiveLog: () => WaypointOptimizationTrailerOptionsFilterSensitiveLog,
+  WaypointOptimizationTravelMode: () => WaypointOptimizationTravelMode,
+  WaypointOptimizationTravelModeOptionsFilterSensitiveLog: () => WaypointOptimizationTravelModeOptionsFilterSensitiveLog,
+  WaypointOptimizationTruckOptionsFilterSensitiveLog: () => WaypointOptimizationTruckOptionsFilterSensitiveLog,
+  WaypointOptimizationTruckType: () => WaypointOptimizationTruckType,
+  WaypointOptimizationWaypointFilterSensitiveLog: () => WaypointOptimizationWaypointFilterSensitiveLog,
+  WeightPerAxleGroupFilterSensitiveLog: () => WeightPerAxleGroupFilterSensitiveLog,
+  __Client: () => import_smithy_client.Client
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/GeoRoutesClient.ts
+var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
+var import_middleware_logger = require("@aws-sdk/middleware-logger");
+var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+var import_core = require("@smithy/core");
+var import_middleware_content_length = require("@smithy/middleware-content-length");
+var import_middleware_endpoint = require("@smithy/middleware-endpoint");
+var import_middleware_retry = require("@smithy/middleware-retry");
+
+var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return Object.assign(options, {
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "geo-routes"
+  });
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/GeoRoutesClient.ts
+var import_runtimeConfig = require("././runtimeConfig");
+
+// src/runtimeExtensions.ts
+var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
+var import_protocol_http = require("@smithy/protocol-http");
+var import_smithy_client = require("@smithy/smithy-client");
+
+// src/auth/httpAuthExtensionConfiguration.ts
+var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
+  const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
+  let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
+  let _credentials = runtimeConfig.credentials;
+  return {
+    setHttpAuthScheme(httpAuthScheme) {
+      const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
+      if (index === -1) {
+        _httpAuthSchemes.push(httpAuthScheme);
+      } else {
+        _httpAuthSchemes.splice(index, 1, httpAuthScheme);
+      }
+    },
+    httpAuthSchemes() {
+      return _httpAuthSchemes;
+    },
+    setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
+      _httpAuthSchemeProvider = httpAuthSchemeProvider;
+    },
+    httpAuthSchemeProvider() {
+      return _httpAuthSchemeProvider;
+    },
+    setCredentials(credentials) {
+      _credentials = credentials;
+    },
+    credentials() {
+      return _credentials;
+    }
+  };
+}, "getHttpAuthExtensionConfiguration");
+var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
+  return {
+    httpAuthSchemes: config.httpAuthSchemes(),
+    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
+    credentials: config.credentials()
+  };
+}, "resolveHttpAuthRuntimeConfig");
+
+// src/runtimeExtensions.ts
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = Object.assign(
+    (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),
+    (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),
+    (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),
+    getHttpAuthExtensionConfiguration(runtimeConfig)
+  );
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return Object.assign(
+    runtimeConfig,
+    (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
+    resolveHttpAuthRuntimeConfig(extensionConfiguration)
+  );
+}, "resolveRuntimeExtensions");
+
+// src/GeoRoutesClient.ts
+var GeoRoutesClient = class extends import_smithy_client.Client {
+  static {
+    __name(this, "GeoRoutesClient");
+  }
+  /**
+   * The resolved configuration of GeoRoutesClient class. This is resolved and normalized from the {@link GeoRoutesClientConfig | constructor configuration interface}.
+   */
+  config;
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    super(_config_0);
+    this.initConfig = _config_0;
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
+    const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
+    const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
+    const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
+    this.config = _config_8;
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
+    this.middlewareStack.use(
+      (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
+        httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultGeoRoutesHttpAuthSchemeParametersProvider,
+        identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({
+          "aws.auth#sigv4": config.credentials
+        }), "identityProviderConfigProvider")
+      })
+    );
+    this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
+  }
+  /**
+   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+   */
+  destroy() {
+    super.destroy();
+  }
+};
+
+// src/GeoRoutes.ts
+
+
+// src/commands/CalculateIsolinesCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+
+// src/models/models_0.ts
+
+
+// src/models/GeoRoutesServiceException.ts
+
+var GeoRoutesServiceException = class _GeoRoutesServiceException extends import_smithy_client.ServiceException {
+  static {
+    __name(this, "GeoRoutesServiceException");
+  }
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _GeoRoutesServiceException.prototype);
+  }
+};
+
+// src/models/models_0.ts
+var AccessDeniedException = class _AccessDeniedException extends GeoRoutesServiceException {
+  static {
+    __name(this, "AccessDeniedException");
+  }
+  name = "AccessDeniedException";
+  $fault = "client";
+  Message;
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AccessDeniedException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _AccessDeniedException.prototype);
+    this.Message = opts.Message;
+  }
+};
+var IsolineZoneCategory = {
+  CONGESTION_PRICING: "CongestionPricing",
+  ENVIRONMENTAL: "Environmental",
+  VIGNETTE: "Vignette"
+};
+var MatchingStrategy = {
+  MATCH_ANY: "MatchAny",
+  MATCH_MOST_SIGNIFICANT_ROAD: "MatchMostSignificantRoad"
+};
+var SideOfStreetMatchingStrategy = {
+  ANY_STREET: "AnyStreet",
+  DIVIDED_STREET_ONLY: "DividedStreetOnly"
+};
+var GeometryFormat = {
+  FLEXIBLE_POLYLINE: "FlexiblePolyline",
+  SIMPLE: "Simple"
+};
+var IsolineOptimizationObjective = {
+  ACCURATE_CALCULATION: "AccurateCalculation",
+  BALANCED_CALCULATION: "BalancedCalculation",
+  FAST_CALCULATION: "FastCalculation"
+};
+var RoutingObjective = {
+  FASTEST_ROUTE: "FastestRoute",
+  SHORTEST_ROUTE: "ShortestRoute"
+};
+var TrafficUsage = {
+  IGNORE_TRAFFIC_DATA: "IgnoreTrafficData",
+  USE_TRAFFIC_DATA: "UseTrafficData"
+};
+var IsolineTravelMode = {
+  CAR: "Car",
+  PEDESTRIAN: "Pedestrian",
+  SCOOTER: "Scooter",
+  TRUCK: "Truck"
+};
+var IsolineEngineType = {
+  ELECTRIC: "Electric",
+  INTERNAL_COMBUSTION: "InternalCombustion",
+  PLUGIN_HYBRID: "PluginHybrid"
+};
+var IsolineHazardousCargoType = {
+  COMBUSTIBLE: "Combustible",
+  CORROSIVE: "Corrosive",
+  EXPLOSIVE: "Explosive",
+  FLAMMABLE: "Flammable",
+  GAS: "Gas",
+  HARMFUL_TO_WATER: "HarmfulToWater",
+  ORGANIC: "Organic",
+  OTHER: "Other",
+  POISON: "Poison",
+  POISONOUS_INHALATION: "PoisonousInhalation",
+  RADIOACTIVE: "Radioactive"
+};
+var IsolineTruckType = {
+  LIGHT_TRUCK: "LightTruck",
+  STRAIGHT_TRUCK: "StraightTruck",
+  TRACTOR: "Tractor"
+};
+var InternalServerException = class _InternalServerException extends GeoRoutesServiceException {
+  static {
+    __name(this, "InternalServerException");
+  }
+  name = "InternalServerException";
+  $fault = "server";
+  $retryable = {};
+  Message;
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServerException",
+      $fault: "server",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _InternalServerException.prototype);
+    this.Message = opts.Message;
+  }
+};
+var ThrottlingException = class _ThrottlingException extends GeoRoutesServiceException {
+  static {
+    __name(this, "ThrottlingException");
+  }
+  name = "ThrottlingException";
+  $fault = "client";
+  $retryable = {};
+  Message;
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ThrottlingException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ThrottlingException.prototype);
+    this.Message = opts.Message;
+  }
+};
+var ValidationExceptionReason = {
+  /**
+   *     The input cannot be parsed. For example a required JSON document, ARN identifier,
+   *     date value, or numeric field cannot be parsed.
+   *
+   */
+  CANNOT_PARSE: "CannotParse",
+  /**
+   *     The input is present and parsable, but it is otherwise invalid. For example, a
+   *     required numeric argument is outside the allowed range.
+   *
+   */
+  FIELD_VALIDATION_FAILED: "FieldValidationFailed",
+  /**
+   * The required input is missing.
+   */
+  MISSING: "Missing",
+  /**
+   * The input is invalid but no more specific reason is applicable.
+   */
+  OTHER: "Other",
+  /**
+   * No such field is supported.
+   */
+  UNKNOWN_FIELD: "UnknownField",
+  /**
+   * No such operation is supported.
+   */
+  UNKNOWN_OPERATION: "UnknownOperation"
+};
+var ValidationException = class _ValidationException extends GeoRoutesServiceException {
+  static {
+    __name(this, "ValidationException");
+  }
+  name = "ValidationException";
+  $fault = "client";
+  Message;
+  /**
+   * <p>A message with the reason for the validation exception error.</p>
+   * @public
+   */
+  Reason;
+  /**
+   * <p>The field where the invalid entry was detected.</p>
+   * @public
+   */
+  FieldList;
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ValidationException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ValidationException.prototype);
+    this.Message = opts.Message;
+    this.Reason = opts.Reason;
+    this.FieldList = opts.FieldList;
+  }
+};
+var RouteMatrixZoneCategory = {
+  CONGESTION_PRICING: "CongestionPricing",
+  ENVIRONMENTAL: "Environmental",
+  VIGNETTE: "Vignette"
+};
+var RouteMatrixTravelMode = {
+  CAR: "Car",
+  PEDESTRIAN: "Pedestrian",
+  SCOOTER: "Scooter",
+  TRUCK: "Truck"
+};
+var RouteMatrixHazardousCargoType = {
+  COMBUSTIBLE: "Combustible",
+  CORROSIVE: "Corrosive",
+  EXPLOSIVE: "Explosive",
+  FLAMMABLE: "Flammable",
+  GAS: "Gas",
+  HARMFUL_TO_WATER: "HarmfulToWater",
+  ORGANIC: "Organic",
+  OTHER: "Other",
+  POISON: "Poison",
+  POISONOUS_INHALATION: "PoisonousInhalation",
+  RADIOACTIVE: "Radioactive"
+};
+var RouteMatrixTruckType = {
+  LIGHT_TRUCK: "LightTruck",
+  STRAIGHT_TRUCK: "StraightTruck",
+  TRACTOR: "Tractor"
+};
+var RouteMatrixErrorCode = {
+  NO_MATCH: "NoMatch",
+  NO_MATCH_DESTINATION: "NoMatchDestination",
+  NO_MATCH_ORIGIN: "NoMatchOrigin",
+  NO_ROUTE: "NoRoute",
+  OTHER: "Other",
+  OUT_OF_BOUNDS: "OutOfBounds",
+  OUT_OF_BOUNDS_DESTINATION: "OutOfBoundsDestination",
+  OUT_OF_BOUNDS_ORIGIN: "OutOfBoundsOrigin",
+  VIOLATION: "Violation"
+};
+var RouteZoneCategory = {
+  CONGESTION_PRICING: "CongestionPricing",
+  ENVIRONMENTAL: "Environmental",
+  VIGNETTE: "Vignette"
+};
+var MeasurementSystem = {
+  IMPERIAL: "Imperial",
+  METRIC: "Metric"
+};
+var RouteLegAdditionalFeature = {
+  ELEVATION: "Elevation",
+  INCIDENTS: "Incidents",
+  PASS_THROUGH_WAYPOINTS: "PassThroughWaypoints",
+  SUMMARY: "Summary",
+  TOLLS: "Tolls",
+  TRAVEL_STEP_INSTRUCTIONS: "TravelStepInstructions",
+  TRUCK_ROAD_TYPES: "TruckRoadTypes",
+  TYPICAL_DURATION: "TypicalDuration",
+  ZONES: "Zones"
+};
+var RouteSpanAdditionalFeature = {
+  BEST_CASE_DURATION: "BestCaseDuration",
+  CAR_ACCESS: "CarAccess",
+  CONSUMPTION: "Consumption",
+  COUNTRY: "Country",
+  DISTANCE: "Distance",
+  DURATION: "Duration",
+  DYNAMIC_SPEED: "DynamicSpeed",
+  FUNCTIONAL_CLASSIFICATION: "FunctionalClassification",
+  GATES: "Gates",
+  INCIDENTS: "Incidents",
+  NAMES: "Names",
+  NOTICES: "Notices",
+  PEDESTRIAN_ACCESS: "PedestrianAccess",
+  RAILWAY_CROSSINGS: "RailwayCrossings",
+  REGION: "Region",
+  ROAD_ATTRIBUTES: "RoadAttributes",
+  ROUTE_NUMBERS: "RouteNumbers",
+  SCOOTER_ACCESS: "ScooterAccess",
+  SPEED_LIMIT: "SpeedLimit",
+  TOLL_SYSTEMS: "TollSystems",
+  TRUCK_ACCESS: "TruckAccess",
+  TRUCK_ROAD_TYPES: "TruckRoadTypes",
+  TYPICAL_DURATION: "TypicalDuration",
+  ZONES: "Zones"
+};
+var RouteTollVehicleCategory = {
+  MINIBUS: "Minibus"
+};
+var RouteTravelMode = {
+  CAR: "Car",
+  PEDESTRIAN: "Pedestrian",
+  SCOOTER: "Scooter",
+  TRUCK: "Truck"
+};
+var RouteEngineType = {
+  ELECTRIC: "Electric",
+  INTERNAL_COMBUSTION: "InternalCombustion",
+  PLUGIN_HYBRID: "PluginHybrid"
+};
+var RouteHazardousCargoType = {
+  COMBUSTIBLE: "Combustible",
+  CORROSIVE: "Corrosive",
+  EXPLOSIVE: "Explosive",
+  FLAMMABLE: "Flammable",
+  GAS: "Gas",
+  HARMFUL_TO_WATER: "HarmfulToWater",
+  ORGANIC: "Organic",
+  OTHER: "Other",
+  POISON: "Poison",
+  POISONOUS_INHALATION: "PoisonousInhalation",
+  RADIOACTIVE: "Radioactive"
+};
+var RouteTruckType = {
+  LIGHT_TRUCK: "LightTruck",
+  STRAIGHT_TRUCK: "StraightTruck",
+  TRACTOR: "Tractor"
+};
+var RouteTravelStepType = {
+  DEFAULT: "Default",
+  TURN_BY_TURN: "TurnByTurn"
+};
+var RouteResponseNoticeCode = {
+  MAIN_LANGUAGE_NOT_FOUND: "MainLanguageNotFound",
+  OTHER: "Other",
+  TRAVEL_TIME_EXCEEDS_DRIVER_WORK_HOURS: "TravelTimeExceedsDriverWorkHours"
+};
+var RouteNoticeImpact = {
+  HIGH: "High",
+  LOW: "Low"
+};
+var RouteFerryAfterTravelStepType = {
+  DEBOARD: "Deboard"
+};
+var RouteFerryBeforeTravelStepType = {
+  BOARD: "Board"
+};
+var RouteFerryNoticeCode = {
+  ACCURATE_POLYLINE_UNAVAILABLE: "AccuratePolylineUnavailable",
+  NO_SCHEDULE: "NoSchedule",
+  OTHER: "Other",
+  POTENTIAL_VIOLATED_VEHICLE_RESTRICTION_USAGE: "PotentialViolatedVehicleRestrictionUsage",
+  SEASONAL_CLOSURE: "SeasonalClosure",
+  VIOLATED_AVOID_FERRY: "ViolatedAvoidFerry",
+  VIOLATED_AVOID_RAIL_FERRY: "ViolatedAvoidRailFerry"
+};
+var RouteFerryTravelStepType = {
+  ARRIVE: "Arrive",
+  CONTINUE: "Continue",
+  DEPART: "Depart"
+};
+var RouteSideOfStreet = {
+  LEFT: "Left",
+  RIGHT: "Right"
+};
+var RoutePedestrianNoticeCode = {
+  ACCURATE_POLYLINE_UNAVAILABLE: "AccuratePolylineUnavailable",
+  OTHER: "Other",
+  VIOLATED_AVOID_DIRT_ROAD: "ViolatedAvoidDirtRoad",
+  VIOLATED_AVOID_TUNNEL: "ViolatedAvoidTunnel",
+  VIOLATED_PEDESTRIAN_OPTION: "ViolatedPedestrianOption"
+};
+var RouteSpanPedestrianAccessAttribute = {
+  ALLOWED: "Allowed",
+  INDOORS: "Indoors",
+  NO_THROUGH_TRAFFIC: "NoThroughTraffic",
+  PARK: "Park",
+  STAIRS: "Stairs",
+  TOLL_ROAD: "TollRoad"
+};
+var RouteSpanRoadAttribute = {
+  BRIDGE: "Bridge",
+  BUILT_UP_AREA: "BuiltUpArea",
+  CONTROLLED_ACCESS_HIGHWAY: "ControlledAccessHighway",
+  DIRT_ROAD: "DirtRoad",
+  DIVIDED_ROAD: "DividedRoad",
+  MOTORWAY: "Motorway",
+  PRIVATE_ROAD: "PrivateRoad",
+  RAMP: "Ramp",
+  RIGHT_HAND_TRAFFIC: "RightHandTraffic",
+  ROUNDABOUT: "Roundabout",
+  TUNNEL: "Tunnel",
+  UNDER_CONSTRUCTION: "UnderConstruction"
+};
+var RouteDirection = {
+  EAST: "East",
+  NORTH: "North",
+  SOUTH: "South",
+  WEST: "West"
+};
+var RouteRoadType = {
+  HIGHWAY: "Highway",
+  RURAL: "Rural",
+  URBAN: "Urban"
+};
+var RouteSteeringDirection = {
+  LEFT: "Left",
+  RIGHT: "Right",
+  STRAIGHT: "Straight"
+};
+var RouteTurnIntensity = {
+  SHARP: "Sharp",
+  SLIGHT: "Slight",
+  TYPICAL: "Typical"
+};
+var RoutePedestrianTravelStepType = {
+  ARRIVE: "Arrive",
+  CONTINUE: "Continue",
+  DEPART: "Depart",
+  EXIT: "Exit",
+  KEEP: "Keep",
+  RAMP: "Ramp",
+  ROUNDABOUT_ENTER: "RoundaboutEnter",
+  ROUNDABOUT_EXIT: "RoundaboutExit",
+  ROUNDABOUT_PASS: "RoundaboutPass",
+  TURN: "Turn",
+  U_TURN: "UTurn"
+};
+var RouteLegTravelMode = {
+  CAR: "Car",
+  CAR_SHUTTLE_TRAIN: "CarShuttleTrain",
+  FERRY: "Ferry",
+  PEDESTRIAN: "Pedestrian",
+  SCOOTER: "Scooter",
+  TRUCK: "Truck"
+};
+var RouteLegType = {
+  FERRY: "Ferry",
+  PEDESTRIAN: "Pedestrian",
+  VEHICLE: "Vehicle"
+};
+var RouteVehicleIncidentSeverity = {
+  CRITICAL: "Critical",
+  HIGH: "High",
+  LOW: "Low",
+  MEDIUM: "Medium"
+};
+var RouteVehicleIncidentType = {
+  ACCIDENT: "Accident",
+  CONGESTION: "Congestion",
+  CONSTRUCTION: "Construction",
+  DISABLED_VEHICLE: "DisabledVehicle",
+  LANE_RESTRICTION: "LaneRestriction",
+  MASS_TRANSIT: "MassTransit",
+  OTHER: "Other",
+  PLANNED_EVENT: "PlannedEvent",
+  ROAD_CLOSURE: "RoadClosure",
+  ROAD_HAZARD: "RoadHazard",
+  WEATHER: "Weather"
+};
+var RouteVehicleNoticeCode = {
+  ACCURATE_POLYLINE_UNAVAILABLE: "AccuratePolylineUnavailable",
+  OTHER: "Other",
+  POTENTIAL_VIOLATED_AVOID_TOLL_ROAD_USAGE: "PotentialViolatedAvoidTollRoadUsage",
+  POTENTIAL_VIOLATED_CARPOOL_USAGE: "PotentialViolatedCarpoolUsage",
+  POTENTIAL_VIOLATED_TURN_RESTRICTION_USAGE: "PotentialViolatedTurnRestrictionUsage",
+  POTENTIAL_VIOLATED_VEHICLE_RESTRICTION_USAGE: "PotentialViolatedVehicleRestrictionUsage",
+  POTENTIAL_VIOLATED_ZONE_RESTRICTION_USAGE: "PotentialViolatedZoneRestrictionUsage",
+  SEASONAL_CLOSURE: "SeasonalClosure",
+  TOLLS_DATA_TEMPORARILY_UNAVAILABLE: "TollsDataTemporarilyUnavailable",
+  TOLLS_DATA_UNAVAILABLE: "TollsDataUnavailable",
+  TOLL_TRANSPONDER: "TollTransponder",
+  VIOLATED_AVOID_CONTROLLED_ACCESS_HIGHWAY: "ViolatedAvoidControlledAccessHighway",
+  VIOLATED_AVOID_DIFFICULT_TURNS: "ViolatedAvoidDifficultTurns",
+  VIOLATED_AVOID_DIRT_ROAD: "ViolatedAvoidDirtRoad",
+  VIOLATED_AVOID_SEASONAL_CLOSURE: "ViolatedAvoidSeasonalClosure",
+  VIOLATED_AVOID_TOLL_ROAD: "ViolatedAvoidTollRoad",
+  VIOLATED_AVOID_TOLL_TRANSPONDER: "ViolatedAvoidTollTransponder",
+  VIOLATED_AVOID_TRUCK_ROAD_TYPE: "ViolatedAvoidTruckRoadType",
+  VIOLATED_AVOID_TUNNEL: "ViolatedAvoidTunnel",
+  VIOLATED_AVOID_U_TURNS: "ViolatedAvoidUTurns",
+  VIOLATED_BLOCKED_ROAD: "ViolatedBlockedRoad",
+  VIOLATED_CARPOOL: "ViolatedCarpool",
+  VIOLATED_EMERGENCY_GATE: "ViolatedEmergencyGate",
+  VIOLATED_START_DIRECTION: "ViolatedStartDirection",
+  VIOLATED_TURN_RESTRICTION: "ViolatedTurnRestriction",
+  VIOLATED_VEHICLE_RESTRICTION: "ViolatedVehicleRestriction",
+  VIOLATED_ZONE_RESTRICTION: "ViolatedZoneRestriction"
+};
+var RouteWeightConstraintType = {
+  CURRENT: "Current",
+  GROSS: "Gross",
+  UNKNOWN: "Unknown"
+};
+var RouteSpanCarAccessAttribute = {
+  ALLOWED: "Allowed",
+  NO_THROUGH_TRAFFIC: "NoThroughTraffic",
+  TOLL_ROAD: "TollRoad"
+};
+var RouteSpanGateAttribute = {
+  EMERGENCY: "Emergency",
+  KEY_ACCESS: "KeyAccess",
+  PERMISSION_REQUIRED: "PermissionRequired"
+};
+var RouteSpanRailwayCrossingAttribute = {
+  PROTECTED: "Protected",
+  UNPROTECTED: "Unprotected"
+};
+var RouteSpanScooterAccessAttribute = {
+  ALLOWED: "Allowed",
+  NO_THROUGH_TRAFFIC: "NoThroughTraffic",
+  TOLL_ROAD: "TollRoad"
+};
+var RouteSpanTruckAccessAttribute = {
+  ALLOWED: "Allowed",
+  NO_THROUGH_TRAFFIC: "NoThroughTraffic",
+  TOLL_ROAD: "TollRoad"
+};
+var RouteTollPassValidityPeriodType = {
+  ANNUAL: "Annual",
+  DAYS: "Days",
+  EXTENDED_ANNUAL: "ExtendedAnnual",
+  MINUTES: "Minutes",
+  MONTHS: "Months"
+};
+var RouteTollPaymentMethod = {
+  BANK_CARD: "BankCard",
+  CASH: "Cash",
+  CASH_EXACT: "CashExact",
+  CREDIT_CARD: "CreditCard",
+  PASS_SUBSCRIPTION: "PassSubscription",
+  TRANSPONDER: "Transponder",
+  TRAVEL_CARD: "TravelCard",
+  VIDEO_TOLL: "VideoToll"
+};
+var RouteVehicleTravelStepType = {
+  ARRIVE: "Arrive",
+  CONTINUE: "Continue",
+  CONTINUE_HIGHWAY: "ContinueHighway",
+  DEPART: "Depart",
+  ENTER_HIGHWAY: "EnterHighway",
+  EXIT: "Exit",
+  KEEP: "Keep",
+  RAMP: "Ramp",
+  ROUNDABOUT_ENTER: "RoundaboutEnter",
+  ROUNDABOUT_EXIT: "RoundaboutExit",
+  ROUNDABOUT_PASS: "RoundaboutPass",
+  TURN: "Turn",
+  U_TURN: "UTurn"
+};
+var DayOfWeek = {
+  FRIDAY: "Friday",
+  MONDAY: "Monday",
+  SATURDAY: "Saturday",
+  SUNDAY: "Sunday",
+  THURSDAY: "Thursday",
+  TUESDAY: "Tuesday",
+  WEDNESDAY: "Wednesday"
+};
+var WaypointOptimizationClusteringAlgorithm = {
+  DRIVING_DISTANCE: "DrivingDistance",
+  TOPOLOGY_SEGMENT: "TopologySegment"
+};
+var WaypointOptimizationServiceTimeTreatment = {
+  REST: "Rest",
+  WORK: "Work"
+};
+var WaypointOptimizationSequencingObjective = {
+  FASTEST_ROUTE: "FastestRoute",
+  SHORTEST_ROUTE: "ShortestRoute"
+};
+var WaypointOptimizationTravelMode = {
+  CAR: "Car",
+  PEDESTRIAN: "Pedestrian",
+  SCOOTER: "Scooter",
+  TRUCK: "Truck"
+};
+var WaypointOptimizationHazardousCargoType = {
+  COMBUSTIBLE: "Combustible",
+  CORROSIVE: "Corrosive",
+  EXPLOSIVE: "Explosive",
+  FLAMMABLE: "Flammable",
+  GAS: "Gas",
+  HARMFUL_TO_WATER: "HarmfulToWater",
+  ORGANIC: "Organic",
+  OTHER: "Other",
+  POISON: "Poison",
+  POISONOUS_INHALATION: "PoisonousInhalation",
+  RADIOACTIVE: "Radioactive"
+};
+var WaypointOptimizationTruckType = {
+  STRAIGHT_TRUCK: "StraightTruck",
+  TRACTOR: "Tractor"
+};
+var WaypointOptimizationConstraint = {
+  ACCESS_HOURS: "AccessHours",
+  APPOINTMENT_TIME: "AppointmentTime",
+  BEFORE: "Before",
+  HEADING: "Heading",
+  SERVICE_DURATION: "ServiceDuration",
+  SIDE_OF_STREET: "SideOfStreet"
+};
+var RoadSnapTravelMode = {
+  CAR: "Car",
+  PEDESTRIAN: "Pedestrian",
+  SCOOTER: "Scooter",
+  TRUCK: "Truck"
+};
+var RoadSnapHazardousCargoType = {
+  COMBUSTIBLE: "Combustible",
+  CORROSIVE: "Corrosive",
+  EXPLOSIVE: "Explosive",
+  FLAMMABLE: "Flammable",
+  GAS: "Gas",
+  HARMFUL_TO_WATER: "HarmfulToWater",
+  ORGANIC: "Organic",
+  OTHER: "Other",
+  POISON: "Poison",
+  POISONOUS_INHALATION: "PoisonousInhalation",
+  RADIOACTIVE: "Radioactive"
+};
+var RoadSnapNoticeCode = {
+  TRACE_POINTS_HEADING_IGNORED: "TracePointsHeadingIgnored",
+  TRACE_POINTS_IGNORED: "TracePointsIgnored",
+  TRACE_POINTS_MOVED_BY_LARGE_DISTANCE: "TracePointsMovedByLargeDistance",
+  TRACE_POINTS_NOT_MATCHED: "TracePointsNotMatched",
+  TRACE_POINTS_OUT_OF_SEQUENCE: "TracePointsOutOfSequence",
+  TRACE_POINTS_SPEED_ESTIMATED: "TracePointsSpeedEstimated",
+  TRACE_POINTS_SPEED_IGNORED: "TracePointsSpeedIgnored"
+};
+var IsolineAllowOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Hot && { Hot: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Hov && { Hov: import_smithy_client.SENSITIVE_STRING }
+}), "IsolineAllowOptionsFilterSensitiveLog");
+var CorridorFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.LineString && { LineString: import_smithy_client.SENSITIVE_STRING }
+}), "CorridorFilterSensitiveLog");
+var PolylineCorridorFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Polyline && { Polyline: import_smithy_client.SENSITIVE_STRING }
+}), "PolylineCorridorFilterSensitiveLog");
+var IsolineAvoidanceAreaGeometryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.BoundingBox && { BoundingBox: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Corridor && { Corridor: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Polygon && { Polygon: obj.Polygon.map((item) => import_smithy_client.SENSITIVE_STRING) },
+  ...obj.PolylineCorridor && { PolylineCorridor: import_smithy_client.SENSITIVE_STRING },
+  ...obj.PolylinePolygon && { PolylinePolygon: import_smithy_client.SENSITIVE_STRING }
+}), "IsolineAvoidanceAreaGeometryFilterSensitiveLog");
+var IsolineAvoidanceAreaFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Except && { Except: obj.Except.map((item) => IsolineAvoidanceAreaGeometryFilterSensitiveLog(item)) },
+  ...obj.Geometry && { Geometry: IsolineAvoidanceAreaGeometryFilterSensitiveLog(obj.Geometry) }
+}), "IsolineAvoidanceAreaFilterSensitiveLog");
+var IsolineAvoidanceOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Areas && { Areas: obj.Areas.map((item) => IsolineAvoidanceAreaFilterSensitiveLog(item)) },
+  ...obj.CarShuttleTrains && { CarShuttleTrains: import_smithy_client.SENSITIVE_STRING },
+  ...obj.ControlledAccessHighways && { ControlledAccessHighways: import_smithy_client.SENSITIVE_STRING },
+  ...obj.DirtRoads && { DirtRoads: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Ferries && { Ferries: import_smithy_client.SENSITIVE_STRING },
+  ...obj.SeasonalClosure && { SeasonalClosure: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TollRoads && { TollRoads: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TollTransponders && { TollTransponders: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TruckRoadTypes && { TruckRoadTypes: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Tunnels && { Tunnels: import_smithy_client.SENSITIVE_STRING },
+  ...obj.UTurns && { UTurns: import_smithy_client.SENSITIVE_STRING }
+}), "IsolineAvoidanceOptionsFilterSensitiveLog");
+var IsolineMatchingOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.NameHint && { NameHint: import_smithy_client.SENSITIVE_STRING },
+  ...obj.OnRoadThreshold && { OnRoadThreshold: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Radius && { Radius: import_smithy_client.SENSITIVE_STRING }
+}), "IsolineMatchingOptionsFilterSensitiveLog");
+var IsolineSideOfStreetOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Position && { Position: import_smithy_client.SENSITIVE_STRING }
+}), "IsolineSideOfStreetOptionsFilterSensitiveLog");
+var IsolineDestinationOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.AvoidActionsForDistance && { AvoidActionsForDistance: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Heading && { Heading: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Matching && { Matching: IsolineMatchingOptionsFilterSensitiveLog(obj.Matching) },
+  ...obj.SideOfStreet && { SideOfStreet: IsolineSideOfStreetOptionsFilterSensitiveLog(obj.SideOfStreet) }
+}), "IsolineDestinationOptionsFilterSensitiveLog");
+var IsolineGranularityOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.MaxResolution && { MaxResolution: import_smithy_client.SENSITIVE_STRING }
+}), "IsolineGranularityOptionsFilterSensitiveLog");
+var IsolineOriginOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.AvoidActionsForDistance && { AvoidActionsForDistance: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Heading && { Heading: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Matching && { Matching: IsolineMatchingOptionsFilterSensitiveLog(obj.Matching) },
+  ...obj.SideOfStreet && { SideOfStreet: IsolineSideOfStreetOptionsFilterSensitiveLog(obj.SideOfStreet) }
+}), "IsolineOriginOptionsFilterSensitiveLog");
+var IsolineThresholdsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Distance && { Distance: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Time && { Time: import_smithy_client.SENSITIVE_STRING }
+}), "IsolineThresholdsFilterSensitiveLog");
+var IsolineTrafficOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.FlowEventThresholdOverride && { FlowEventThresholdOverride: import_smithy_client.SENSITIVE_STRING }
+}), "IsolineTrafficOptionsFilterSensitiveLog");
+var IsolineVehicleLicensePlateFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj
+}), "IsolineVehicleLicensePlateFilterSensitiveLog");
+var IsolineCarOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.EngineType && { EngineType: import_smithy_client.SENSITIVE_STRING },
+  ...obj.LicensePlate && { LicensePlate: import_smithy_client.SENSITIVE_STRING },
+  ...obj.MaxSpeed && { MaxSpeed: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Occupancy && { Occupancy: import_smithy_client.SENSITIVE_STRING }
+}), "IsolineCarOptionsFilterSensitiveLog");
+var IsolineScooterOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.EngineType && { EngineType: import_smithy_client.SENSITIVE_STRING },
+  ...obj.LicensePlate && { LicensePlate: import_smithy_client.SENSITIVE_STRING },
+  ...obj.MaxSpeed && { MaxSpeed: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Occupancy && { Occupancy: import_smithy_client.SENSITIVE_STRING }
+}), "IsolineScooterOptionsFilterSensitiveLog");
+var IsolineTrailerOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.AxleCount && { AxleCount: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TrailerCount && { TrailerCount: import_smithy_client.SENSITIVE_STRING }
+}), "IsolineTrailerOptionsFilterSensitiveLog");
+var WeightPerAxleGroupFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Single && { Single: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Tandem && { Tandem: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Triple && { Triple: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Quad && { Quad: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Quint && { Quint: import_smithy_client.SENSITIVE_STRING }
+}), "WeightPerAxleGroupFilterSensitiveLog");
+var IsolineTruckOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.AxleCount && { AxleCount: import_smithy_client.SENSITIVE_STRING },
+  ...obj.EngineType && { EngineType: import_smithy_client.SENSITIVE_STRING },
+  ...obj.GrossWeight && { GrossWeight: import_smithy_client.SENSITIVE_STRING },
+  ...obj.HazardousCargos && { HazardousCargos: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Height && { Height: import_smithy_client.SENSITIVE_STRING },
+  ...obj.HeightAboveFirstAxle && { HeightAboveFirstAxle: import_smithy_client.SENSITIVE_STRING },
+  ...obj.KpraLength && { KpraLength: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Length && { Length: import_smithy_client.SENSITIVE_STRING },
+  ...obj.LicensePlate && { LicensePlate: import_smithy_client.SENSITIVE_STRING },
+  ...obj.MaxSpeed && { MaxSpeed: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Occupancy && { Occupancy: import_smithy_client.SENSITIVE_STRING },
+  ...obj.PayloadCapacity && { PayloadCapacity: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TireCount && { TireCount: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Trailer && { Trailer: IsolineTrailerOptionsFilterSensitiveLog(obj.Trailer) },
+  ...obj.TunnelRestrictionCode && { TunnelRestrictionCode: import_smithy_client.SENSITIVE_STRING },
+  ...obj.WeightPerAxle && { WeightPerAxle: import_smithy_client.SENSITIVE_STRING },
+  ...obj.WeightPerAxleGroup && { WeightPerAxleGroup: WeightPerAxleGroupFilterSensitiveLog(obj.WeightPerAxleGroup) },
+  ...obj.Width && { Width: import_smithy_client.SENSITIVE_STRING }
+}), "IsolineTruckOptionsFilterSensitiveLog");
+var IsolineTravelModeOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Car && { Car: IsolineCarOptionsFilterSensitiveLog(obj.Car) },
+  ...obj.Scooter && { Scooter: IsolineScooterOptionsFilterSensitiveLog(obj.Scooter) },
+  ...obj.Truck && { Truck: IsolineTruckOptionsFilterSensitiveLog(obj.Truck) }
+}), "IsolineTravelModeOptionsFilterSensitiveLog");
+var CalculateIsolinesRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Allow && { Allow: IsolineAllowOptionsFilterSensitiveLog(obj.Allow) },
+  ...obj.ArrivalTime && { ArrivalTime: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Avoid && { Avoid: IsolineAvoidanceOptionsFilterSensitiveLog(obj.Avoid) },
+  ...obj.DepartNow && { DepartNow: import_smithy_client.SENSITIVE_STRING },
+  ...obj.DepartureTime && { DepartureTime: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Destination && { Destination: import_smithy_client.SENSITIVE_STRING },
+  ...obj.DestinationOptions && {
+    DestinationOptions: IsolineDestinationOptionsFilterSensitiveLog(obj.DestinationOptions)
+  },
+  ...obj.IsolineGranularity && {
+    IsolineGranularity: IsolineGranularityOptionsFilterSensitiveLog(obj.IsolineGranularity)
+  },
+  ...obj.Key && { Key: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Origin && { Origin: import_smithy_client.SENSITIVE_STRING },
+  ...obj.OriginOptions && { OriginOptions: IsolineOriginOptionsFilterSensitiveLog(obj.OriginOptions) },
+  ...obj.Thresholds && { Thresholds: IsolineThresholdsFilterSensitiveLog(obj.Thresholds) },
+  ...obj.Traffic && { Traffic: IsolineTrafficOptionsFilterSensitiveLog(obj.Traffic) },
+  ...obj.TravelModeOptions && {
+    TravelModeOptions: IsolineTravelModeOptionsFilterSensitiveLog(obj.TravelModeOptions)
+  }
+}), "CalculateIsolinesRequestFilterSensitiveLog");
+var IsolineConnectionGeometryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.LineString && { LineString: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Polyline && { Polyline: import_smithy_client.SENSITIVE_STRING }
+}), "IsolineConnectionGeometryFilterSensitiveLog");
+var IsolineConnectionFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Geometry && { Geometry: IsolineConnectionGeometryFilterSensitiveLog(obj.Geometry) }
+}), "IsolineConnectionFilterSensitiveLog");
+var IsolineShapeGeometryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Polygon && { Polygon: obj.Polygon.map((item) => import_smithy_client.SENSITIVE_STRING) },
+  ...obj.PolylinePolygon && { PolylinePolygon: import_smithy_client.SENSITIVE_STRING }
+}), "IsolineShapeGeometryFilterSensitiveLog");
+var IsolineFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Connections && { Connections: obj.Connections.map((item) => IsolineConnectionFilterSensitiveLog(item)) },
+  ...obj.DistanceThreshold && { DistanceThreshold: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Geometries && { Geometries: obj.Geometries.map((item) => IsolineShapeGeometryFilterSensitiveLog(item)) },
+  ...obj.TimeThreshold && { TimeThreshold: import_smithy_client.SENSITIVE_STRING }
+}), "IsolineFilterSensitiveLog");
+var CalculateIsolinesResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.ArrivalTime && { ArrivalTime: import_smithy_client.SENSITIVE_STRING },
+  ...obj.DepartureTime && { DepartureTime: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Isolines && { Isolines: obj.Isolines.map((item) => IsolineFilterSensitiveLog(item)) },
+  ...obj.SnappedDestination && { SnappedDestination: import_smithy_client.SENSITIVE_STRING },
+  ...obj.SnappedOrigin && { SnappedOrigin: import_smithy_client.SENSITIVE_STRING }
+}), "CalculateIsolinesResponseFilterSensitiveLog");
+var RouteMatrixAllowOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Hot && { Hot: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Hov && { Hov: import_smithy_client.SENSITIVE_STRING }
+}), "RouteMatrixAllowOptionsFilterSensitiveLog");
+var RouteMatrixAvoidanceAreaGeometryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.BoundingBox && { BoundingBox: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Polygon && { Polygon: obj.Polygon.map((item) => import_smithy_client.SENSITIVE_STRING) },
+  ...obj.PolylinePolygon && { PolylinePolygon: import_smithy_client.SENSITIVE_STRING }
+}), "RouteMatrixAvoidanceAreaGeometryFilterSensitiveLog");
+var RouteMatrixAvoidanceAreaFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Geometry && { Geometry: RouteMatrixAvoidanceAreaGeometryFilterSensitiveLog(obj.Geometry) }
+}), "RouteMatrixAvoidanceAreaFilterSensitiveLog");
+var RouteMatrixAvoidanceZoneCategoryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Category && { Category: import_smithy_client.SENSITIVE_STRING }
+}), "RouteMatrixAvoidanceZoneCategoryFilterSensitiveLog");
+var RouteMatrixAvoidanceOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Areas && { Areas: obj.Areas.map((item) => RouteMatrixAvoidanceAreaFilterSensitiveLog(item)) },
+  ...obj.CarShuttleTrains && { CarShuttleTrains: import_smithy_client.SENSITIVE_STRING },
+  ...obj.ControlledAccessHighways && { ControlledAccessHighways: import_smithy_client.SENSITIVE_STRING },
+  ...obj.DirtRoads && { DirtRoads: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Ferries && { Ferries: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TollRoads && { TollRoads: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TollTransponders && { TollTransponders: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TruckRoadTypes && { TruckRoadTypes: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Tunnels && { Tunnels: import_smithy_client.SENSITIVE_STRING },
+  ...obj.UTurns && { UTurns: import_smithy_client.SENSITIVE_STRING },
+  ...obj.ZoneCategories && {
+    ZoneCategories: obj.ZoneCategories.map((item) => RouteMatrixAvoidanceZoneCategoryFilterSensitiveLog(item))
+  }
+}), "RouteMatrixAvoidanceOptionsFilterSensitiveLog");
+var RouteMatrixMatchingOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.NameHint && { NameHint: import_smithy_client.SENSITIVE_STRING },
+  ...obj.OnRoadThreshold && { OnRoadThreshold: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Radius && { Radius: import_smithy_client.SENSITIVE_STRING }
+}), "RouteMatrixMatchingOptionsFilterSensitiveLog");
+var RouteMatrixSideOfStreetOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Position && { Position: import_smithy_client.SENSITIVE_STRING }
+}), "RouteMatrixSideOfStreetOptionsFilterSensitiveLog");
+var RouteMatrixDestinationOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.AvoidActionsForDistance && { AvoidActionsForDistance: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Heading && { Heading: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Matching && { Matching: RouteMatrixMatchingOptionsFilterSensitiveLog(obj.Matching) },
+  ...obj.SideOfStreet && { SideOfStreet: RouteMatrixSideOfStreetOptionsFilterSensitiveLog(obj.SideOfStreet) }
+}), "RouteMatrixDestinationOptionsFilterSensitiveLog");
+var RouteMatrixDestinationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Options && { Options: RouteMatrixDestinationOptionsFilterSensitiveLog(obj.Options) },
+  ...obj.Position && { Position: import_smithy_client.SENSITIVE_STRING }
+}), "RouteMatrixDestinationFilterSensitiveLog");
+var RouteMatrixExclusionOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Countries && { Countries: import_smithy_client.SENSITIVE_STRING }
+}), "RouteMatrixExclusionOptionsFilterSensitiveLog");
+var RouteMatrixOriginOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.AvoidActionsForDistance && { AvoidActionsForDistance: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Heading && { Heading: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Matching && { Matching: RouteMatrixMatchingOptionsFilterSensitiveLog(obj.Matching) },
+  ...obj.SideOfStreet && { SideOfStreet: RouteMatrixSideOfStreetOptionsFilterSensitiveLog(obj.SideOfStreet) }
+}), "RouteMatrixOriginOptionsFilterSensitiveLog");
+var RouteMatrixOriginFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Options && { Options: RouteMatrixOriginOptionsFilterSensitiveLog(obj.Options) },
+  ...obj.Position && { Position: import_smithy_client.SENSITIVE_STRING }
+}), "RouteMatrixOriginFilterSensitiveLog");
+var RouteMatrixAutoCircleFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Margin && { Margin: import_smithy_client.SENSITIVE_STRING },
+  ...obj.MaxRadius && { MaxRadius: import_smithy_client.SENSITIVE_STRING }
+}), "RouteMatrixAutoCircleFilterSensitiveLog");
+var CircleFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Center && { Center: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Radius && { Radius: import_smithy_client.SENSITIVE_STRING }
+}), "CircleFilterSensitiveLog");
+var RouteMatrixBoundaryGeometryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.AutoCircle && { AutoCircle: RouteMatrixAutoCircleFilterSensitiveLog(obj.AutoCircle) },
+  ...obj.Circle && { Circle: import_smithy_client.SENSITIVE_STRING },
+  ...obj.BoundingBox && { BoundingBox: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Polygon && { Polygon: obj.Polygon.map((item) => import_smithy_client.SENSITIVE_STRING) }
+}), "RouteMatrixBoundaryGeometryFilterSensitiveLog");
+var RouteMatrixBoundaryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Geometry && { Geometry: RouteMatrixBoundaryGeometryFilterSensitiveLog(obj.Geometry) },
+  ...obj.Unbounded && { Unbounded: import_smithy_client.SENSITIVE_STRING }
+}), "RouteMatrixBoundaryFilterSensitiveLog");
+var RouteMatrixTrafficOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.FlowEventThresholdOverride && { FlowEventThresholdOverride: import_smithy_client.SENSITIVE_STRING }
+}), "RouteMatrixTrafficOptionsFilterSensitiveLog");
+var RouteMatrixVehicleLicensePlateFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj
+}), "RouteMatrixVehicleLicensePlateFilterSensitiveLog");
+var RouteMatrixCarOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.LicensePlate && { LicensePlate: import_smithy_client.SENSITIVE_STRING },
+  ...obj.MaxSpeed && { MaxSpeed: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Occupancy && { Occupancy: import_smithy_client.SENSITIVE_STRING }
+}), "RouteMatrixCarOptionsFilterSensitiveLog");
+var RouteMatrixScooterOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.LicensePlate && { LicensePlate: import_smithy_client.SENSITIVE_STRING },
+  ...obj.MaxSpeed && { MaxSpeed: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Occupancy && { Occupancy: import_smithy_client.SENSITIVE_STRING }
+}), "RouteMatrixScooterOptionsFilterSensitiveLog");
+var RouteMatrixTrailerOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.TrailerCount && { TrailerCount: import_smithy_client.SENSITIVE_STRING }
+}), "RouteMatrixTrailerOptionsFilterSensitiveLog");
+var RouteMatrixTruckOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.AxleCount && { AxleCount: import_smithy_client.SENSITIVE_STRING },
+  ...obj.GrossWeight && { GrossWeight: import_smithy_client.SENSITIVE_STRING },
+  ...obj.HazardousCargos && { HazardousCargos: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Height && { Height: import_smithy_client.SENSITIVE_STRING },
+  ...obj.KpraLength && { KpraLength: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Length && { Length: import_smithy_client.SENSITIVE_STRING },
+  ...obj.LicensePlate && { LicensePlate: import_smithy_client.SENSITIVE_STRING },
+  ...obj.MaxSpeed && { MaxSpeed: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Occupancy && { Occupancy: import_smithy_client.SENSITIVE_STRING },
+  ...obj.PayloadCapacity && { PayloadCapacity: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Trailer && { Trailer: RouteMatrixTrailerOptionsFilterSensitiveLog(obj.Trailer) },
+  ...obj.TruckType && { TruckType: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TunnelRestrictionCode && { TunnelRestrictionCode: import_smithy_client.SENSITIVE_STRING },
+  ...obj.WeightPerAxle && { WeightPerAxle: import_smithy_client.SENSITIVE_STRING },
+  ...obj.WeightPerAxleGroup && { WeightPerAxleGroup: WeightPerAxleGroupFilterSensitiveLog(obj.WeightPerAxleGroup) },
+  ...obj.Width && { Width: import_smithy_client.SENSITIVE_STRING }
+}), "RouteMatrixTruckOptionsFilterSensitiveLog");
+var RouteMatrixTravelModeOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Car && { Car: RouteMatrixCarOptionsFilterSensitiveLog(obj.Car) },
+  ...obj.Scooter && { Scooter: RouteMatrixScooterOptionsFilterSensitiveLog(obj.Scooter) },
+  ...obj.Truck && { Truck: RouteMatrixTruckOptionsFilterSensitiveLog(obj.Truck) }
+}), "RouteMatrixTravelModeOptionsFilterSensitiveLog");
+var CalculateRouteMatrixRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Allow && { Allow: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Avoid && { Avoid: RouteMatrixAvoidanceOptionsFilterSensitiveLog(obj.Avoid) },
+  ...obj.DepartNow && { DepartNow: import_smithy_client.SENSITIVE_STRING },
+  ...obj.DepartureTime && { DepartureTime: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Destinations && {
+    Destinations: obj.Destinations.map((item) => RouteMatrixDestinationFilterSensitiveLog(item))
+  },
+  ...obj.Exclude && { Exclude: RouteMatrixExclusionOptionsFilterSensitiveLog(obj.Exclude) },
+  ...obj.Key && { Key: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Origins && { Origins: obj.Origins.map((item) => RouteMatrixOriginFilterSensitiveLog(item)) },
+  ...obj.RoutingBoundary && { RoutingBoundary: RouteMatrixBoundaryFilterSensitiveLog(obj.RoutingBoundary) },
+  ...obj.Traffic && { Traffic: RouteMatrixTrafficOptionsFilterSensitiveLog(obj.Traffic) },
+  ...obj.TravelModeOptions && {
+    TravelModeOptions: RouteMatrixTravelModeOptionsFilterSensitiveLog(obj.TravelModeOptions)
+  }
+}), "CalculateRouteMatrixRequestFilterSensitiveLog");
+var RouteMatrixEntryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Distance && { Distance: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Duration && { Duration: import_smithy_client.SENSITIVE_STRING }
+}), "RouteMatrixEntryFilterSensitiveLog");
+var CalculateRouteMatrixResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.RouteMatrix && {
+    RouteMatrix: obj.RouteMatrix.map((item) => item.map((item2) => RouteMatrixEntryFilterSensitiveLog(item2)))
+  },
+  ...obj.RoutingBoundary && { RoutingBoundary: RouteMatrixBoundaryFilterSensitiveLog(obj.RoutingBoundary) }
+}), "CalculateRouteMatrixResponseFilterSensitiveLog");
+var RouteAllowOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Hot && { Hot: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Hov && { Hov: import_smithy_client.SENSITIVE_STRING }
+}), "RouteAllowOptionsFilterSensitiveLog");
+var RouteAvoidanceAreaGeometryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Corridor && { Corridor: import_smithy_client.SENSITIVE_STRING },
+  ...obj.BoundingBox && { BoundingBox: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Polygon && { Polygon: obj.Polygon.map((item) => import_smithy_client.SENSITIVE_STRING) },
+  ...obj.PolylineCorridor && { PolylineCorridor: import_smithy_client.SENSITIVE_STRING },
+  ...obj.PolylinePolygon && { PolylinePolygon: import_smithy_client.SENSITIVE_STRING }
+}), "RouteAvoidanceAreaGeometryFilterSensitiveLog");
+var RouteAvoidanceAreaFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Except && { Except: obj.Except.map((item) => RouteAvoidanceAreaGeometryFilterSensitiveLog(item)) },
+  ...obj.Geometry && { Geometry: RouteAvoidanceAreaGeometryFilterSensitiveLog(obj.Geometry) }
+}), "RouteAvoidanceAreaFilterSensitiveLog");
+var RouteAvoidanceZoneCategoryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Category && { Category: import_smithy_client.SENSITIVE_STRING }
+}), "RouteAvoidanceZoneCategoryFilterSensitiveLog");
+var RouteAvoidanceOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Areas && { Areas: obj.Areas.map((item) => RouteAvoidanceAreaFilterSensitiveLog(item)) },
+  ...obj.CarShuttleTrains && { CarShuttleTrains: import_smithy_client.SENSITIVE_STRING },
+  ...obj.ControlledAccessHighways && { ControlledAccessHighways: import_smithy_client.SENSITIVE_STRING },
+  ...obj.DirtRoads && { DirtRoads: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Ferries && { Ferries: import_smithy_client.SENSITIVE_STRING },
+  ...obj.SeasonalClosure && { SeasonalClosure: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TollRoads && { TollRoads: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TollTransponders && { TollTransponders: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TruckRoadTypes && { TruckRoadTypes: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Tunnels && { Tunnels: import_smithy_client.SENSITIVE_STRING },
+  ...obj.UTurns && { UTurns: import_smithy_client.SENSITIVE_STRING },
+  ...obj.ZoneCategories && {
+    ZoneCategories: obj.ZoneCategories.map((item) => RouteAvoidanceZoneCategoryFilterSensitiveLog(item))
+  }
+}), "RouteAvoidanceOptionsFilterSensitiveLog");
+var RouteMatchingOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.NameHint && { NameHint: import_smithy_client.SENSITIVE_STRING },
+  ...obj.OnRoadThreshold && { OnRoadThreshold: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Radius && { Radius: import_smithy_client.SENSITIVE_STRING }
+}), "RouteMatchingOptionsFilterSensitiveLog");
+var RouteSideOfStreetOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Position && { Position: import_smithy_client.SENSITIVE_STRING }
+}), "RouteSideOfStreetOptionsFilterSensitiveLog");
+var RouteDestinationOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.AvoidActionsForDistance && { AvoidActionsForDistance: import_smithy_client.SENSITIVE_STRING },
+  ...obj.AvoidUTurns && { AvoidUTurns: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Heading && { Heading: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Matching && { Matching: RouteMatchingOptionsFilterSensitiveLog(obj.Matching) },
+  ...obj.SideOfStreet && { SideOfStreet: RouteSideOfStreetOptionsFilterSensitiveLog(obj.SideOfStreet) },
+  ...obj.StopDuration && { StopDuration: import_smithy_client.SENSITIVE_STRING }
+}), "RouteDestinationOptionsFilterSensitiveLog");
+var RouteDriverScheduleIntervalFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.DriveDuration && { DriveDuration: import_smithy_client.SENSITIVE_STRING },
+  ...obj.RestDuration && { RestDuration: import_smithy_client.SENSITIVE_STRING }
+}), "RouteDriverScheduleIntervalFilterSensitiveLog");
+var RouteDriverOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Schedule && { Schedule: obj.Schedule.map((item) => RouteDriverScheduleIntervalFilterSensitiveLog(item)) }
+}), "RouteDriverOptionsFilterSensitiveLog");
+var RouteExclusionOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Countries && { Countries: import_smithy_client.SENSITIVE_STRING }
+}), "RouteExclusionOptionsFilterSensitiveLog");
+var RouteOriginOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.AvoidActionsForDistance && { AvoidActionsForDistance: import_smithy_client.SENSITIVE_STRING },
+  ...obj.AvoidUTurns && { AvoidUTurns: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Heading && { Heading: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Matching && { Matching: RouteMatchingOptionsFilterSensitiveLog(obj.Matching) },
+  ...obj.SideOfStreet && { SideOfStreet: RouteSideOfStreetOptionsFilterSensitiveLog(obj.SideOfStreet) }
+}), "RouteOriginOptionsFilterSensitiveLog");
+var RouteEmissionTypeFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Co2EmissionClass && { Co2EmissionClass: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Type && { Type: import_smithy_client.SENSITIVE_STRING }
+}), "RouteEmissionTypeFilterSensitiveLog");
+var RouteTollOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.AllTransponders && { AllTransponders: import_smithy_client.SENSITIVE_STRING },
+  ...obj.AllVignettes && { AllVignettes: import_smithy_client.SENSITIVE_STRING },
+  ...obj.EmissionType && { EmissionType: RouteEmissionTypeFilterSensitiveLog(obj.EmissionType) },
+  ...obj.VehicleCategory && { VehicleCategory: import_smithy_client.SENSITIVE_STRING }
+}), "RouteTollOptionsFilterSensitiveLog");
+var RouteTrafficOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.FlowEventThresholdOverride && { FlowEventThresholdOverride: import_smithy_client.SENSITIVE_STRING }
+}), "RouteTrafficOptionsFilterSensitiveLog");
+var RouteVehicleLicensePlateFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.LastCharacter && { LastCharacter: import_smithy_client.SENSITIVE_STRING }
+}), "RouteVehicleLicensePlateFilterSensitiveLog");
+var RouteCarOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.EngineType && { EngineType: import_smithy_client.SENSITIVE_STRING },
+  ...obj.LicensePlate && { LicensePlate: RouteVehicleLicensePlateFilterSensitiveLog(obj.LicensePlate) },
+  ...obj.MaxSpeed && { MaxSpeed: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Occupancy && { Occupancy: import_smithy_client.SENSITIVE_STRING }
+}), "RouteCarOptionsFilterSensitiveLog");
+var RoutePedestrianOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Speed && { Speed: import_smithy_client.SENSITIVE_STRING }
+}), "RoutePedestrianOptionsFilterSensitiveLog");
+var RouteScooterOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.EngineType && { EngineType: import_smithy_client.SENSITIVE_STRING },
+  ...obj.LicensePlate && { LicensePlate: RouteVehicleLicensePlateFilterSensitiveLog(obj.LicensePlate) },
+  ...obj.MaxSpeed && { MaxSpeed: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Occupancy && { Occupancy: import_smithy_client.SENSITIVE_STRING }
+}), "RouteScooterOptionsFilterSensitiveLog");
+var RouteTrailerOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.AxleCount && { AxleCount: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TrailerCount && { TrailerCount: import_smithy_client.SENSITIVE_STRING }
+}), "RouteTrailerOptionsFilterSensitiveLog");
+var RouteTruckOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.AxleCount && { AxleCount: import_smithy_client.SENSITIVE_STRING },
+  ...obj.EngineType && { EngineType: import_smithy_client.SENSITIVE_STRING },
+  ...obj.GrossWeight && { GrossWeight: import_smithy_client.SENSITIVE_STRING },
+  ...obj.HazardousCargos && { HazardousCargos: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Height && { Height: import_smithy_client.SENSITIVE_STRING },
+  ...obj.HeightAboveFirstAxle && { HeightAboveFirstAxle: import_smithy_client.SENSITIVE_STRING },
+  ...obj.KpraLength && { KpraLength: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Length && { Length: import_smithy_client.SENSITIVE_STRING },
+  ...obj.LicensePlate && { LicensePlate: RouteVehicleLicensePlateFilterSensitiveLog(obj.LicensePlate) },
+  ...obj.MaxSpeed && { MaxSpeed: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Occupancy && { Occupancy: import_smithy_client.SENSITIVE_STRING },
+  ...obj.PayloadCapacity && { PayloadCapacity: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TireCount && { TireCount: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Trailer && { Trailer: RouteTrailerOptionsFilterSensitiveLog(obj.Trailer) },
+  ...obj.TruckType && { TruckType: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TunnelRestrictionCode && { TunnelRestrictionCode: import_smithy_client.SENSITIVE_STRING },
+  ...obj.WeightPerAxle && { WeightPerAxle: import_smithy_client.SENSITIVE_STRING },
+  ...obj.WeightPerAxleGroup && { WeightPerAxleGroup: WeightPerAxleGroupFilterSensitiveLog(obj.WeightPerAxleGroup) },
+  ...obj.Width && { Width: import_smithy_client.SENSITIVE_STRING }
+}), "RouteTruckOptionsFilterSensitiveLog");
+var RouteTravelModeOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Car && { Car: RouteCarOptionsFilterSensitiveLog(obj.Car) },
+  ...obj.Pedestrian && { Pedestrian: RoutePedestrianOptionsFilterSensitiveLog(obj.Pedestrian) },
+  ...obj.Scooter && { Scooter: RouteScooterOptionsFilterSensitiveLog(obj.Scooter) },
+  ...obj.Truck && { Truck: RouteTruckOptionsFilterSensitiveLog(obj.Truck) }
+}), "RouteTravelModeOptionsFilterSensitiveLog");
+var RouteWaypointFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.AvoidActionsForDistance && { AvoidActionsForDistance: import_smithy_client.SENSITIVE_STRING },
+  ...obj.AvoidUTurns && { AvoidUTurns: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Heading && { Heading: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Matching && { Matching: RouteMatchingOptionsFilterSensitiveLog(obj.Matching) },
+  ...obj.PassThrough && { PassThrough: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Position && { Position: import_smithy_client.SENSITIVE_STRING },
+  ...obj.SideOfStreet && { SideOfStreet: RouteSideOfStreetOptionsFilterSensitiveLog(obj.SideOfStreet) },
+  ...obj.StopDuration && { StopDuration: import_smithy_client.SENSITIVE_STRING }
+}), "RouteWaypointFilterSensitiveLog");
+var CalculateRoutesRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Allow && { Allow: RouteAllowOptionsFilterSensitiveLog(obj.Allow) },
+  ...obj.ArrivalTime && { ArrivalTime: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Avoid && { Avoid: RouteAvoidanceOptionsFilterSensitiveLog(obj.Avoid) },
+  ...obj.DepartNow && { DepartNow: import_smithy_client.SENSITIVE_STRING },
+  ...obj.DepartureTime && { DepartureTime: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Destination && { Destination: import_smithy_client.SENSITIVE_STRING },
+  ...obj.DestinationOptions && {
+    DestinationOptions: RouteDestinationOptionsFilterSensitiveLog(obj.DestinationOptions)
+  },
+  ...obj.Driver && { Driver: RouteDriverOptionsFilterSensitiveLog(obj.Driver) },
+  ...obj.Exclude && { Exclude: RouteExclusionOptionsFilterSensitiveLog(obj.Exclude) },
+  ...obj.Key && { Key: import_smithy_client.SENSITIVE_STRING },
+  ...obj.LegAdditionalFeatures && { LegAdditionalFeatures: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Origin && { Origin: import_smithy_client.SENSITIVE_STRING },
+  ...obj.OriginOptions && { OriginOptions: RouteOriginOptionsFilterSensitiveLog(obj.OriginOptions) },
+  ...obj.Tolls && { Tolls: RouteTollOptionsFilterSensitiveLog(obj.Tolls) },
+  ...obj.Traffic && { Traffic: RouteTrafficOptionsFilterSensitiveLog(obj.Traffic) },
+  ...obj.TravelModeOptions && { TravelModeOptions: RouteTravelModeOptionsFilterSensitiveLog(obj.TravelModeOptions) },
+  ...obj.Waypoints && { Waypoints: obj.Waypoints.map((item) => RouteWaypointFilterSensitiveLog(item)) }
+}), "CalculateRoutesRequestFilterSensitiveLog");
+var RouteFerryAfterTravelStepFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Duration && { Duration: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Instruction && { Instruction: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Type && { Type: import_smithy_client.SENSITIVE_STRING }
+}), "RouteFerryAfterTravelStepFilterSensitiveLog");
+var RouteFerryPlaceFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Name && { Name: import_smithy_client.SENSITIVE_STRING },
+  ...obj.OriginalPosition && { OriginalPosition: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Position && { Position: import_smithy_client.SENSITIVE_STRING },
+  ...obj.WaypointIndex && { WaypointIndex: import_smithy_client.SENSITIVE_STRING }
+}), "RouteFerryPlaceFilterSensitiveLog");
+var RouteFerryArrivalFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Place && { Place: RouteFerryPlaceFilterSensitiveLog(obj.Place) },
+  ...obj.Time && { Time: import_smithy_client.SENSITIVE_STRING }
+}), "RouteFerryArrivalFilterSensitiveLog");
+var RouteFerryBeforeTravelStepFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Duration && { Duration: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Instruction && { Instruction: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Type && { Type: import_smithy_client.SENSITIVE_STRING }
+}), "RouteFerryBeforeTravelStepFilterSensitiveLog");
+var RouteFerryDepartureFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Place && { Place: RouteFerryPlaceFilterSensitiveLog(obj.Place) },
+  ...obj.Time && { Time: import_smithy_client.SENSITIVE_STRING }
+}), "RouteFerryDepartureFilterSensitiveLog");
+var RoutePassThroughPlaceFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.OriginalPosition && { OriginalPosition: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Position && { Position: import_smithy_client.SENSITIVE_STRING },
+  ...obj.WaypointIndex && { WaypointIndex: import_smithy_client.SENSITIVE_STRING }
+}), "RoutePassThroughPlaceFilterSensitiveLog");
+var RoutePassThroughWaypointFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Place && { Place: RoutePassThroughPlaceFilterSensitiveLog(obj.Place) }
+}), "RoutePassThroughWaypointFilterSensitiveLog");
+var LocalizedStringFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Value && { Value: import_smithy_client.SENSITIVE_STRING }
+}), "LocalizedStringFilterSensitiveLog");
+var RouteFerrySpanFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Country && { Country: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Distance && { Distance: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Duration && { Duration: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Names && { Names: obj.Names.map((item) => LocalizedStringFilterSensitiveLog(item)) },
+  ...obj.Region && { Region: import_smithy_client.SENSITIVE_STRING }
+}), "RouteFerrySpanFilterSensitiveLog");
+var RouteFerryOverviewSummaryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Distance && { Distance: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Duration && { Duration: import_smithy_client.SENSITIVE_STRING }
+}), "RouteFerryOverviewSummaryFilterSensitiveLog");
+var RouteFerryTravelOnlySummaryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Duration && { Duration: import_smithy_client.SENSITIVE_STRING }
+}), "RouteFerryTravelOnlySummaryFilterSensitiveLog");
+var RouteFerrySummaryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Overview && { Overview: RouteFerryOverviewSummaryFilterSensitiveLog(obj.Overview) },
+  ...obj.TravelOnly && { TravelOnly: RouteFerryTravelOnlySummaryFilterSensitiveLog(obj.TravelOnly) }
+}), "RouteFerrySummaryFilterSensitiveLog");
+var RouteFerryTravelStepFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Distance && { Distance: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Duration && { Duration: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Instruction && { Instruction: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Type && { Type: import_smithy_client.SENSITIVE_STRING }
+}), "RouteFerryTravelStepFilterSensitiveLog");
+var RouteFerryLegDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.AfterTravelSteps && {
+    AfterTravelSteps: obj.AfterTravelSteps.map((item) => RouteFerryAfterTravelStepFilterSensitiveLog(item))
+  },
+  ...obj.Arrival && { Arrival: RouteFerryArrivalFilterSensitiveLog(obj.Arrival) },
+  ...obj.BeforeTravelSteps && {
+    BeforeTravelSteps: obj.BeforeTravelSteps.map((item) => RouteFerryBeforeTravelStepFilterSensitiveLog(item))
+  },
+  ...obj.Departure && { Departure: RouteFerryDepartureFilterSensitiveLog(obj.Departure) },
+  ...obj.PassThroughWaypoints && {
+    PassThroughWaypoints: obj.PassThroughWaypoints.map((item) => RoutePassThroughWaypointFilterSensitiveLog(item))
+  },
+  ...obj.RouteName && { RouteName: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Spans && { Spans: obj.Spans.map((item) => RouteFerrySpanFilterSensitiveLog(item)) },
+  ...obj.Summary && { Summary: RouteFerrySummaryFilterSensitiveLog(obj.Summary) },
+  ...obj.TravelSteps && { TravelSteps: obj.TravelSteps.map((item) => RouteFerryTravelStepFilterSensitiveLog(item)) }
+}), "RouteFerryLegDetailsFilterSensitiveLog");
+var RouteLegGeometryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.LineString && { LineString: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Polyline && { Polyline: import_smithy_client.SENSITIVE_STRING }
+}), "RouteLegGeometryFilterSensitiveLog");
+var RoutePedestrianPlaceFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Name && { Name: import_smithy_client.SENSITIVE_STRING },
+  ...obj.OriginalPosition && { OriginalPosition: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Position && { Position: import_smithy_client.SENSITIVE_STRING },
+  ...obj.SideOfStreet && { SideOfStreet: import_smithy_client.SENSITIVE_STRING },
+  ...obj.WaypointIndex && { WaypointIndex: import_smithy_client.SENSITIVE_STRING }
+}), "RoutePedestrianPlaceFilterSensitiveLog");
+var RoutePedestrianArrivalFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Place && { Place: RoutePedestrianPlaceFilterSensitiveLog(obj.Place) },
+  ...obj.Time && { Time: import_smithy_client.SENSITIVE_STRING }
+}), "RoutePedestrianArrivalFilterSensitiveLog");
+var RoutePedestrianDepartureFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Place && { Place: RoutePedestrianPlaceFilterSensitiveLog(obj.Place) },
+  ...obj.Time && { Time: import_smithy_client.SENSITIVE_STRING }
+}), "RoutePedestrianDepartureFilterSensitiveLog");
+var RouteSpanDynamicSpeedDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.BestCaseSpeed && { BestCaseSpeed: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TurnDuration && { TurnDuration: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TypicalSpeed && { TypicalSpeed: import_smithy_client.SENSITIVE_STRING }
+}), "RouteSpanDynamicSpeedDetailsFilterSensitiveLog");
+var RouteNumberFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Direction && { Direction: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Value && { Value: import_smithy_client.SENSITIVE_STRING }
+}), "RouteNumberFilterSensitiveLog");
+var RouteSpanSpeedLimitDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.MaxSpeed && { MaxSpeed: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Unlimited && { Unlimited: import_smithy_client.SENSITIVE_STRING }
+}), "RouteSpanSpeedLimitDetailsFilterSensitiveLog");
+var RoutePedestrianSpanFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.BestCaseDuration && { BestCaseDuration: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Country && { Country: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Distance && { Distance: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Duration && { Duration: import_smithy_client.SENSITIVE_STRING },
+  ...obj.DynamicSpeed && { DynamicSpeed: RouteSpanDynamicSpeedDetailsFilterSensitiveLog(obj.DynamicSpeed) },
+  ...obj.FunctionalClassification && { FunctionalClassification: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Names && { Names: obj.Names.map((item) => LocalizedStringFilterSensitiveLog(item)) },
+  ...obj.PedestrianAccess && { PedestrianAccess: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Region && { Region: import_smithy_client.SENSITIVE_STRING },
+  ...obj.RoadAttributes && { RoadAttributes: import_smithy_client.SENSITIVE_STRING },
+  ...obj.RouteNumbers && { RouteNumbers: obj.RouteNumbers.map((item) => RouteNumberFilterSensitiveLog(item)) },
+  ...obj.SpeedLimit && { SpeedLimit: RouteSpanSpeedLimitDetailsFilterSensitiveLog(obj.SpeedLimit) },
+  ...obj.TypicalDuration && { TypicalDuration: import_smithy_client.SENSITIVE_STRING }
+}), "RoutePedestrianSpanFilterSensitiveLog");
+var RoutePedestrianOverviewSummaryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Distance && { Distance: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Duration && { Duration: import_smithy_client.SENSITIVE_STRING }
+}), "RoutePedestrianOverviewSummaryFilterSensitiveLog");
+var RoutePedestrianTravelOnlySummaryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Duration && { Duration: import_smithy_client.SENSITIVE_STRING }
+}), "RoutePedestrianTravelOnlySummaryFilterSensitiveLog");
+var RoutePedestrianSummaryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Overview && { Overview: RoutePedestrianOverviewSummaryFilterSensitiveLog(obj.Overview) },
+  ...obj.TravelOnly && { TravelOnly: RoutePedestrianTravelOnlySummaryFilterSensitiveLog(obj.TravelOnly) }
+}), "RoutePedestrianSummaryFilterSensitiveLog");
+var RouteContinueStepDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Intersection && { Intersection: obj.Intersection.map((item) => LocalizedStringFilterSensitiveLog(item)) }
+}), "RouteContinueStepDetailsFilterSensitiveLog");
+var RouteRoadFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.RoadName && { RoadName: obj.RoadName.map((item) => LocalizedStringFilterSensitiveLog(item)) },
+  ...obj.RouteNumber && { RouteNumber: obj.RouteNumber.map((item) => RouteNumberFilterSensitiveLog(item)) },
+  ...obj.Towards && { Towards: obj.Towards.map((item) => LocalizedStringFilterSensitiveLog(item)) },
+  ...obj.Type && { Type: import_smithy_client.SENSITIVE_STRING }
+}), "RouteRoadFilterSensitiveLog");
+var RouteKeepStepDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Intersection && { Intersection: obj.Intersection.map((item) => LocalizedStringFilterSensitiveLog(item)) },
+  ...obj.SteeringDirection && { SteeringDirection: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TurnIntensity && { TurnIntensity: import_smithy_client.SENSITIVE_STRING }
+}), "RouteKeepStepDetailsFilterSensitiveLog");
+var RouteRoundaboutEnterStepDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Intersection && { Intersection: obj.Intersection.map((item) => LocalizedStringFilterSensitiveLog(item)) },
+  ...obj.SteeringDirection && { SteeringDirection: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TurnIntensity && { TurnIntensity: import_smithy_client.SENSITIVE_STRING }
+}), "RouteRoundaboutEnterStepDetailsFilterSensitiveLog");
+var RouteRoundaboutExitStepDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Intersection && { Intersection: obj.Intersection.map((item) => LocalizedStringFilterSensitiveLog(item)) },
+  ...obj.RelativeExit && { RelativeExit: import_smithy_client.SENSITIVE_STRING },
+  ...obj.SteeringDirection && { SteeringDirection: import_smithy_client.SENSITIVE_STRING }
+}), "RouteRoundaboutExitStepDetailsFilterSensitiveLog");
+var RouteRoundaboutPassStepDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Intersection && { Intersection: obj.Intersection.map((item) => LocalizedStringFilterSensitiveLog(item)) },
+  ...obj.SteeringDirection && { SteeringDirection: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TurnIntensity && { TurnIntensity: import_smithy_client.SENSITIVE_STRING }
+}), "RouteRoundaboutPassStepDetailsFilterSensitiveLog");
+var RouteSignpostLabelFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.RouteNumber && { RouteNumber: RouteNumberFilterSensitiveLog(obj.RouteNumber) },
+  ...obj.Text && { Text: LocalizedStringFilterSensitiveLog(obj.Text) }
+}), "RouteSignpostLabelFilterSensitiveLog");
+var RouteSignpostFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Labels && { Labels: obj.Labels.map((item) => RouteSignpostLabelFilterSensitiveLog(item)) }
+}), "RouteSignpostFilterSensitiveLog");
+var RouteTurnStepDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Intersection && { Intersection: obj.Intersection.map((item) => LocalizedStringFilterSensitiveLog(item)) },
+  ...obj.SteeringDirection && { SteeringDirection: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TurnIntensity && { TurnIntensity: import_smithy_client.SENSITIVE_STRING }
+}), "RouteTurnStepDetailsFilterSensitiveLog");
+var RoutePedestrianTravelStepFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.ContinueStepDetails && {
+    ContinueStepDetails: RouteContinueStepDetailsFilterSensitiveLog(obj.ContinueStepDetails)
+  },
+  ...obj.CurrentRoad && { CurrentRoad: RouteRoadFilterSensitiveLog(obj.CurrentRoad) },
+  ...obj.Distance && { Distance: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Duration && { Duration: import_smithy_client.SENSITIVE_STRING },
+  ...obj.ExitNumber && { ExitNumber: obj.ExitNumber.map((item) => LocalizedStringFilterSensitiveLog(item)) },
+  ...obj.Instruction && { Instruction: import_smithy_client.SENSITIVE_STRING },
+  ...obj.KeepStepDetails && { KeepStepDetails: RouteKeepStepDetailsFilterSensitiveLog(obj.KeepStepDetails) },
+  ...obj.NextRoad && { NextRoad: RouteRoadFilterSensitiveLog(obj.NextRoad) },
+  ...obj.RoundaboutEnterStepDetails && {
+    RoundaboutEnterStepDetails: RouteRoundaboutEnterStepDetailsFilterSensitiveLog(obj.RoundaboutEnterStepDetails)
+  },
+  ...obj.RoundaboutExitStepDetails && {
+    RoundaboutExitStepDetails: RouteRoundaboutExitStepDetailsFilterSensitiveLog(obj.RoundaboutExitStepDetails)
+  },
+  ...obj.RoundaboutPassStepDetails && {
+    RoundaboutPassStepDetails: RouteRoundaboutPassStepDetailsFilterSensitiveLog(obj.RoundaboutPassStepDetails)
+  },
+  ...obj.Signpost && { Signpost: RouteSignpostFilterSensitiveLog(obj.Signpost) },
+  ...obj.TurnStepDetails && { TurnStepDetails: RouteTurnStepDetailsFilterSensitiveLog(obj.TurnStepDetails) },
+  ...obj.Type && { Type: import_smithy_client.SENSITIVE_STRING }
+}), "RoutePedestrianTravelStepFilterSensitiveLog");
+var RoutePedestrianLegDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Arrival && { Arrival: RoutePedestrianArrivalFilterSensitiveLog(obj.Arrival) },
+  ...obj.Departure && { Departure: RoutePedestrianDepartureFilterSensitiveLog(obj.Departure) },
+  ...obj.PassThroughWaypoints && {
+    PassThroughWaypoints: obj.PassThroughWaypoints.map((item) => RoutePassThroughWaypointFilterSensitiveLog(item))
+  },
+  ...obj.Spans && { Spans: obj.Spans.map((item) => RoutePedestrianSpanFilterSensitiveLog(item)) },
+  ...obj.Summary && { Summary: RoutePedestrianSummaryFilterSensitiveLog(obj.Summary) },
+  ...obj.TravelSteps && {
+    TravelSteps: obj.TravelSteps.map((item) => RoutePedestrianTravelStepFilterSensitiveLog(item))
+  }
+}), "RoutePedestrianLegDetailsFilterSensitiveLog");
+var RouteVehiclePlaceFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Name && { Name: import_smithy_client.SENSITIVE_STRING },
+  ...obj.OriginalPosition && { OriginalPosition: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Position && { Position: import_smithy_client.SENSITIVE_STRING },
+  ...obj.SideOfStreet && { SideOfStreet: import_smithy_client.SENSITIVE_STRING },
+  ...obj.WaypointIndex && { WaypointIndex: import_smithy_client.SENSITIVE_STRING }
+}), "RouteVehiclePlaceFilterSensitiveLog");
+var RouteVehicleArrivalFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Place && { Place: RouteVehiclePlaceFilterSensitiveLog(obj.Place) },
+  ...obj.Time && { Time: import_smithy_client.SENSITIVE_STRING }
+}), "RouteVehicleArrivalFilterSensitiveLog");
+var RouteVehicleDepartureFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Place && { Place: RouteVehiclePlaceFilterSensitiveLog(obj.Place) },
+  ...obj.Time && { Time: import_smithy_client.SENSITIVE_STRING }
+}), "RouteVehicleDepartureFilterSensitiveLog");
+var RouteVehicleIncidentFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Description && { Description: import_smithy_client.SENSITIVE_STRING },
+  ...obj.EndTime && { EndTime: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Severity && { Severity: import_smithy_client.SENSITIVE_STRING },
+  ...obj.StartTime && { StartTime: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Type && { Type: import_smithy_client.SENSITIVE_STRING }
+}), "RouteVehicleIncidentFilterSensitiveLog");
+var RouteWeightConstraintFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Value && { Value: import_smithy_client.SENSITIVE_STRING }
+}), "RouteWeightConstraintFilterSensitiveLog");
+var RouteViolatedConstraintsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.AllHazardsRestricted && { AllHazardsRestricted: import_smithy_client.SENSITIVE_STRING },
+  ...obj.HazardousCargos && { HazardousCargos: import_smithy_client.SENSITIVE_STRING },
+  ...obj.MaxHeight && { MaxHeight: import_smithy_client.SENSITIVE_STRING },
+  ...obj.MaxKpraLength && { MaxKpraLength: import_smithy_client.SENSITIVE_STRING },
+  ...obj.MaxLength && { MaxLength: import_smithy_client.SENSITIVE_STRING },
+  ...obj.MaxPayloadCapacity && { MaxPayloadCapacity: import_smithy_client.SENSITIVE_STRING },
+  ...obj.MaxWeight && { MaxWeight: RouteWeightConstraintFilterSensitiveLog(obj.MaxWeight) },
+  ...obj.MaxWeightPerAxle && { MaxWeightPerAxle: import_smithy_client.SENSITIVE_STRING },
+  ...obj.MaxWeightPerAxleGroup && {
+    MaxWeightPerAxleGroup: WeightPerAxleGroupFilterSensitiveLog(obj.MaxWeightPerAxleGroup)
+  },
+  ...obj.MaxWidth && { MaxWidth: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TimeDependent && { TimeDependent: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TravelMode && { TravelMode: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TruckType && { TruckType: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TunnelRestrictionCode && { TunnelRestrictionCode: import_smithy_client.SENSITIVE_STRING }
+}), "RouteViolatedConstraintsFilterSensitiveLog");
+var RouteVehicleNoticeDetailFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Title && { Title: import_smithy_client.SENSITIVE_STRING },
+  ...obj.ViolatedConstraints && {
+    ViolatedConstraints: RouteViolatedConstraintsFilterSensitiveLog(obj.ViolatedConstraints)
+  }
+}), "RouteVehicleNoticeDetailFilterSensitiveLog");
+var RouteVehicleNoticeFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Details && { Details: obj.Details.map((item) => RouteVehicleNoticeDetailFilterSensitiveLog(item)) }
+}), "RouteVehicleNoticeFilterSensitiveLog");
+var RouteVehicleSpanFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.BestCaseDuration && { BestCaseDuration: import_smithy_client.SENSITIVE_STRING },
+  ...obj.CarAccess && { CarAccess: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Country && { Country: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Distance && { Distance: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Duration && { Duration: import_smithy_client.SENSITIVE_STRING },
+  ...obj.DynamicSpeed && { DynamicSpeed: RouteSpanDynamicSpeedDetailsFilterSensitiveLog(obj.DynamicSpeed) },
+  ...obj.FunctionalClassification && { FunctionalClassification: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Gate && { Gate: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Names && { Names: obj.Names.map((item) => LocalizedStringFilterSensitiveLog(item)) },
+  ...obj.RailwayCrossing && { RailwayCrossing: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Region && { Region: import_smithy_client.SENSITIVE_STRING },
+  ...obj.RoadAttributes && { RoadAttributes: import_smithy_client.SENSITIVE_STRING },
+  ...obj.RouteNumbers && { RouteNumbers: obj.RouteNumbers.map((item) => RouteNumberFilterSensitiveLog(item)) },
+  ...obj.ScooterAccess && { ScooterAccess: import_smithy_client.SENSITIVE_STRING },
+  ...obj.SpeedLimit && { SpeedLimit: RouteSpanSpeedLimitDetailsFilterSensitiveLog(obj.SpeedLimit) },
+  ...obj.TruckAccess && { TruckAccess: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TypicalDuration && { TypicalDuration: import_smithy_client.SENSITIVE_STRING }
+}), "RouteVehicleSpanFilterSensitiveLog");
+var RouteVehicleOverviewSummaryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.BestCaseDuration && { BestCaseDuration: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Distance && { Distance: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Duration && { Duration: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TypicalDuration && { TypicalDuration: import_smithy_client.SENSITIVE_STRING }
+}), "RouteVehicleOverviewSummaryFilterSensitiveLog");
+var RouteVehicleTravelOnlySummaryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.BestCaseDuration && { BestCaseDuration: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Duration && { Duration: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TypicalDuration && { TypicalDuration: import_smithy_client.SENSITIVE_STRING }
+}), "RouteVehicleTravelOnlySummaryFilterSensitiveLog");
+var RouteVehicleSummaryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Overview && { Overview: RouteVehicleOverviewSummaryFilterSensitiveLog(obj.Overview) },
+  ...obj.TravelOnly && { TravelOnly: RouteVehicleTravelOnlySummaryFilterSensitiveLog(obj.TravelOnly) }
+}), "RouteVehicleSummaryFilterSensitiveLog");
+var RouteTollPaymentSiteFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Position && { Position: import_smithy_client.SENSITIVE_STRING }
+}), "RouteTollPaymentSiteFilterSensitiveLog");
+var RouteTollPriceValueRangeFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Min && { Min: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Max && { Max: import_smithy_client.SENSITIVE_STRING }
+}), "RouteTollPriceValueRangeFilterSensitiveLog");
+var RouteTollPriceFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Estimate && { Estimate: import_smithy_client.SENSITIVE_STRING },
+  ...obj.PerDuration && { PerDuration: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Range && { Range: import_smithy_client.SENSITIVE_STRING },
+  ...obj.RangeValue && { RangeValue: RouteTollPriceValueRangeFilterSensitiveLog(obj.RangeValue) },
+  ...obj.Value && { Value: import_smithy_client.SENSITIVE_STRING }
+}), "RouteTollPriceFilterSensitiveLog");
+var RouteTollPassValidityPeriodFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Period && { Period: import_smithy_client.SENSITIVE_STRING },
+  ...obj.PeriodCount && { PeriodCount: import_smithy_client.SENSITIVE_STRING }
+}), "RouteTollPassValidityPeriodFilterSensitiveLog");
+var RouteTollPassFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.IncludesReturnTrip && { IncludesReturnTrip: import_smithy_client.SENSITIVE_STRING },
+  ...obj.SeniorPass && { SeniorPass: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TransferCount && { TransferCount: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TripCount && { TripCount: import_smithy_client.SENSITIVE_STRING },
+  ...obj.ValidityPeriod && { ValidityPeriod: RouteTollPassValidityPeriodFilterSensitiveLog(obj.ValidityPeriod) }
+}), "RouteTollPassFilterSensitiveLog");
+var RouteTransponderFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.SystemName && { SystemName: import_smithy_client.SENSITIVE_STRING }
+}), "RouteTransponderFilterSensitiveLog");
+var RouteTollRateFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.ApplicableTimes && { ApplicableTimes: import_smithy_client.SENSITIVE_STRING },
+  ...obj.ConvertedPrice && { ConvertedPrice: RouteTollPriceFilterSensitiveLog(obj.ConvertedPrice) },
+  ...obj.Id && { Id: import_smithy_client.SENSITIVE_STRING },
+  ...obj.LocalPrice && { LocalPrice: RouteTollPriceFilterSensitiveLog(obj.LocalPrice) },
+  ...obj.Name && { Name: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Pass && { Pass: RouteTollPassFilterSensitiveLog(obj.Pass) },
+  ...obj.PaymentMethods && { PaymentMethods: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Transponders && { Transponders: obj.Transponders.map((item) => RouteTransponderFilterSensitiveLog(item)) }
+}), "RouteTollRateFilterSensitiveLog");
+var RouteTollFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Country && { Country: import_smithy_client.SENSITIVE_STRING },
+  ...obj.PaymentSites && {
+    PaymentSites: obj.PaymentSites.map((item) => RouteTollPaymentSiteFilterSensitiveLog(item))
+  },
+  ...obj.Rates && { Rates: obj.Rates.map((item) => RouteTollRateFilterSensitiveLog(item)) }
+}), "RouteTollFilterSensitiveLog");
+var RouteTollSystemFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Name && { Name: import_smithy_client.SENSITIVE_STRING }
+}), "RouteTollSystemFilterSensitiveLog");
+var RouteContinueHighwayStepDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Intersection && { Intersection: obj.Intersection.map((item) => LocalizedStringFilterSensitiveLog(item)) },
+  ...obj.SteeringDirection && { SteeringDirection: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TurnIntensity && { TurnIntensity: import_smithy_client.SENSITIVE_STRING }
+}), "RouteContinueHighwayStepDetailsFilterSensitiveLog");
+var RouteEnterHighwayStepDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Intersection && { Intersection: obj.Intersection.map((item) => LocalizedStringFilterSensitiveLog(item)) },
+  ...obj.SteeringDirection && { SteeringDirection: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TurnIntensity && { TurnIntensity: import_smithy_client.SENSITIVE_STRING }
+}), "RouteEnterHighwayStepDetailsFilterSensitiveLog");
+var RouteExitStepDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Intersection && { Intersection: obj.Intersection.map((item) => LocalizedStringFilterSensitiveLog(item)) },
+  ...obj.RelativeExit && { RelativeExit: import_smithy_client.SENSITIVE_STRING },
+  ...obj.SteeringDirection && { SteeringDirection: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TurnIntensity && { TurnIntensity: import_smithy_client.SENSITIVE_STRING }
+}), "RouteExitStepDetailsFilterSensitiveLog");
+var RouteRampStepDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Intersection && { Intersection: obj.Intersection.map((item) => LocalizedStringFilterSensitiveLog(item)) },
+  ...obj.SteeringDirection && { SteeringDirection: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TurnIntensity && { TurnIntensity: import_smithy_client.SENSITIVE_STRING }
+}), "RouteRampStepDetailsFilterSensitiveLog");
+var RouteUTurnStepDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Intersection && { Intersection: obj.Intersection.map((item) => LocalizedStringFilterSensitiveLog(item)) },
+  ...obj.SteeringDirection && { SteeringDirection: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TurnIntensity && { TurnIntensity: import_smithy_client.SENSITIVE_STRING }
+}), "RouteUTurnStepDetailsFilterSensitiveLog");
+var RouteVehicleTravelStepFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.ContinueHighwayStepDetails && {
+    ContinueHighwayStepDetails: RouteContinueHighwayStepDetailsFilterSensitiveLog(obj.ContinueHighwayStepDetails)
+  },
+  ...obj.ContinueStepDetails && {
+    ContinueStepDetails: RouteContinueStepDetailsFilterSensitiveLog(obj.ContinueStepDetails)
+  },
+  ...obj.CurrentRoad && { CurrentRoad: RouteRoadFilterSensitiveLog(obj.CurrentRoad) },
+  ...obj.Distance && { Distance: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Duration && { Duration: import_smithy_client.SENSITIVE_STRING },
+  ...obj.EnterHighwayStepDetails && {
+    EnterHighwayStepDetails: RouteEnterHighwayStepDetailsFilterSensitiveLog(obj.EnterHighwayStepDetails)
+  },
+  ...obj.ExitNumber && { ExitNumber: obj.ExitNumber.map((item) => LocalizedStringFilterSensitiveLog(item)) },
+  ...obj.ExitStepDetails && { ExitStepDetails: RouteExitStepDetailsFilterSensitiveLog(obj.ExitStepDetails) },
+  ...obj.Instruction && { Instruction: import_smithy_client.SENSITIVE_STRING },
+  ...obj.KeepStepDetails && { KeepStepDetails: RouteKeepStepDetailsFilterSensitiveLog(obj.KeepStepDetails) },
+  ...obj.NextRoad && { NextRoad: RouteRoadFilterSensitiveLog(obj.NextRoad) },
+  ...obj.RampStepDetails && { RampStepDetails: RouteRampStepDetailsFilterSensitiveLog(obj.RampStepDetails) },
+  ...obj.RoundaboutEnterStepDetails && {
+    RoundaboutEnterStepDetails: RouteRoundaboutEnterStepDetailsFilterSensitiveLog(obj.RoundaboutEnterStepDetails)
+  },
+  ...obj.RoundaboutExitStepDetails && {
+    RoundaboutExitStepDetails: RouteRoundaboutExitStepDetailsFilterSensitiveLog(obj.RoundaboutExitStepDetails)
+  },
+  ...obj.RoundaboutPassStepDetails && {
+    RoundaboutPassStepDetails: RouteRoundaboutPassStepDetailsFilterSensitiveLog(obj.RoundaboutPassStepDetails)
+  },
+  ...obj.Signpost && { Signpost: RouteSignpostFilterSensitiveLog(obj.Signpost) },
+  ...obj.TurnStepDetails && { TurnStepDetails: RouteTurnStepDetailsFilterSensitiveLog(obj.TurnStepDetails) },
+  ...obj.Type && { Type: import_smithy_client.SENSITIVE_STRING },
+  ...obj.UTurnStepDetails && { UTurnStepDetails: RouteUTurnStepDetailsFilterSensitiveLog(obj.UTurnStepDetails) }
+}), "RouteVehicleTravelStepFilterSensitiveLog");
+var RouteZoneFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Category && { Category: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Name && { Name: import_smithy_client.SENSITIVE_STRING }
+}), "RouteZoneFilterSensitiveLog");
+var RouteVehicleLegDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Arrival && { Arrival: RouteVehicleArrivalFilterSensitiveLog(obj.Arrival) },
+  ...obj.Departure && { Departure: RouteVehicleDepartureFilterSensitiveLog(obj.Departure) },
+  ...obj.Incidents && { Incidents: obj.Incidents.map((item) => RouteVehicleIncidentFilterSensitiveLog(item)) },
+  ...obj.PassThroughWaypoints && {
+    PassThroughWaypoints: obj.PassThroughWaypoints.map((item) => RoutePassThroughWaypointFilterSensitiveLog(item))
+  },
+  ...obj.Spans && { Spans: obj.Spans.map((item) => RouteVehicleSpanFilterSensitiveLog(item)) },
+  ...obj.Summary && { Summary: RouteVehicleSummaryFilterSensitiveLog(obj.Summary) },
+  ...obj.Tolls && { Tolls: obj.Tolls.map((item) => RouteTollFilterSensitiveLog(item)) },
+  ...obj.TollSystems && { TollSystems: obj.TollSystems.map((item) => RouteTollSystemFilterSensitiveLog(item)) },
+  ...obj.TravelSteps && {
+    TravelSteps: obj.TravelSteps.map((item) => RouteVehicleTravelStepFilterSensitiveLog(item))
+  },
+  ...obj.TruckRoadTypes && { TruckRoadTypes: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Zones && { Zones: obj.Zones.map((item) => RouteZoneFilterSensitiveLog(item)) }
+}), "RouteVehicleLegDetailsFilterSensitiveLog");
+var RouteLegFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.FerryLegDetails && { FerryLegDetails: RouteFerryLegDetailsFilterSensitiveLog(obj.FerryLegDetails) },
+  ...obj.Geometry && { Geometry: RouteLegGeometryFilterSensitiveLog(obj.Geometry) },
+  ...obj.PedestrianLegDetails && {
+    PedestrianLegDetails: RoutePedestrianLegDetailsFilterSensitiveLog(obj.PedestrianLegDetails)
+  },
+  ...obj.TravelMode && { TravelMode: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Type && { Type: import_smithy_client.SENSITIVE_STRING },
+  ...obj.VehicleLegDetails && { VehicleLegDetails: RouteVehicleLegDetailsFilterSensitiveLog(obj.VehicleLegDetails) }
+}), "RouteLegFilterSensitiveLog");
+var RouteMajorRoadLabelFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.RoadName && { RoadName: LocalizedStringFilterSensitiveLog(obj.RoadName) },
+  ...obj.RouteNumber && { RouteNumber: RouteNumberFilterSensitiveLog(obj.RouteNumber) }
+}), "RouteMajorRoadLabelFilterSensitiveLog");
+var RouteTollPriceSummaryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Estimate && { Estimate: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Range && { Range: import_smithy_client.SENSITIVE_STRING },
+  ...obj.RangeValue && { RangeValue: RouteTollPriceValueRangeFilterSensitiveLog(obj.RangeValue) },
+  ...obj.Value && { Value: import_smithy_client.SENSITIVE_STRING }
+}), "RouteTollPriceSummaryFilterSensitiveLog");
+var RouteTollSummaryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Total && { Total: RouteTollPriceSummaryFilterSensitiveLog(obj.Total) }
+}), "RouteTollSummaryFilterSensitiveLog");
+var RouteSummaryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Distance && { Distance: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Duration && { Duration: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Tolls && { Tolls: RouteTollSummaryFilterSensitiveLog(obj.Tolls) }
+}), "RouteSummaryFilterSensitiveLog");
+var RouteFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Legs && { Legs: obj.Legs.map((item) => RouteLegFilterSensitiveLog(item)) },
+  ...obj.MajorRoadLabels && {
+    MajorRoadLabels: obj.MajorRoadLabels.map((item) => RouteMajorRoadLabelFilterSensitiveLog(item))
+  },
+  ...obj.Summary && { Summary: RouteSummaryFilterSensitiveLog(obj.Summary) }
+}), "RouteFilterSensitiveLog");
+var CalculateRoutesResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Routes && { Routes: obj.Routes.map((item) => RouteFilterSensitiveLog(item)) }
+}), "CalculateRoutesResponseFilterSensitiveLog");
+var WaypointOptimizationAvoidanceAreaGeometryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.BoundingBox && { BoundingBox: import_smithy_client.SENSITIVE_STRING }
+}), "WaypointOptimizationAvoidanceAreaGeometryFilterSensitiveLog");
+var WaypointOptimizationAvoidanceAreaFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Geometry && { Geometry: WaypointOptimizationAvoidanceAreaGeometryFilterSensitiveLog(obj.Geometry) }
+}), "WaypointOptimizationAvoidanceAreaFilterSensitiveLog");
+var WaypointOptimizationAvoidanceOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Areas && { Areas: obj.Areas.map((item) => WaypointOptimizationAvoidanceAreaFilterSensitiveLog(item)) },
+  ...obj.CarShuttleTrains && { CarShuttleTrains: import_smithy_client.SENSITIVE_STRING },
+  ...obj.ControlledAccessHighways && { ControlledAccessHighways: import_smithy_client.SENSITIVE_STRING },
+  ...obj.DirtRoads && { DirtRoads: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Ferries && { Ferries: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TollRoads && { TollRoads: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Tunnels && { Tunnels: import_smithy_client.SENSITIVE_STRING },
+  ...obj.UTurns && { UTurns: import_smithy_client.SENSITIVE_STRING }
+}), "WaypointOptimizationAvoidanceOptionsFilterSensitiveLog");
+var WaypointOptimizationDrivingDistanceOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.DrivingDistance && { DrivingDistance: import_smithy_client.SENSITIVE_STRING }
+}), "WaypointOptimizationDrivingDistanceOptionsFilterSensitiveLog");
+var WaypointOptimizationClusteringOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Algorithm && { Algorithm: import_smithy_client.SENSITIVE_STRING },
+  ...obj.DrivingDistanceOptions && {
+    DrivingDistanceOptions: WaypointOptimizationDrivingDistanceOptionsFilterSensitiveLog(obj.DrivingDistanceOptions)
+  }
+}), "WaypointOptimizationClusteringOptionsFilterSensitiveLog");
+var WaypointOptimizationAccessHoursEntryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.DayOfWeek && { DayOfWeek: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TimeOfDay && { TimeOfDay: import_smithy_client.SENSITIVE_STRING }
+}), "WaypointOptimizationAccessHoursEntryFilterSensitiveLog");
+var WaypointOptimizationAccessHoursFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.From && { From: WaypointOptimizationAccessHoursEntryFilterSensitiveLog(obj.From) },
+  ...obj.To && { To: WaypointOptimizationAccessHoursEntryFilterSensitiveLog(obj.To) }
+}), "WaypointOptimizationAccessHoursFilterSensitiveLog");
+var WaypointOptimizationSideOfStreetOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Position && { Position: import_smithy_client.SENSITIVE_STRING }
+}), "WaypointOptimizationSideOfStreetOptionsFilterSensitiveLog");
+var WaypointOptimizationDestinationOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.AccessHours && { AccessHours: WaypointOptimizationAccessHoursFilterSensitiveLog(obj.AccessHours) },
+  ...obj.AppointmentTime && { AppointmentTime: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Heading && { Heading: import_smithy_client.SENSITIVE_STRING },
+  ...obj.ServiceDuration && { ServiceDuration: import_smithy_client.SENSITIVE_STRING },
+  ...obj.SideOfStreet && {
+    SideOfStreet: WaypointOptimizationSideOfStreetOptionsFilterSensitiveLog(obj.SideOfStreet)
+  }
+}), "WaypointOptimizationDestinationOptionsFilterSensitiveLog");
+var WaypointOptimizationRestCycleDurationsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.RestDuration && { RestDuration: import_smithy_client.SENSITIVE_STRING },
+  ...obj.WorkDuration && { WorkDuration: import_smithy_client.SENSITIVE_STRING }
+}), "WaypointOptimizationRestCycleDurationsFilterSensitiveLog");
+var WaypointOptimizationRestCyclesFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.LongCycle && { LongCycle: WaypointOptimizationRestCycleDurationsFilterSensitiveLog(obj.LongCycle) },
+  ...obj.ShortCycle && { ShortCycle: WaypointOptimizationRestCycleDurationsFilterSensitiveLog(obj.ShortCycle) }
+}), "WaypointOptimizationRestCyclesFilterSensitiveLog");
+var WaypointOptimizationRestProfileFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Profile && { Profile: import_smithy_client.SENSITIVE_STRING }
+}), "WaypointOptimizationRestProfileFilterSensitiveLog");
+var WaypointOptimizationDriverOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.RestCycles && { RestCycles: WaypointOptimizationRestCyclesFilterSensitiveLog(obj.RestCycles) },
+  ...obj.RestProfile && { RestProfile: WaypointOptimizationRestProfileFilterSensitiveLog(obj.RestProfile) },
+  ...obj.TreatServiceTimeAs && { TreatServiceTimeAs: import_smithy_client.SENSITIVE_STRING }
+}), "WaypointOptimizationDriverOptionsFilterSensitiveLog");
+var WaypointOptimizationExclusionOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Countries && { Countries: import_smithy_client.SENSITIVE_STRING }
+}), "WaypointOptimizationExclusionOptionsFilterSensitiveLog");
+var WaypointOptimizationPedestrianOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Speed && { Speed: import_smithy_client.SENSITIVE_STRING }
+}), "WaypointOptimizationPedestrianOptionsFilterSensitiveLog");
+var WaypointOptimizationTrailerOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.TrailerCount && { TrailerCount: import_smithy_client.SENSITIVE_STRING }
+}), "WaypointOptimizationTrailerOptionsFilterSensitiveLog");
+var WaypointOptimizationTruckOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.GrossWeight && { GrossWeight: import_smithy_client.SENSITIVE_STRING },
+  ...obj.HazardousCargos && { HazardousCargos: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Height && { Height: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Length && { Length: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Trailer && { Trailer: WaypointOptimizationTrailerOptionsFilterSensitiveLog(obj.Trailer) },
+  ...obj.TruckType && { TruckType: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TunnelRestrictionCode && { TunnelRestrictionCode: import_smithy_client.SENSITIVE_STRING },
+  ...obj.WeightPerAxle && { WeightPerAxle: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Width && { Width: import_smithy_client.SENSITIVE_STRING }
+}), "WaypointOptimizationTruckOptionsFilterSensitiveLog");
+var WaypointOptimizationTravelModeOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Pedestrian && { Pedestrian: WaypointOptimizationPedestrianOptionsFilterSensitiveLog(obj.Pedestrian) },
+  ...obj.Truck && { Truck: WaypointOptimizationTruckOptionsFilterSensitiveLog(obj.Truck) }
+}), "WaypointOptimizationTravelModeOptionsFilterSensitiveLog");
+var WaypointOptimizationWaypointFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.AccessHours && { AccessHours: WaypointOptimizationAccessHoursFilterSensitiveLog(obj.AccessHours) },
+  ...obj.AppointmentTime && { AppointmentTime: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Heading && { Heading: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Position && { Position: import_smithy_client.SENSITIVE_STRING },
+  ...obj.ServiceDuration && { ServiceDuration: import_smithy_client.SENSITIVE_STRING },
+  ...obj.SideOfStreet && {
+    SideOfStreet: WaypointOptimizationSideOfStreetOptionsFilterSensitiveLog(obj.SideOfStreet)
+  }
+}), "WaypointOptimizationWaypointFilterSensitiveLog");
+var OptimizeWaypointsRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Avoid && { Avoid: WaypointOptimizationAvoidanceOptionsFilterSensitiveLog(obj.Avoid) },
+  ...obj.Clustering && { Clustering: WaypointOptimizationClusteringOptionsFilterSensitiveLog(obj.Clustering) },
+  ...obj.DepartureTime && { DepartureTime: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Destination && { Destination: import_smithy_client.SENSITIVE_STRING },
+  ...obj.DestinationOptions && {
+    DestinationOptions: WaypointOptimizationDestinationOptionsFilterSensitiveLog(obj.DestinationOptions)
+  },
+  ...obj.Driver && { Driver: WaypointOptimizationDriverOptionsFilterSensitiveLog(obj.Driver) },
+  ...obj.Exclude && { Exclude: WaypointOptimizationExclusionOptionsFilterSensitiveLog(obj.Exclude) },
+  ...obj.Key && { Key: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Origin && { Origin: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TravelModeOptions && {
+    TravelModeOptions: WaypointOptimizationTravelModeOptionsFilterSensitiveLog(obj.TravelModeOptions)
+  },
+  ...obj.Waypoints && {
+    Waypoints: obj.Waypoints.map((item) => WaypointOptimizationWaypointFilterSensitiveLog(item))
+  }
+}), "OptimizeWaypointsRequestFilterSensitiveLog");
+var WaypointOptimizationConnectionFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Distance && { Distance: import_smithy_client.SENSITIVE_STRING },
+  ...obj.RestDuration && { RestDuration: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TravelDuration && { TravelDuration: import_smithy_client.SENSITIVE_STRING },
+  ...obj.WaitDuration && { WaitDuration: import_smithy_client.SENSITIVE_STRING }
+}), "WaypointOptimizationConnectionFilterSensitiveLog");
+var WaypointOptimizationFailedConstraintFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Constraint && { Constraint: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Reason && { Reason: import_smithy_client.SENSITIVE_STRING }
+}), "WaypointOptimizationFailedConstraintFilterSensitiveLog");
+var WaypointOptimizationImpedingWaypointFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.FailedConstraints && {
+    FailedConstraints: obj.FailedConstraints.map(
+      (item) => WaypointOptimizationFailedConstraintFilterSensitiveLog(item)
+    )
+  },
+  ...obj.Position && { Position: import_smithy_client.SENSITIVE_STRING }
+}), "WaypointOptimizationImpedingWaypointFilterSensitiveLog");
+var WaypointOptimizationOptimizedWaypointFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.ArrivalTime && { ArrivalTime: import_smithy_client.SENSITIVE_STRING },
+  ...obj.DepartureTime && { DepartureTime: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Position && { Position: import_smithy_client.SENSITIVE_STRING }
+}), "WaypointOptimizationOptimizedWaypointFilterSensitiveLog");
+var WaypointOptimizationTimeBreakdownFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.RestDuration && { RestDuration: import_smithy_client.SENSITIVE_STRING },
+  ...obj.ServiceDuration && { ServiceDuration: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TravelDuration && { TravelDuration: import_smithy_client.SENSITIVE_STRING },
+  ...obj.WaitDuration && { WaitDuration: import_smithy_client.SENSITIVE_STRING }
+}), "WaypointOptimizationTimeBreakdownFilterSensitiveLog");
+var OptimizeWaypointsResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Connections && {
+    Connections: obj.Connections.map((item) => WaypointOptimizationConnectionFilterSensitiveLog(item))
+  },
+  ...obj.Distance && { Distance: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Duration && { Duration: import_smithy_client.SENSITIVE_STRING },
+  ...obj.ImpedingWaypoints && {
+    ImpedingWaypoints: obj.ImpedingWaypoints.map(
+      (item) => WaypointOptimizationImpedingWaypointFilterSensitiveLog(item)
+    )
+  },
+  ...obj.OptimizedWaypoints && {
+    OptimizedWaypoints: obj.OptimizedWaypoints.map(
+      (item) => WaypointOptimizationOptimizedWaypointFilterSensitiveLog(item)
+    )
+  },
+  ...obj.TimeBreakdown && { TimeBreakdown: WaypointOptimizationTimeBreakdownFilterSensitiveLog(obj.TimeBreakdown) }
+}), "OptimizeWaypointsResponseFilterSensitiveLog");
+var RoadSnapTracePointFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Heading && { Heading: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Position && { Position: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Speed && { Speed: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Timestamp && { Timestamp: import_smithy_client.SENSITIVE_STRING }
+}), "RoadSnapTracePointFilterSensitiveLog");
+var RoadSnapTrailerOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.TrailerCount && { TrailerCount: import_smithy_client.SENSITIVE_STRING }
+}), "RoadSnapTrailerOptionsFilterSensitiveLog");
+var RoadSnapTruckOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.GrossWeight && { GrossWeight: import_smithy_client.SENSITIVE_STRING },
+  ...obj.HazardousCargos && { HazardousCargos: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Height && { Height: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Length && { Length: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Trailer && { Trailer: RoadSnapTrailerOptionsFilterSensitiveLog(obj.Trailer) },
+  ...obj.TunnelRestrictionCode && { TunnelRestrictionCode: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Width && { Width: import_smithy_client.SENSITIVE_STRING }
+}), "RoadSnapTruckOptionsFilterSensitiveLog");
+var RoadSnapTravelModeOptionsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Truck && { Truck: RoadSnapTruckOptionsFilterSensitiveLog(obj.Truck) }
+}), "RoadSnapTravelModeOptionsFilterSensitiveLog");
+var SnapToRoadsRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Key && { Key: import_smithy_client.SENSITIVE_STRING },
+  ...obj.SnapRadius && { SnapRadius: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TracePoints && { TracePoints: obj.TracePoints.map((item) => RoadSnapTracePointFilterSensitiveLog(item)) },
+  ...obj.TravelModeOptions && {
+    TravelModeOptions: RoadSnapTravelModeOptionsFilterSensitiveLog(obj.TravelModeOptions)
+  }
+}), "SnapToRoadsRequestFilterSensitiveLog");
+var RoadSnapNoticeFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Code && { Code: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Title && { Title: import_smithy_client.SENSITIVE_STRING },
+  ...obj.TracePointIndexes && { TracePointIndexes: import_smithy_client.SENSITIVE_STRING }
+}), "RoadSnapNoticeFilterSensitiveLog");
+var RoadSnapSnappedGeometryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.LineString && { LineString: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Polyline && { Polyline: import_smithy_client.SENSITIVE_STRING }
+}), "RoadSnapSnappedGeometryFilterSensitiveLog");
+var RoadSnapSnappedTracePointFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Confidence && { Confidence: import_smithy_client.SENSITIVE_STRING },
+  ...obj.OriginalPosition && { OriginalPosition: import_smithy_client.SENSITIVE_STRING },
+  ...obj.SnappedPosition && { SnappedPosition: import_smithy_client.SENSITIVE_STRING }
+}), "RoadSnapSnappedTracePointFilterSensitiveLog");
+var SnapToRoadsResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Notices && { Notices: obj.Notices.map((item) => RoadSnapNoticeFilterSensitiveLog(item)) },
+  ...obj.SnappedGeometry && { SnappedGeometry: RoadSnapSnappedGeometryFilterSensitiveLog(obj.SnappedGeometry) },
+  ...obj.SnappedTracePoints && {
+    SnappedTracePoints: obj.SnappedTracePoints.map((item) => RoadSnapSnappedTracePointFilterSensitiveLog(item))
+  }
+}), "SnapToRoadsResponseFilterSensitiveLog");
+
+// src/protocols/Aws_restJson1.ts
+var import_core2 = require("@aws-sdk/core");
+
+
+var se_CalculateIsolinesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/isolines");
+  const query = (0, import_smithy_client.map)({
+    [_k]: [, input[_K]]
+  });
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Allow: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Allow"),
+      ArrivalTime: [],
+      Avoid: /* @__PURE__ */ __name((_) => se_IsolineAvoidanceOptions(_, context), "Avoid"),
+      DepartNow: [],
+      DepartureTime: [],
+      Destination: /* @__PURE__ */ __name((_) => se_Position(_, context), "Destination"),
+      DestinationOptions: /* @__PURE__ */ __name((_) => se_IsolineDestinationOptions(_, context), "DestinationOptions"),
+      IsolineGeometryFormat: [],
+      IsolineGranularity: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "IsolineGranularity"),
+      OptimizeIsolineFor: [],
+      OptimizeRoutingFor: [],
+      Origin: /* @__PURE__ */ __name((_) => se_Position(_, context), "Origin"),
+      OriginOptions: /* @__PURE__ */ __name((_) => se_IsolineOriginOptions(_, context), "OriginOptions"),
+      Thresholds: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Thresholds"),
+      Traffic: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Traffic"),
+      TravelMode: [],
+      TravelModeOptions: /* @__PURE__ */ __name((_) => se_IsolineTravelModeOptions(_, context), "TravelModeOptions")
+    })
+  );
+  b.m("POST").h(headers).q(query).b(body);
+  return b.build();
+}, "se_CalculateIsolinesCommand");
+var se_CalculateRouteMatrixCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/route-matrix");
+  const query = (0, import_smithy_client.map)({
+    [_k]: [, input[_K]]
+  });
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Allow: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Allow"),
+      Avoid: /* @__PURE__ */ __name((_) => se_RouteMatrixAvoidanceOptions(_, context), "Avoid"),
+      DepartNow: [],
+      DepartureTime: [],
+      Destinations: /* @__PURE__ */ __name((_) => se_RouteMatrixDestinationList(_, context), "Destinations"),
+      Exclude: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Exclude"),
+      OptimizeRoutingFor: [],
+      Origins: /* @__PURE__ */ __name((_) => se_RouteMatrixOriginList(_, context), "Origins"),
+      RoutingBoundary: /* @__PURE__ */ __name((_) => se_RouteMatrixBoundary(_, context), "RoutingBoundary"),
+      Traffic: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Traffic"),
+      TravelMode: [],
+      TravelModeOptions: /* @__PURE__ */ __name((_) => se_RouteMatrixTravelModeOptions(_, context), "TravelModeOptions")
+    })
+  );
+  b.m("POST").h(headers).q(query).b(body);
+  return b.build();
+}, "se_CalculateRouteMatrixCommand");
+var se_CalculateRoutesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/routes");
+  const query = (0, import_smithy_client.map)({
+    [_k]: [, input[_K]]
+  });
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Allow: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Allow"),
+      ArrivalTime: [],
+      Avoid: /* @__PURE__ */ __name((_) => se_RouteAvoidanceOptions(_, context), "Avoid"),
+      DepartNow: [],
+      DepartureTime: [],
+      Destination: /* @__PURE__ */ __name((_) => se_Position(_, context), "Destination"),
+      DestinationOptions: /* @__PURE__ */ __name((_) => se_RouteDestinationOptions(_, context), "DestinationOptions"),
+      Driver: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Driver"),
+      Exclude: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Exclude"),
+      InstructionsMeasurementSystem: [],
+      Languages: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Languages"),
+      LegAdditionalFeatures: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "LegAdditionalFeatures"),
+      LegGeometryFormat: [],
+      MaxAlternatives: [],
+      OptimizeRoutingFor: [],
+      Origin: /* @__PURE__ */ __name((_) => se_Position(_, context), "Origin"),
+      OriginOptions: /* @__PURE__ */ __name((_) => se_RouteOriginOptions(_, context), "OriginOptions"),
+      SpanAdditionalFeatures: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "SpanAdditionalFeatures"),
+      Tolls: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Tolls"),
+      Traffic: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Traffic"),
+      TravelMode: [],
+      TravelModeOptions: /* @__PURE__ */ __name((_) => se_RouteTravelModeOptions(_, context), "TravelModeOptions"),
+      TravelStepType: [],
+      Waypoints: /* @__PURE__ */ __name((_) => se_RouteWaypointList(_, context), "Waypoints")
+    })
+  );
+  b.m("POST").h(headers).q(query).b(body);
+  return b.build();
+}, "se_CalculateRoutesCommand");
+var se_OptimizeWaypointsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/optimize-waypoints");
+  const query = (0, import_smithy_client.map)({
+    [_k]: [, input[_K]]
+  });
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Avoid: /* @__PURE__ */ __name((_) => se_WaypointOptimizationAvoidanceOptions(_, context), "Avoid"),
+      Clustering: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Clustering"),
+      DepartureTime: [],
+      Destination: /* @__PURE__ */ __name((_) => se_Position(_, context), "Destination"),
+      DestinationOptions: /* @__PURE__ */ __name((_) => se_WaypointOptimizationDestinationOptions(_, context), "DestinationOptions"),
+      Driver: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Driver"),
+      Exclude: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Exclude"),
+      OptimizeSequencingFor: [],
+      Origin: /* @__PURE__ */ __name((_) => se_Position(_, context), "Origin"),
+      OriginOptions: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "OriginOptions"),
+      Traffic: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Traffic"),
+      TravelMode: [],
+      TravelModeOptions: /* @__PURE__ */ __name((_) => se_WaypointOptimizationTravelModeOptions(_, context), "TravelModeOptions"),
+      Waypoints: /* @__PURE__ */ __name((_) => se_WaypointOptimizationWaypointList(_, context), "Waypoints")
+    })
+  );
+  b.m("POST").h(headers).q(query).b(body);
+  return b.build();
+}, "se_OptimizeWaypointsCommand");
+var se_SnapToRoadsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/snap-to-roads");
+  const query = (0, import_smithy_client.map)({
+    [_k]: [, input[_K]]
+  });
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      SnapRadius: [],
+      SnappedGeometryFormat: [],
+      TracePoints: /* @__PURE__ */ __name((_) => se_RoadSnapTracePointList(_, context), "TracePoints"),
+      TravelMode: [],
+      TravelModeOptions: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "TravelModeOptions")
+    })
+  );
+  b.m("POST").h(headers).q(query).b(body);
+  return b.build();
+}, "se_SnapToRoadsCommand");
+var de_CalculateIsolinesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output),
+    [_PB]: [, output.headers[_xagpb]]
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    ArrivalTime: import_smithy_client.expectString,
+    DepartureTime: import_smithy_client.expectString,
+    IsolineGeometryFormat: import_smithy_client.expectString,
+    Isolines: /* @__PURE__ */ __name((_) => de_IsolineList(_, context), "Isolines"),
+    SnappedDestination: /* @__PURE__ */ __name((_) => de_Position(_, context), "SnappedDestination"),
+    SnappedOrigin: /* @__PURE__ */ __name((_) => de_Position(_, context), "SnappedOrigin")
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CalculateIsolinesCommand");
+var de_CalculateRouteMatrixCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output),
+    [_PB]: [, output.headers[_xagpb]]
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    ErrorCount: import_smithy_client.expectInt32,
+    RouteMatrix: import_smithy_client._json,
+    RoutingBoundary: /* @__PURE__ */ __name((_) => de_RouteMatrixBoundary(_, context), "RoutingBoundary")
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CalculateRouteMatrixCommand");
+var de_CalculateRoutesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output),
+    [_PB]: [, output.headers[_xagpb]]
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    LegGeometryFormat: import_smithy_client.expectString,
+    Notices: import_smithy_client._json,
+    Routes: /* @__PURE__ */ __name((_) => de_RouteList(_, context), "Routes")
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CalculateRoutesCommand");
+var de_OptimizeWaypointsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output),
+    [_PB]: [, output.headers[_xagpb]]
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Connections: import_smithy_client._json,
+    Distance: import_smithy_client.expectLong,
+    Duration: import_smithy_client.expectLong,
+    ImpedingWaypoints: /* @__PURE__ */ __name((_) => de_WaypointOptimizationImpedingWaypointList(_, context), "ImpedingWaypoints"),
+    OptimizedWaypoints: /* @__PURE__ */ __name((_) => de_WaypointOptimizationOptimizedWaypointList(_, context), "OptimizedWaypoints"),
+    TimeBreakdown: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_OptimizeWaypointsCommand");
+var de_SnapToRoadsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output),
+    [_PB]: [, output.headers[_xagpb]]
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Notices: import_smithy_client._json,
+    SnappedGeometry: /* @__PURE__ */ __name((_) => de_RoadSnapSnappedGeometry(_, context), "SnappedGeometry"),
+    SnappedGeometryFormat: import_smithy_client.expectString,
+    SnappedTracePoints: /* @__PURE__ */ __name((_) => de_RoadSnapSnappedTracePointList(_, context), "SnappedTracePoints")
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_SnapToRoadsCommand");
+var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
+  };
+  const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.georoutes#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.georoutes#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.georoutes#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.georoutes#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(GeoRoutesServiceException);
+var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: [, import_smithy_client.expectString, `message`]
+  });
+  Object.assign(contents, doc);
+  const exception = new AccessDeniedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_AccessDeniedExceptionRes");
+var de_InternalServerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: [, import_smithy_client.expectString, `message`]
+  });
+  Object.assign(contents, doc);
+  const exception = new InternalServerException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InternalServerExceptionRes");
+var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: [, import_smithy_client.expectString, `message`]
+  });
+  Object.assign(contents, doc);
+  const exception = new ThrottlingException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ThrottlingExceptionRes");
+var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    FieldList: [, (_) => de_ValidationExceptionFieldList(_, context), `fieldList`],
+    Message: [, import_smithy_client.expectString, `message`],
+    Reason: [, import_smithy_client.expectString, `reason`]
+  });
+  Object.assign(contents, doc);
+  const exception = new ValidationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ValidationExceptionRes");
+var se_BoundingBox = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return (0, import_smithy_client.serializeFloat)(entry);
+  });
+}, "se_BoundingBox");
+var se_Circle = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Center: /* @__PURE__ */ __name((_) => se_Position(_, context), "Center"),
+    Radius: import_smithy_client.serializeFloat
+  });
+}, "se_Circle");
+var se_Corridor = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    LineString: /* @__PURE__ */ __name((_) => se_LineString(_, context), "LineString"),
+    Radius: []
+  });
+}, "se_Corridor");
+var se_IsolineAvoidanceArea = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Except: /* @__PURE__ */ __name((_) => se_IsolineAvoidanceAreaGeometryList(_, context), "Except"),
+    Geometry: /* @__PURE__ */ __name((_) => se_IsolineAvoidanceAreaGeometry(_, context), "Geometry")
+  });
+}, "se_IsolineAvoidanceArea");
+var se_IsolineAvoidanceAreaGeometry = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    BoundingBox: /* @__PURE__ */ __name((_) => se_BoundingBox(_, context), "BoundingBox"),
+    Corridor: /* @__PURE__ */ __name((_) => se_Corridor(_, context), "Corridor"),
+    Polygon: /* @__PURE__ */ __name((_) => se_LinearRings(_, context), "Polygon"),
+    PolylineCorridor: import_smithy_client._json,
+    PolylinePolygon: import_smithy_client._json
+  });
+}, "se_IsolineAvoidanceAreaGeometry");
+var se_IsolineAvoidanceAreaGeometryList = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_IsolineAvoidanceAreaGeometry(entry, context);
+  });
+}, "se_IsolineAvoidanceAreaGeometryList");
+var se_IsolineAvoidanceAreaList = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_IsolineAvoidanceArea(entry, context);
+  });
+}, "se_IsolineAvoidanceAreaList");
+var se_IsolineAvoidanceOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Areas: /* @__PURE__ */ __name((_) => se_IsolineAvoidanceAreaList(_, context), "Areas"),
+    CarShuttleTrains: [],
+    ControlledAccessHighways: [],
+    DirtRoads: [],
+    Ferries: [],
+    SeasonalClosure: [],
+    TollRoads: [],
+    TollTransponders: [],
+    TruckRoadTypes: import_smithy_client._json,
+    Tunnels: [],
+    UTurns: [],
+    ZoneCategories: import_smithy_client._json
+  });
+}, "se_IsolineAvoidanceOptions");
+var se_IsolineCarOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    EngineType: [],
+    LicensePlate: import_smithy_client._json,
+    MaxSpeed: import_smithy_client.serializeFloat,
+    Occupancy: []
+  });
+}, "se_IsolineCarOptions");
+var se_IsolineDestinationOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AvoidActionsForDistance: [],
+    Heading: import_smithy_client.serializeFloat,
+    Matching: import_smithy_client._json,
+    SideOfStreet: /* @__PURE__ */ __name((_) => se_IsolineSideOfStreetOptions(_, context), "SideOfStreet")
+  });
+}, "se_IsolineDestinationOptions");
+var se_IsolineOriginOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AvoidActionsForDistance: [],
+    Heading: import_smithy_client.serializeFloat,
+    Matching: import_smithy_client._json,
+    SideOfStreet: /* @__PURE__ */ __name((_) => se_IsolineSideOfStreetOptions(_, context), "SideOfStreet")
+  });
+}, "se_IsolineOriginOptions");
+var se_IsolineScooterOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    EngineType: [],
+    LicensePlate: import_smithy_client._json,
+    MaxSpeed: import_smithy_client.serializeFloat,
+    Occupancy: []
+  });
+}, "se_IsolineScooterOptions");
+var se_IsolineSideOfStreetOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Position: /* @__PURE__ */ __name((_) => se_Position(_, context), "Position"),
+    UseWith: []
+  });
+}, "se_IsolineSideOfStreetOptions");
+var se_IsolineTravelModeOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Car: /* @__PURE__ */ __name((_) => se_IsolineCarOptions(_, context), "Car"),
+    Scooter: /* @__PURE__ */ __name((_) => se_IsolineScooterOptions(_, context), "Scooter"),
+    Truck: /* @__PURE__ */ __name((_) => se_IsolineTruckOptions(_, context), "Truck")
+  });
+}, "se_IsolineTravelModeOptions");
+var se_IsolineTruckOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AxleCount: [],
+    EngineType: [],
+    GrossWeight: [],
+    HazardousCargos: import_smithy_client._json,
+    Height: [],
+    HeightAboveFirstAxle: [],
+    KpraLength: [],
+    Length: [],
+    LicensePlate: import_smithy_client._json,
+    MaxSpeed: import_smithy_client.serializeFloat,
+    Occupancy: [],
+    PayloadCapacity: [],
+    TireCount: [],
+    Trailer: import_smithy_client._json,
+    TruckType: [],
+    TunnelRestrictionCode: [],
+    WeightPerAxle: [],
+    WeightPerAxleGroup: import_smithy_client._json,
+    Width: []
+  });
+}, "se_IsolineTruckOptions");
+var se_LinearRing = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_Position(entry, context);
+  });
+}, "se_LinearRing");
+var se_LinearRings = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_LinearRing(entry, context);
+  });
+}, "se_LinearRings");
+var se_LineString = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_Position(entry, context);
+  });
+}, "se_LineString");
+var se_Position = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return (0, import_smithy_client.serializeFloat)(entry);
+  });
+}, "se_Position");
+var se_RoadSnapTracePoint = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Heading: import_smithy_client.serializeFloat,
+    Position: /* @__PURE__ */ __name((_) => se_Position(_, context), "Position"),
+    Speed: import_smithy_client.serializeFloat,
+    Timestamp: []
+  });
+}, "se_RoadSnapTracePoint");
+var se_RoadSnapTracePointList = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_RoadSnapTracePoint(entry, context);
+  });
+}, "se_RoadSnapTracePointList");
+var se_RouteAvoidanceArea = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Except: /* @__PURE__ */ __name((_) => se_RouteAvoidanceAreaGeometryList(_, context), "Except"),
+    Geometry: /* @__PURE__ */ __name((_) => se_RouteAvoidanceAreaGeometry(_, context), "Geometry")
+  });
+}, "se_RouteAvoidanceArea");
+var se_RouteAvoidanceAreaGeometry = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    BoundingBox: /* @__PURE__ */ __name((_) => se_BoundingBox(_, context), "BoundingBox"),
+    Corridor: /* @__PURE__ */ __name((_) => se_Corridor(_, context), "Corridor"),
+    Polygon: /* @__PURE__ */ __name((_) => se_LinearRings(_, context), "Polygon"),
+    PolylineCorridor: import_smithy_client._json,
+    PolylinePolygon: import_smithy_client._json
+  });
+}, "se_RouteAvoidanceAreaGeometry");
+var se_RouteAvoidanceAreaGeometryList = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_RouteAvoidanceAreaGeometry(entry, context);
+  });
+}, "se_RouteAvoidanceAreaGeometryList");
+var se_RouteAvoidanceAreaList = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_RouteAvoidanceArea(entry, context);
+  });
+}, "se_RouteAvoidanceAreaList");
+var se_RouteAvoidanceOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Areas: /* @__PURE__ */ __name((_) => se_RouteAvoidanceAreaList(_, context), "Areas"),
+    CarShuttleTrains: [],
+    ControlledAccessHighways: [],
+    DirtRoads: [],
+    Ferries: [],
+    SeasonalClosure: [],
+    TollRoads: [],
+    TollTransponders: [],
+    TruckRoadTypes: import_smithy_client._json,
+    Tunnels: [],
+    UTurns: [],
+    ZoneCategories: import_smithy_client._json
+  });
+}, "se_RouteAvoidanceOptions");
+var se_RouteCarOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    EngineType: [],
+    LicensePlate: import_smithy_client._json,
+    MaxSpeed: import_smithy_client.serializeFloat,
+    Occupancy: []
+  });
+}, "se_RouteCarOptions");
+var se_RouteDestinationOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AvoidActionsForDistance: [],
+    AvoidUTurns: [],
+    Heading: import_smithy_client.serializeFloat,
+    Matching: import_smithy_client._json,
+    SideOfStreet: /* @__PURE__ */ __name((_) => se_RouteSideOfStreetOptions(_, context), "SideOfStreet"),
+    StopDuration: []
+  });
+}, "se_RouteDestinationOptions");
+var se_RouteMatrixAvoidanceArea = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Geometry: /* @__PURE__ */ __name((_) => se_RouteMatrixAvoidanceAreaGeometry(_, context), "Geometry")
+  });
+}, "se_RouteMatrixAvoidanceArea");
+var se_RouteMatrixAvoidanceAreaGeometry = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    BoundingBox: /* @__PURE__ */ __name((_) => se_BoundingBox(_, context), "BoundingBox"),
+    Polygon: /* @__PURE__ */ __name((_) => se_LinearRings(_, context), "Polygon"),
+    PolylinePolygon: import_smithy_client._json
+  });
+}, "se_RouteMatrixAvoidanceAreaGeometry");
+var se_RouteMatrixAvoidanceAreaList = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_RouteMatrixAvoidanceArea(entry, context);
+  });
+}, "se_RouteMatrixAvoidanceAreaList");
+var se_RouteMatrixAvoidanceOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Areas: /* @__PURE__ */ __name((_) => se_RouteMatrixAvoidanceAreaList(_, context), "Areas"),
+    CarShuttleTrains: [],
+    ControlledAccessHighways: [],
+    DirtRoads: [],
+    Ferries: [],
+    TollRoads: [],
+    TollTransponders: [],
+    TruckRoadTypes: import_smithy_client._json,
+    Tunnels: [],
+    UTurns: [],
+    ZoneCategories: import_smithy_client._json
+  });
+}, "se_RouteMatrixAvoidanceOptions");
+var se_RouteMatrixBoundary = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Geometry: /* @__PURE__ */ __name((_) => se_RouteMatrixBoundaryGeometry(_, context), "Geometry"),
+    Unbounded: []
+  });
+}, "se_RouteMatrixBoundary");
+var se_RouteMatrixBoundaryGeometry = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AutoCircle: import_smithy_client._json,
+    BoundingBox: /* @__PURE__ */ __name((_) => se_BoundingBox(_, context), "BoundingBox"),
+    Circle: /* @__PURE__ */ __name((_) => se_Circle(_, context), "Circle"),
+    Polygon: /* @__PURE__ */ __name((_) => se_LinearRings(_, context), "Polygon")
+  });
+}, "se_RouteMatrixBoundaryGeometry");
+var se_RouteMatrixCarOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    LicensePlate: import_smithy_client._json,
+    MaxSpeed: import_smithy_client.serializeFloat,
+    Occupancy: []
+  });
+}, "se_RouteMatrixCarOptions");
+var se_RouteMatrixDestination = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Options: /* @__PURE__ */ __name((_) => se_RouteMatrixDestinationOptions(_, context), "Options"),
+    Position: /* @__PURE__ */ __name((_) => se_Position(_, context), "Position")
+  });
+}, "se_RouteMatrixDestination");
+var se_RouteMatrixDestinationList = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_RouteMatrixDestination(entry, context);
+  });
+}, "se_RouteMatrixDestinationList");
+var se_RouteMatrixDestinationOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AvoidActionsForDistance: [],
+    Heading: import_smithy_client.serializeFloat,
+    Matching: import_smithy_client._json,
+    SideOfStreet: /* @__PURE__ */ __name((_) => se_RouteMatrixSideOfStreetOptions(_, context), "SideOfStreet")
+  });
+}, "se_RouteMatrixDestinationOptions");
+var se_RouteMatrixOrigin = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Options: /* @__PURE__ */ __name((_) => se_RouteMatrixOriginOptions(_, context), "Options"),
+    Position: /* @__PURE__ */ __name((_) => se_Position(_, context), "Position")
+  });
+}, "se_RouteMatrixOrigin");
+var se_RouteMatrixOriginList = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_RouteMatrixOrigin(entry, context);
+  });
+}, "se_RouteMatrixOriginList");
+var se_RouteMatrixOriginOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AvoidActionsForDistance: [],
+    Heading: import_smithy_client.serializeFloat,
+    Matching: import_smithy_client._json,
+    SideOfStreet: /* @__PURE__ */ __name((_) => se_RouteMatrixSideOfStreetOptions(_, context), "SideOfStreet")
+  });
+}, "se_RouteMatrixOriginOptions");
+var se_RouteMatrixScooterOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    LicensePlate: import_smithy_client._json,
+    MaxSpeed: import_smithy_client.serializeFloat,
+    Occupancy: []
+  });
+}, "se_RouteMatrixScooterOptions");
+var se_RouteMatrixSideOfStreetOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Position: /* @__PURE__ */ __name((_) => se_Position(_, context), "Position"),
+    UseWith: []
+  });
+}, "se_RouteMatrixSideOfStreetOptions");
+var se_RouteMatrixTravelModeOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Car: /* @__PURE__ */ __name((_) => se_RouteMatrixCarOptions(_, context), "Car"),
+    Scooter: /* @__PURE__ */ __name((_) => se_RouteMatrixScooterOptions(_, context), "Scooter"),
+    Truck: /* @__PURE__ */ __name((_) => se_RouteMatrixTruckOptions(_, context), "Truck")
+  });
+}, "se_RouteMatrixTravelModeOptions");
+var se_RouteMatrixTruckOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AxleCount: [],
+    GrossWeight: [],
+    HazardousCargos: import_smithy_client._json,
+    Height: [],
+    KpraLength: [],
+    Length: [],
+    LicensePlate: import_smithy_client._json,
+    MaxSpeed: import_smithy_client.serializeFloat,
+    Occupancy: [],
+    PayloadCapacity: [],
+    Trailer: import_smithy_client._json,
+    TruckType: [],
+    TunnelRestrictionCode: [],
+    WeightPerAxle: [],
+    WeightPerAxleGroup: import_smithy_client._json,
+    Width: []
+  });
+}, "se_RouteMatrixTruckOptions");
+var se_RouteOriginOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AvoidActionsForDistance: [],
+    AvoidUTurns: [],
+    Heading: import_smithy_client.serializeFloat,
+    Matching: import_smithy_client._json,
+    SideOfStreet: /* @__PURE__ */ __name((_) => se_RouteSideOfStreetOptions(_, context), "SideOfStreet")
+  });
+}, "se_RouteOriginOptions");
+var se_RoutePedestrianOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Speed: import_smithy_client.serializeFloat
+  });
+}, "se_RoutePedestrianOptions");
+var se_RouteScooterOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    EngineType: [],
+    LicensePlate: import_smithy_client._json,
+    MaxSpeed: import_smithy_client.serializeFloat,
+    Occupancy: []
+  });
+}, "se_RouteScooterOptions");
+var se_RouteSideOfStreetOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Position: /* @__PURE__ */ __name((_) => se_Position(_, context), "Position"),
+    UseWith: []
+  });
+}, "se_RouteSideOfStreetOptions");
+var se_RouteTravelModeOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Car: /* @__PURE__ */ __name((_) => se_RouteCarOptions(_, context), "Car"),
+    Pedestrian: /* @__PURE__ */ __name((_) => se_RoutePedestrianOptions(_, context), "Pedestrian"),
+    Scooter: /* @__PURE__ */ __name((_) => se_RouteScooterOptions(_, context), "Scooter"),
+    Truck: /* @__PURE__ */ __name((_) => se_RouteTruckOptions(_, context), "Truck")
+  });
+}, "se_RouteTravelModeOptions");
+var se_RouteTruckOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AxleCount: [],
+    EngineType: [],
+    GrossWeight: [],
+    HazardousCargos: import_smithy_client._json,
+    Height: [],
+    HeightAboveFirstAxle: [],
+    KpraLength: [],
+    Length: [],
+    LicensePlate: import_smithy_client._json,
+    MaxSpeed: import_smithy_client.serializeFloat,
+    Occupancy: [],
+    PayloadCapacity: [],
+    TireCount: [],
+    Trailer: import_smithy_client._json,
+    TruckType: [],
+    TunnelRestrictionCode: [],
+    WeightPerAxle: [],
+    WeightPerAxleGroup: import_smithy_client._json,
+    Width: []
+  });
+}, "se_RouteTruckOptions");
+var se_RouteWaypoint = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AvoidActionsForDistance: [],
+    AvoidUTurns: [],
+    Heading: import_smithy_client.serializeFloat,
+    Matching: import_smithy_client._json,
+    PassThrough: [],
+    Position: /* @__PURE__ */ __name((_) => se_Position(_, context), "Position"),
+    SideOfStreet: /* @__PURE__ */ __name((_) => se_RouteSideOfStreetOptions(_, context), "SideOfStreet"),
+    StopDuration: []
+  });
+}, "se_RouteWaypoint");
+var se_RouteWaypointList = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_RouteWaypoint(entry, context);
+  });
+}, "se_RouteWaypointList");
+var se_WaypointOptimizationAvoidanceArea = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Geometry: /* @__PURE__ */ __name((_) => se_WaypointOptimizationAvoidanceAreaGeometry(_, context), "Geometry")
+  });
+}, "se_WaypointOptimizationAvoidanceArea");
+var se_WaypointOptimizationAvoidanceAreaGeometry = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    BoundingBox: /* @__PURE__ */ __name((_) => se_BoundingBox(_, context), "BoundingBox")
+  });
+}, "se_WaypointOptimizationAvoidanceAreaGeometry");
+var se_WaypointOptimizationAvoidanceAreaList = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_WaypointOptimizationAvoidanceArea(entry, context);
+  });
+}, "se_WaypointOptimizationAvoidanceAreaList");
+var se_WaypointOptimizationAvoidanceOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Areas: /* @__PURE__ */ __name((_) => se_WaypointOptimizationAvoidanceAreaList(_, context), "Areas"),
+    CarShuttleTrains: [],
+    ControlledAccessHighways: [],
+    DirtRoads: [],
+    Ferries: [],
+    TollRoads: [],
+    Tunnels: [],
+    UTurns: []
+  });
+}, "se_WaypointOptimizationAvoidanceOptions");
+var se_WaypointOptimizationDestinationOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AccessHours: import_smithy_client._json,
+    AppointmentTime: [],
+    Heading: import_smithy_client.serializeFloat,
+    Id: [],
+    ServiceDuration: [],
+    SideOfStreet: /* @__PURE__ */ __name((_) => se_WaypointOptimizationSideOfStreetOptions(_, context), "SideOfStreet")
+  });
+}, "se_WaypointOptimizationDestinationOptions");
+var se_WaypointOptimizationPedestrianOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Speed: import_smithy_client.serializeFloat
+  });
+}, "se_WaypointOptimizationPedestrianOptions");
+var se_WaypointOptimizationSideOfStreetOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Position: /* @__PURE__ */ __name((_) => se_Position(_, context), "Position"),
+    UseWith: []
+  });
+}, "se_WaypointOptimizationSideOfStreetOptions");
+var se_WaypointOptimizationTravelModeOptions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Pedestrian: /* @__PURE__ */ __name((_) => se_WaypointOptimizationPedestrianOptions(_, context), "Pedestrian"),
+    Truck: import_smithy_client._json
+  });
+}, "se_WaypointOptimizationTravelModeOptions");
+var se_WaypointOptimizationWaypoint = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AccessHours: import_smithy_client._json,
+    AppointmentTime: [],
+    Before: import_smithy_client._json,
+    Heading: import_smithy_client.serializeFloat,
+    Id: [],
+    Position: /* @__PURE__ */ __name((_) => se_Position(_, context), "Position"),
+    ServiceDuration: [],
+    SideOfStreet: /* @__PURE__ */ __name((_) => se_WaypointOptimizationSideOfStreetOptions(_, context), "SideOfStreet")
+  });
+}, "se_WaypointOptimizationWaypoint");
+var se_WaypointOptimizationWaypointList = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_WaypointOptimizationWaypoint(entry, context);
+  });
+}, "se_WaypointOptimizationWaypointList");
+var de_BoundingBox = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return (0, import_smithy_client.limitedParseDouble)(entry);
+  });
+  return retVal;
+}, "de_BoundingBox");
+var de_Circle = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Center: /* @__PURE__ */ __name((_) => de_Position(_, context), "Center"),
+    Radius: import_smithy_client.limitedParseDouble
+  });
+}, "de_Circle");
+var de_Isoline = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Connections: /* @__PURE__ */ __name((_) => de_IsolineConnectionList(_, context), "Connections"),
+    DistanceThreshold: import_smithy_client.expectLong,
+    Geometries: /* @__PURE__ */ __name((_) => de_IsolineShapeGeometryList(_, context), "Geometries"),
+    TimeThreshold: import_smithy_client.expectLong
+  });
+}, "de_Isoline");
+var de_IsolineConnection = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    FromPolygonIndex: import_smithy_client.expectInt32,
+    Geometry: /* @__PURE__ */ __name((_) => de_IsolineConnectionGeometry(_, context), "Geometry"),
+    ToPolygonIndex: import_smithy_client.expectInt32
+  });
+}, "de_IsolineConnection");
+var de_IsolineConnectionGeometry = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LineString: /* @__PURE__ */ __name((_) => de_LineString(_, context), "LineString"),
+    Polyline: import_smithy_client.expectString
+  });
+}, "de_IsolineConnectionGeometry");
+var de_IsolineConnectionList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_IsolineConnection(entry, context);
+  });
+  return retVal;
+}, "de_IsolineConnectionList");
+var de_IsolineList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Isoline(entry, context);
+  });
+  return retVal;
+}, "de_IsolineList");
+var de_IsolineShapeGeometry = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Polygon: /* @__PURE__ */ __name((_) => de_LinearRings(_, context), "Polygon"),
+    PolylinePolygon: import_smithy_client._json
+  });
+}, "de_IsolineShapeGeometry");
+var de_IsolineShapeGeometryList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_IsolineShapeGeometry(entry, context);
+  });
+  return retVal;
+}, "de_IsolineShapeGeometryList");
+var de_LinearRing = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Position(entry, context);
+  });
+  return retVal;
+}, "de_LinearRing");
+var de_LinearRings = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_LinearRing(entry, context);
+  });
+  return retVal;
+}, "de_LinearRings");
+var de_LineString = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Position(entry, context);
+  });
+  return retVal;
+}, "de_LineString");
+var de_Position = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return (0, import_smithy_client.limitedParseDouble)(entry);
+  });
+  return retVal;
+}, "de_Position");
+var de_Position23 = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return (0, import_smithy_client.limitedParseDouble)(entry);
+  });
+  return retVal;
+}, "de_Position23");
+var de_RoadSnapSnappedGeometry = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LineString: /* @__PURE__ */ __name((_) => de_LineString(_, context), "LineString"),
+    Polyline: import_smithy_client.expectString
+  });
+}, "de_RoadSnapSnappedGeometry");
+var de_RoadSnapSnappedTracePoint = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Confidence: import_smithy_client.limitedParseDouble,
+    OriginalPosition: /* @__PURE__ */ __name((_) => de_Position(_, context), "OriginalPosition"),
+    SnappedPosition: /* @__PURE__ */ __name((_) => de_Position(_, context), "SnappedPosition")
+  });
+}, "de_RoadSnapSnappedTracePoint");
+var de_RoadSnapSnappedTracePointList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_RoadSnapSnappedTracePoint(entry, context);
+  });
+  return retVal;
+}, "de_RoadSnapSnappedTracePointList");
+var de_Route = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Legs: /* @__PURE__ */ __name((_) => de_RouteLegList(_, context), "Legs"),
+    MajorRoadLabels: import_smithy_client._json,
+    Summary: /* @__PURE__ */ __name((_) => de_RouteSummary(_, context), "Summary")
+  });
+}, "de_Route");
+var de_RouteContinueHighwayStepDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Intersection: import_smithy_client._json,
+    SteeringDirection: import_smithy_client.expectString,
+    TurnAngle: import_smithy_client.limitedParseDouble,
+    TurnIntensity: import_smithy_client.expectString
+  });
+}, "de_RouteContinueHighwayStepDetails");
+var de_RouteEnterHighwayStepDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Intersection: import_smithy_client._json,
+    SteeringDirection: import_smithy_client.expectString,
+    TurnAngle: import_smithy_client.limitedParseDouble,
+    TurnIntensity: import_smithy_client.expectString
+  });
+}, "de_RouteEnterHighwayStepDetails");
+var de_RouteExitStepDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Intersection: import_smithy_client._json,
+    RelativeExit: import_smithy_client.expectInt32,
+    SteeringDirection: import_smithy_client.expectString,
+    TurnAngle: import_smithy_client.limitedParseDouble,
+    TurnIntensity: import_smithy_client.expectString
+  });
+}, "de_RouteExitStepDetails");
+var de_RouteFerryArrival = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Place: /* @__PURE__ */ __name((_) => de_RouteFerryPlace(_, context), "Place"),
+    Time: import_smithy_client.expectString
+  });
+}, "de_RouteFerryArrival");
+var de_RouteFerryDeparture = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Place: /* @__PURE__ */ __name((_) => de_RouteFerryPlace(_, context), "Place"),
+    Time: import_smithy_client.expectString
+  });
+}, "de_RouteFerryDeparture");
+var de_RouteFerryLegDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AfterTravelSteps: import_smithy_client._json,
+    Arrival: /* @__PURE__ */ __name((_) => de_RouteFerryArrival(_, context), "Arrival"),
+    BeforeTravelSteps: import_smithy_client._json,
+    Departure: /* @__PURE__ */ __name((_) => de_RouteFerryDeparture(_, context), "Departure"),
+    Notices: import_smithy_client._json,
+    PassThroughWaypoints: /* @__PURE__ */ __name((_) => de_RoutePassThroughWaypointList(_, context), "PassThroughWaypoints"),
+    RouteName: import_smithy_client.expectString,
+    Spans: import_smithy_client._json,
+    Summary: import_smithy_client._json,
+    TravelSteps: import_smithy_client._json
+  });
+}, "de_RouteFerryLegDetails");
+var de_RouteFerryPlace = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Name: import_smithy_client.expectString,
+    OriginalPosition: /* @__PURE__ */ __name((_) => de_Position23(_, context), "OriginalPosition"),
+    Position: /* @__PURE__ */ __name((_) => de_Position23(_, context), "Position"),
+    WaypointIndex: import_smithy_client.expectInt32
+  });
+}, "de_RouteFerryPlace");
+var de_RouteKeepStepDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Intersection: import_smithy_client._json,
+    SteeringDirection: import_smithy_client.expectString,
+    TurnAngle: import_smithy_client.limitedParseDouble,
+    TurnIntensity: import_smithy_client.expectString
+  });
+}, "de_RouteKeepStepDetails");
+var de_RouteLeg = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    FerryLegDetails: /* @__PURE__ */ __name((_) => de_RouteFerryLegDetails(_, context), "FerryLegDetails"),
+    Geometry: /* @__PURE__ */ __name((_) => de_RouteLegGeometry(_, context), "Geometry"),
+    Language: import_smithy_client.expectString,
+    PedestrianLegDetails: /* @__PURE__ */ __name((_) => de_RoutePedestrianLegDetails(_, context), "PedestrianLegDetails"),
+    TravelMode: import_smithy_client.expectString,
+    Type: import_smithy_client.expectString,
+    VehicleLegDetails: /* @__PURE__ */ __name((_) => de_RouteVehicleLegDetails(_, context), "VehicleLegDetails")
+  });
+}, "de_RouteLeg");
+var de_RouteLegGeometry = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LineString: /* @__PURE__ */ __name((_) => de_LineString(_, context), "LineString"),
+    Polyline: import_smithy_client.expectString
+  });
+}, "de_RouteLegGeometry");
+var de_RouteLegList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_RouteLeg(entry, context);
+  });
+  return retVal;
+}, "de_RouteLegList");
+var de_RouteList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Route(entry, context);
+  });
+  return retVal;
+}, "de_RouteList");
+var de_RouteMatrixBoundary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Geometry: /* @__PURE__ */ __name((_) => de_RouteMatrixBoundaryGeometry(_, context), "Geometry"),
+    Unbounded: import_smithy_client.expectBoolean
+  });
+}, "de_RouteMatrixBoundary");
+var de_RouteMatrixBoundaryGeometry = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AutoCircle: import_smithy_client._json,
+    BoundingBox: /* @__PURE__ */ __name((_) => de_BoundingBox(_, context), "BoundingBox"),
+    Circle: /* @__PURE__ */ __name((_) => de_Circle(_, context), "Circle"),
+    Polygon: /* @__PURE__ */ __name((_) => de_LinearRings(_, context), "Polygon")
+  });
+}, "de_RouteMatrixBoundaryGeometry");
+var de_RoutePassThroughPlace = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    OriginalPosition: /* @__PURE__ */ __name((_) => de_Position23(_, context), "OriginalPosition"),
+    Position: /* @__PURE__ */ __name((_) => de_Position23(_, context), "Position"),
+    WaypointIndex: import_smithy_client.expectInt32
+  });
+}, "de_RoutePassThroughPlace");
+var de_RoutePassThroughWaypoint = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    GeometryOffset: import_smithy_client.expectInt32,
+    Place: /* @__PURE__ */ __name((_) => de_RoutePassThroughPlace(_, context), "Place")
+  });
+}, "de_RoutePassThroughWaypoint");
+var de_RoutePassThroughWaypointList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_RoutePassThroughWaypoint(entry, context);
+  });
+  return retVal;
+}, "de_RoutePassThroughWaypointList");
+var de_RoutePedestrianArrival = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Place: /* @__PURE__ */ __name((_) => de_RoutePedestrianPlace(_, context), "Place"),
+    Time: import_smithy_client.expectString
+  });
+}, "de_RoutePedestrianArrival");
+var de_RoutePedestrianDeparture = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Place: /* @__PURE__ */ __name((_) => de_RoutePedestrianPlace(_, context), "Place"),
+    Time: import_smithy_client.expectString
+  });
+}, "de_RoutePedestrianDeparture");
+var de_RoutePedestrianLegDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arrival: /* @__PURE__ */ __name((_) => de_RoutePedestrianArrival(_, context), "Arrival"),
+    Departure: /* @__PURE__ */ __name((_) => de_RoutePedestrianDeparture(_, context), "Departure"),
+    Notices: import_smithy_client._json,
+    PassThroughWaypoints: /* @__PURE__ */ __name((_) => de_RoutePassThroughWaypointList(_, context), "PassThroughWaypoints"),
+    Spans: /* @__PURE__ */ __name((_) => de_RoutePedestrianSpanList(_, context), "Spans"),
+    Summary: import_smithy_client._json,
+    TravelSteps: /* @__PURE__ */ __name((_) => de_RoutePedestrianTravelStepList(_, context), "TravelSteps")
+  });
+}, "de_RoutePedestrianLegDetails");
+var de_RoutePedestrianPlace = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Name: import_smithy_client.expectString,
+    OriginalPosition: /* @__PURE__ */ __name((_) => de_Position23(_, context), "OriginalPosition"),
+    Position: /* @__PURE__ */ __name((_) => de_Position23(_, context), "Position"),
+    SideOfStreet: import_smithy_client.expectString,
+    WaypointIndex: import_smithy_client.expectInt32
+  });
+}, "de_RoutePedestrianPlace");
+var de_RoutePedestrianSpan = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    BestCaseDuration: import_smithy_client.expectLong,
+    Country: import_smithy_client.expectString,
+    Distance: import_smithy_client.expectLong,
+    Duration: import_smithy_client.expectLong,
+    DynamicSpeed: /* @__PURE__ */ __name((_) => de_RouteSpanDynamicSpeedDetails(_, context), "DynamicSpeed"),
+    FunctionalClassification: import_smithy_client.expectInt32,
+    GeometryOffset: import_smithy_client.expectInt32,
+    Incidents: import_smithy_client._json,
+    Names: import_smithy_client._json,
+    PedestrianAccess: import_smithy_client._json,
+    Region: import_smithy_client.expectString,
+    RoadAttributes: import_smithy_client._json,
+    RouteNumbers: import_smithy_client._json,
+    SpeedLimit: /* @__PURE__ */ __name((_) => de_RouteSpanSpeedLimitDetails(_, context), "SpeedLimit"),
+    TypicalDuration: import_smithy_client.expectLong
+  });
+}, "de_RoutePedestrianSpan");
+var de_RoutePedestrianSpanList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_RoutePedestrianSpan(entry, context);
+  });
+  return retVal;
+}, "de_RoutePedestrianSpanList");
+var de_RoutePedestrianTravelStep = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ContinueStepDetails: import_smithy_client._json,
+    CurrentRoad: import_smithy_client._json,
+    Distance: import_smithy_client.expectLong,
+    Duration: import_smithy_client.expectLong,
+    ExitNumber: import_smithy_client._json,
+    GeometryOffset: import_smithy_client.expectInt32,
+    Instruction: import_smithy_client.expectString,
+    KeepStepDetails: /* @__PURE__ */ __name((_) => de_RouteKeepStepDetails(_, context), "KeepStepDetails"),
+    NextRoad: import_smithy_client._json,
+    RoundaboutEnterStepDetails: /* @__PURE__ */ __name((_) => de_RouteRoundaboutEnterStepDetails(_, context), "RoundaboutEnterStepDetails"),
+    RoundaboutExitStepDetails: /* @__PURE__ */ __name((_) => de_RouteRoundaboutExitStepDetails(_, context), "RoundaboutExitStepDetails"),
+    RoundaboutPassStepDetails: /* @__PURE__ */ __name((_) => de_RouteRoundaboutPassStepDetails(_, context), "RoundaboutPassStepDetails"),
+    Signpost: import_smithy_client._json,
+    TurnStepDetails: /* @__PURE__ */ __name((_) => de_RouteTurnStepDetails(_, context), "TurnStepDetails"),
+    Type: import_smithy_client.expectString
+  });
+}, "de_RoutePedestrianTravelStep");
+var de_RoutePedestrianTravelStepList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_RoutePedestrianTravelStep(entry, context);
+  });
+  return retVal;
+}, "de_RoutePedestrianTravelStepList");
+var de_RouteRampStepDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Intersection: import_smithy_client._json,
+    SteeringDirection: import_smithy_client.expectString,
+    TurnAngle: import_smithy_client.limitedParseDouble,
+    TurnIntensity: import_smithy_client.expectString
+  });
+}, "de_RouteRampStepDetails");
+var de_RouteRoundaboutEnterStepDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Intersection: import_smithy_client._json,
+    SteeringDirection: import_smithy_client.expectString,
+    TurnAngle: import_smithy_client.limitedParseDouble,
+    TurnIntensity: import_smithy_client.expectString
+  });
+}, "de_RouteRoundaboutEnterStepDetails");
+var de_RouteRoundaboutExitStepDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Intersection: import_smithy_client._json,
+    RelativeExit: import_smithy_client.expectInt32,
+    RoundaboutAngle: import_smithy_client.limitedParseDouble,
+    SteeringDirection: import_smithy_client.expectString
+  });
+}, "de_RouteRoundaboutExitStepDetails");
+var de_RouteRoundaboutPassStepDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Intersection: import_smithy_client._json,
+    SteeringDirection: import_smithy_client.expectString,
+    TurnAngle: import_smithy_client.limitedParseDouble,
+    TurnIntensity: import_smithy_client.expectString
+  });
+}, "de_RouteRoundaboutPassStepDetails");
+var de_RouteSpanDynamicSpeedDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    BestCaseSpeed: import_smithy_client.limitedParseDouble,
+    TurnDuration: import_smithy_client.expectLong,
+    TypicalSpeed: import_smithy_client.limitedParseDouble
+  });
+}, "de_RouteSpanDynamicSpeedDetails");
+var de_RouteSpanSpeedLimitDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    MaxSpeed: import_smithy_client.limitedParseDouble,
+    Unlimited: import_smithy_client.expectBoolean
+  });
+}, "de_RouteSpanSpeedLimitDetails");
+var de_RouteSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Distance: import_smithy_client.expectLong,
+    Duration: import_smithy_client.expectLong,
+    Tolls: /* @__PURE__ */ __name((_) => de_RouteTollSummary(_, context), "Tolls")
+  });
+}, "de_RouteSummary");
+var de_RouteToll = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Country: import_smithy_client.expectString,
+    PaymentSites: /* @__PURE__ */ __name((_) => de_RouteTollPaymentSiteList(_, context), "PaymentSites"),
+    Rates: /* @__PURE__ */ __name((_) => de_RouteTollRateList(_, context), "Rates"),
+    Systems: import_smithy_client._json
+  });
+}, "de_RouteToll");
+var de_RouteTollList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_RouteToll(entry, context);
+  });
+  return retVal;
+}, "de_RouteTollList");
+var de_RouteTollPaymentSite = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Name: import_smithy_client.expectString,
+    Position: /* @__PURE__ */ __name((_) => de_Position23(_, context), "Position")
+  });
+}, "de_RouteTollPaymentSite");
+var de_RouteTollPaymentSiteList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_RouteTollPaymentSite(entry, context);
+  });
+  return retVal;
+}, "de_RouteTollPaymentSiteList");
+var de_RouteTollPrice = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Currency: import_smithy_client.expectString,
+    Estimate: import_smithy_client.expectBoolean,
+    PerDuration: import_smithy_client.expectLong,
+    Range: import_smithy_client.expectBoolean,
+    RangeValue: /* @__PURE__ */ __name((_) => de_RouteTollPriceValueRange(_, context), "RangeValue"),
+    Value: import_smithy_client.limitedParseDouble
+  });
+}, "de_RouteTollPrice");
+var de_RouteTollPriceSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Currency: import_smithy_client.expectString,
+    Estimate: import_smithy_client.expectBoolean,
+    Range: import_smithy_client.expectBoolean,
+    RangeValue: /* @__PURE__ */ __name((_) => de_RouteTollPriceValueRange(_, context), "RangeValue"),
+    Value: import_smithy_client.limitedParseDouble
+  });
+}, "de_RouteTollPriceSummary");
+var de_RouteTollPriceValueRange = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Max: import_smithy_client.limitedParseDouble,
+    Min: import_smithy_client.limitedParseDouble
+  });
+}, "de_RouteTollPriceValueRange");
+var de_RouteTollRate = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ApplicableTimes: import_smithy_client.expectString,
+    ConvertedPrice: /* @__PURE__ */ __name((_) => de_RouteTollPrice(_, context), "ConvertedPrice"),
+    Id: import_smithy_client.expectString,
+    LocalPrice: /* @__PURE__ */ __name((_) => de_RouteTollPrice(_, context), "LocalPrice"),
+    Name: import_smithy_client.expectString,
+    Pass: import_smithy_client._json,
+    PaymentMethods: import_smithy_client._json,
+    Transponders: import_smithy_client._json
+  });
+}, "de_RouteTollRate");
+var de_RouteTollRateList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_RouteTollRate(entry, context);
+  });
+  return retVal;
+}, "de_RouteTollRateList");
+var de_RouteTollSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Total: /* @__PURE__ */ __name((_) => de_RouteTollPriceSummary(_, context), "Total")
+  });
+}, "de_RouteTollSummary");
+var de_RouteTurnStepDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Intersection: import_smithy_client._json,
+    SteeringDirection: import_smithy_client.expectString,
+    TurnAngle: import_smithy_client.limitedParseDouble,
+    TurnIntensity: import_smithy_client.expectString
+  });
+}, "de_RouteTurnStepDetails");
+var de_RouteUTurnStepDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Intersection: import_smithy_client._json,
+    SteeringDirection: import_smithy_client.expectString,
+    TurnAngle: import_smithy_client.limitedParseDouble,
+    TurnIntensity: import_smithy_client.expectString
+  });
+}, "de_RouteUTurnStepDetails");
+var de_RouteVehicleArrival = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Place: /* @__PURE__ */ __name((_) => de_RouteVehiclePlace(_, context), "Place"),
+    Time: import_smithy_client.expectString
+  });
+}, "de_RouteVehicleArrival");
+var de_RouteVehicleDeparture = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Place: /* @__PURE__ */ __name((_) => de_RouteVehiclePlace(_, context), "Place"),
+    Time: import_smithy_client.expectString
+  });
+}, "de_RouteVehicleDeparture");
+var de_RouteVehicleLegDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arrival: /* @__PURE__ */ __name((_) => de_RouteVehicleArrival(_, context), "Arrival"),
+    Departure: /* @__PURE__ */ __name((_) => de_RouteVehicleDeparture(_, context), "Departure"),
+    Incidents: import_smithy_client._json,
+    Notices: import_smithy_client._json,
+    PassThroughWaypoints: /* @__PURE__ */ __name((_) => de_RoutePassThroughWaypointList(_, context), "PassThroughWaypoints"),
+    Spans: /* @__PURE__ */ __name((_) => de_RouteVehicleSpanList(_, context), "Spans"),
+    Summary: import_smithy_client._json,
+    TollSystems: import_smithy_client._json,
+    Tolls: /* @__PURE__ */ __name((_) => de_RouteTollList(_, context), "Tolls"),
+    TravelSteps: /* @__PURE__ */ __name((_) => de_RouteVehicleTravelStepList(_, context), "TravelSteps"),
+    TruckRoadTypes: import_smithy_client._json,
+    Zones: import_smithy_client._json
+  });
+}, "de_RouteVehicleLegDetails");
+var de_RouteVehiclePlace = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Name: import_smithy_client.expectString,
+    OriginalPosition: /* @__PURE__ */ __name((_) => de_Position23(_, context), "OriginalPosition"),
+    Position: /* @__PURE__ */ __name((_) => de_Position23(_, context), "Position"),
+    SideOfStreet: import_smithy_client.expectString,
+    WaypointIndex: import_smithy_client.expectInt32
+  });
+}, "de_RouteVehiclePlace");
+var de_RouteVehicleSpan = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    BestCaseDuration: import_smithy_client.expectLong,
+    CarAccess: import_smithy_client._json,
+    Country: import_smithy_client.expectString,
+    Distance: import_smithy_client.expectLong,
+    Duration: import_smithy_client.expectLong,
+    DynamicSpeed: /* @__PURE__ */ __name((_) => de_RouteSpanDynamicSpeedDetails(_, context), "DynamicSpeed"),
+    FunctionalClassification: import_smithy_client.expectInt32,
+    Gate: import_smithy_client.expectString,
+    GeometryOffset: import_smithy_client.expectInt32,
+    Incidents: import_smithy_client._json,
+    Names: import_smithy_client._json,
+    Notices: import_smithy_client._json,
+    RailwayCrossing: import_smithy_client.expectString,
+    Region: import_smithy_client.expectString,
+    RoadAttributes: import_smithy_client._json,
+    RouteNumbers: import_smithy_client._json,
+    ScooterAccess: import_smithy_client._json,
+    SpeedLimit: /* @__PURE__ */ __name((_) => de_RouteSpanSpeedLimitDetails(_, context), "SpeedLimit"),
+    TollSystems: import_smithy_client._json,
+    TruckAccess: import_smithy_client._json,
+    TruckRoadTypes: import_smithy_client._json,
+    TypicalDuration: import_smithy_client.expectLong,
+    Zones: import_smithy_client._json
+  });
+}, "de_RouteVehicleSpan");
+var de_RouteVehicleSpanList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_RouteVehicleSpan(entry, context);
+  });
+  return retVal;
+}, "de_RouteVehicleSpanList");
+var de_RouteVehicleTravelStep = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ContinueHighwayStepDetails: /* @__PURE__ */ __name((_) => de_RouteContinueHighwayStepDetails(_, context), "ContinueHighwayStepDetails"),
+    ContinueStepDetails: import_smithy_client._json,
+    CurrentRoad: import_smithy_client._json,
+    Distance: import_smithy_client.expectLong,
+    Duration: import_smithy_client.expectLong,
+    EnterHighwayStepDetails: /* @__PURE__ */ __name((_) => de_RouteEnterHighwayStepDetails(_, context), "EnterHighwayStepDetails"),
+    ExitNumber: import_smithy_client._json,
+    ExitStepDetails: /* @__PURE__ */ __name((_) => de_RouteExitStepDetails(_, context), "ExitStepDetails"),
+    GeometryOffset: import_smithy_client.expectInt32,
+    Instruction: import_smithy_client.expectString,
+    KeepStepDetails: /* @__PURE__ */ __name((_) => de_RouteKeepStepDetails(_, context), "KeepStepDetails"),
+    NextRoad: import_smithy_client._json,
+    RampStepDetails: /* @__PURE__ */ __name((_) => de_RouteRampStepDetails(_, context), "RampStepDetails"),
+    RoundaboutEnterStepDetails: /* @__PURE__ */ __name((_) => de_RouteRoundaboutEnterStepDetails(_, context), "RoundaboutEnterStepDetails"),
+    RoundaboutExitStepDetails: /* @__PURE__ */ __name((_) => de_RouteRoundaboutExitStepDetails(_, context), "RoundaboutExitStepDetails"),
+    RoundaboutPassStepDetails: /* @__PURE__ */ __name((_) => de_RouteRoundaboutPassStepDetails(_, context), "RoundaboutPassStepDetails"),
+    Signpost: import_smithy_client._json,
+    TurnStepDetails: /* @__PURE__ */ __name((_) => de_RouteTurnStepDetails(_, context), "TurnStepDetails"),
+    Type: import_smithy_client.expectString,
+    UTurnStepDetails: /* @__PURE__ */ __name((_) => de_RouteUTurnStepDetails(_, context), "UTurnStepDetails")
+  });
+}, "de_RouteVehicleTravelStep");
+var de_RouteVehicleTravelStepList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_RouteVehicleTravelStep(entry, context);
+  });
+  return retVal;
+}, "de_RouteVehicleTravelStepList");
+var de_ValidationExceptionField = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Message: [, import_smithy_client.expectString, `message`],
+    Name: [, import_smithy_client.expectString, `name`]
+  });
+}, "de_ValidationExceptionField");
+var de_ValidationExceptionFieldList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ValidationExceptionField(entry, context);
+  });
+  return retVal;
+}, "de_ValidationExceptionFieldList");
+var de_WaypointOptimizationImpedingWaypoint = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    FailedConstraints: import_smithy_client._json,
+    Id: import_smithy_client.expectString,
+    Position: /* @__PURE__ */ __name((_) => de_Position(_, context), "Position")
+  });
+}, "de_WaypointOptimizationImpedingWaypoint");
+var de_WaypointOptimizationImpedingWaypointList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_WaypointOptimizationImpedingWaypoint(entry, context);
+  });
+  return retVal;
+}, "de_WaypointOptimizationImpedingWaypointList");
+var de_WaypointOptimizationOptimizedWaypoint = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ArrivalTime: import_smithy_client.expectString,
+    ClusterIndex: import_smithy_client.expectInt32,
+    DepartureTime: import_smithy_client.expectString,
+    Id: import_smithy_client.expectString,
+    Position: /* @__PURE__ */ __name((_) => de_Position(_, context), "Position")
+  });
+}, "de_WaypointOptimizationOptimizedWaypoint");
+var de_WaypointOptimizationOptimizedWaypointList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_WaypointOptimizationOptimizedWaypoint(entry, context);
+  });
+  return retVal;
+}, "de_WaypointOptimizationOptimizedWaypointList");
+var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
+  httpStatusCode: output.statusCode,
+  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+  extendedRequestId: output.headers["x-amz-id-2"],
+  cfId: output.headers["x-amz-cf-id"]
+}), "deserializeMetadata");
+var _K = "Key";
+var _PB = "PricingBucket";
+var _k = "key";
+var _xagpb = "x-amz-geo-pricing-bucket";
+
+// src/commands/CalculateIsolinesCommand.ts
+var CalculateIsolinesCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("RoutesService", "CalculateIsolines", {}).n("GeoRoutesClient", "CalculateIsolinesCommand").f(CalculateIsolinesRequestFilterSensitiveLog, CalculateIsolinesResponseFilterSensitiveLog).ser(se_CalculateIsolinesCommand).de(de_CalculateIsolinesCommand).build() {
+  static {
+    __name(this, "CalculateIsolinesCommand");
+  }
+};
+
+// src/commands/CalculateRouteMatrixCommand.ts
+
+
+
+var CalculateRouteMatrixCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("RoutesService", "CalculateRouteMatrix", {}).n("GeoRoutesClient", "CalculateRouteMatrixCommand").f(CalculateRouteMatrixRequestFilterSensitiveLog, CalculateRouteMatrixResponseFilterSensitiveLog).ser(se_CalculateRouteMatrixCommand).de(de_CalculateRouteMatrixCommand).build() {
+  static {
+    __name(this, "CalculateRouteMatrixCommand");
+  }
+};
+
+// src/commands/CalculateRoutesCommand.ts
+
+
+
+var CalculateRoutesCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("RoutesService", "CalculateRoutes", {}).n("GeoRoutesClient", "CalculateRoutesCommand").f(CalculateRoutesRequestFilterSensitiveLog, CalculateRoutesResponseFilterSensitiveLog).ser(se_CalculateRoutesCommand).de(de_CalculateRoutesCommand).build() {
+  static {
+    __name(this, "CalculateRoutesCommand");
+  }
+};
+
+// src/commands/OptimizeWaypointsCommand.ts
+
+
+
+var OptimizeWaypointsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("RoutesService", "OptimizeWaypoints", {}).n("GeoRoutesClient", "OptimizeWaypointsCommand").f(OptimizeWaypointsRequestFilterSensitiveLog, OptimizeWaypointsResponseFilterSensitiveLog).ser(se_OptimizeWaypointsCommand).de(de_OptimizeWaypointsCommand).build() {
+  static {
+    __name(this, "OptimizeWaypointsCommand");
+  }
+};
+
+// src/commands/SnapToRoadsCommand.ts
+
+
+
+var SnapToRoadsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("RoutesService", "SnapToRoads", {}).n("GeoRoutesClient", "SnapToRoadsCommand").f(SnapToRoadsRequestFilterSensitiveLog, SnapToRoadsResponseFilterSensitiveLog).ser(se_SnapToRoadsCommand).de(de_SnapToRoadsCommand).build() {
+  static {
+    __name(this, "SnapToRoadsCommand");
+  }
+};
+
+// src/GeoRoutes.ts
+var commands = {
+  CalculateIsolinesCommand,
+  CalculateRouteMatrixCommand,
+  CalculateRoutesCommand,
+  OptimizeWaypointsCommand,
+  SnapToRoadsCommand
+};
+var GeoRoutes = class extends GeoRoutesClient {
+  static {
+    __name(this, "GeoRoutes");
+  }
+};
+(0, import_smithy_client.createAggregatedClient)(commands, GeoRoutes);
+// Annotate the CommonJS export names for ESM import in node:
+
+0 && (module.exports = {
+  GeoRoutesServiceException,
+  __Client,
+  GeoRoutesClient,
+  GeoRoutes,
+  $Command,
+  CalculateIsolinesCommand,
+  CalculateRouteMatrixCommand,
+  CalculateRoutesCommand,
+  OptimizeWaypointsCommand,
+  SnapToRoadsCommand,
+  AccessDeniedException,
+  IsolineZoneCategory,
+  MatchingStrategy,
+  SideOfStreetMatchingStrategy,
+  GeometryFormat,
+  IsolineOptimizationObjective,
+  RoutingObjective,
+  TrafficUsage,
+  IsolineTravelMode,
+  IsolineEngineType,
+  IsolineHazardousCargoType,
+  IsolineTruckType,
+  InternalServerException,
+  ThrottlingException,
+  ValidationExceptionReason,
+  ValidationException,
+  RouteMatrixZoneCategory,
+  RouteMatrixTravelMode,
+  RouteMatrixHazardousCargoType,
+  RouteMatrixTruckType,
+  RouteMatrixErrorCode,
+  RouteZoneCategory,
+  MeasurementSystem,
+  RouteLegAdditionalFeature,
+  RouteSpanAdditionalFeature,
+  RouteTollVehicleCategory,
+  RouteTravelMode,
+  RouteEngineType,
+  RouteHazardousCargoType,
+  RouteTruckType,
+  RouteTravelStepType,
+  RouteResponseNoticeCode,
+  RouteNoticeImpact,
+  RouteFerryAfterTravelStepType,
+  RouteFerryBeforeTravelStepType,
+  RouteFerryNoticeCode,
+  RouteFerryTravelStepType,
+  RouteSideOfStreet,
+  RoutePedestrianNoticeCode,
+  RouteSpanPedestrianAccessAttribute,
+  RouteSpanRoadAttribute,
+  RouteDirection,
+  RouteRoadType,
+  RouteSteeringDirection,
+  RouteTurnIntensity,
+  RoutePedestrianTravelStepType,
+  RouteLegTravelMode,
+  RouteLegType,
+  RouteVehicleIncidentSeverity,
+  RouteVehicleIncidentType,
+  RouteVehicleNoticeCode,
+  RouteWeightConstraintType,
+  RouteSpanCarAccessAttribute,
+  RouteSpanGateAttribute,
+  RouteSpanRailwayCrossingAttribute,
+  RouteSpanScooterAccessAttribute,
+  RouteSpanTruckAccessAttribute,
+  RouteTollPassValidityPeriodType,
+  RouteTollPaymentMethod,
+  RouteVehicleTravelStepType,
+  DayOfWeek,
+  WaypointOptimizationClusteringAlgorithm,
+  WaypointOptimizationServiceTimeTreatment,
+  WaypointOptimizationSequencingObjective,
+  WaypointOptimizationTravelMode,
+  WaypointOptimizationHazardousCargoType,
+  WaypointOptimizationTruckType,
+  WaypointOptimizationConstraint,
+  RoadSnapTravelMode,
+  RoadSnapHazardousCargoType,
+  RoadSnapNoticeCode,
+  IsolineAllowOptionsFilterSensitiveLog,
+  CorridorFilterSensitiveLog,
+  PolylineCorridorFilterSensitiveLog,
+  IsolineAvoidanceAreaGeometryFilterSensitiveLog,
+  IsolineAvoidanceAreaFilterSensitiveLog,
+  IsolineAvoidanceOptionsFilterSensitiveLog,
+  IsolineMatchingOptionsFilterSensitiveLog,
+  IsolineSideOfStreetOptionsFilterSensitiveLog,
+  IsolineDestinationOptionsFilterSensitiveLog,
+  IsolineGranularityOptionsFilterSensitiveLog,
+  IsolineOriginOptionsFilterSensitiveLog,
+  IsolineThresholdsFilterSensitiveLog,
+  IsolineTrafficOptionsFilterSensitiveLog,
+  IsolineVehicleLicensePlateFilterSensitiveLog,
+  IsolineCarOptionsFilterSensitiveLog,
+  IsolineScooterOptionsFilterSensitiveLog,
+  IsolineTrailerOptionsFilterSensitiveLog,
+  WeightPerAxleGroupFilterSensitiveLog,
+  IsolineTruckOptionsFilterSensitiveLog,
+  IsolineTravelModeOptionsFilterSensitiveLog,
+  CalculateIsolinesRequestFilterSensitiveLog,
+  IsolineConnectionGeometryFilterSensitiveLog,
+  IsolineConnectionFilterSensitiveLog,
+  IsolineShapeGeometryFilterSensitiveLog,
+  IsolineFilterSensitiveLog,
+  CalculateIsolinesResponseFilterSensitiveLog,
+  RouteMatrixAllowOptionsFilterSensitiveLog,
+  RouteMatrixAvoidanceAreaGeometryFilterSensitiveLog,
+  RouteMatrixAvoidanceAreaFilterSensitiveLog,
+  RouteMatrixAvoidanceZoneCategoryFilterSensitiveLog,
+  RouteMatrixAvoidanceOptionsFilterSensitiveLog,
+  RouteMatrixMatchingOptionsFilterSensitiveLog,
+  RouteMatrixSideOfStreetOptionsFilterSensitiveLog,
+  RouteMatrixDestinationOptionsFilterSensitiveLog,
+  RouteMatrixDestinationFilterSensitiveLog,
+  RouteMatrixExclusionOptionsFilterSensitiveLog,
+  RouteMatrixOriginOptionsFilterSensitiveLog,
+  RouteMatrixOriginFilterSensitiveLog,
+  RouteMatrixAutoCircleFilterSensitiveLog,
+  CircleFilterSensitiveLog,
+  RouteMatrixBoundaryGeometryFilterSensitiveLog,
+  RouteMatrixBoundaryFilterSensitiveLog,
+  RouteMatrixTrafficOptionsFilterSensitiveLog,
+  RouteMatrixVehicleLicensePlateFilterSensitiveLog,
+  RouteMatrixCarOptionsFilterSensitiveLog,
+  RouteMatrixScooterOptionsFilterSensitiveLog,
+  RouteMatrixTrailerOptionsFilterSensitiveLog,
+  RouteMatrixTruckOptionsFilterSensitiveLog,
+  RouteMatrixTravelModeOptionsFilterSensitiveLog,
+  CalculateRouteMatrixRequestFilterSensitiveLog,
+  RouteMatrixEntryFilterSensitiveLog,
+  CalculateRouteMatrixResponseFilterSensitiveLog,
+  RouteAllowOptionsFilterSensitiveLog,
+  RouteAvoidanceAreaGeometryFilterSensitiveLog,
+  RouteAvoidanceAreaFilterSensitiveLog,
+  RouteAvoidanceZoneCategoryFilterSensitiveLog,
+  RouteAvoidanceOptionsFilterSensitiveLog,
+  RouteMatchingOptionsFilterSensitiveLog,
+  RouteSideOfStreetOptionsFilterSensitiveLog,
+  RouteDestinationOptionsFilterSensitiveLog,
+  RouteDriverScheduleIntervalFilterSensitiveLog,
+  RouteDriverOptionsFilterSensitiveLog,
+  RouteExclusionOptionsFilterSensitiveLog,
+  RouteOriginOptionsFilterSensitiveLog,
+  RouteEmissionTypeFilterSensitiveLog,
+  RouteTollOptionsFilterSensitiveLog,
+  RouteTrafficOptionsFilterSensitiveLog,
+  RouteVehicleLicensePlateFilterSensitiveLog,
+  RouteCarOptionsFilterSensitiveLog,
+  RoutePedestrianOptionsFilterSensitiveLog,
+  RouteScooterOptionsFilterSensitiveLog,
+  RouteTrailerOptionsFilterSensitiveLog,
+  RouteTruckOptionsFilterSensitiveLog,
+  RouteTravelModeOptionsFilterSensitiveLog,
+  RouteWaypointFilterSensitiveLog,
+  CalculateRoutesRequestFilterSensitiveLog,
+  RouteFerryAfterTravelStepFilterSensitiveLog,
+  RouteFerryPlaceFilterSensitiveLog,
+  RouteFerryArrivalFilterSensitiveLog,
+  RouteFerryBeforeTravelStepFilterSensitiveLog,
+  RouteFerryDepartureFilterSensitiveLog,
+  RoutePassThroughPlaceFilterSensitiveLog,
+  RoutePassThroughWaypointFilterSensitiveLog,
+  LocalizedStringFilterSensitiveLog,
+  RouteFerrySpanFilterSensitiveLog,
+  RouteFerryOverviewSummaryFilterSensitiveLog,
+  RouteFerryTravelOnlySummaryFilterSensitiveLog,
+  RouteFerrySummaryFilterSensitiveLog,
+  RouteFerryTravelStepFilterSensitiveLog,
+  RouteFerryLegDetailsFilterSensitiveLog,
+  RouteLegGeometryFilterSensitiveLog,
+  RoutePedestrianPlaceFilterSensitiveLog,
+  RoutePedestrianArrivalFilterSensitiveLog,
+  RoutePedestrianDepartureFilterSensitiveLog,
+  RouteSpanDynamicSpeedDetailsFilterSensitiveLog,
+  RouteNumberFilterSensitiveLog,
+  RouteSpanSpeedLimitDetailsFilterSensitiveLog,
+  RoutePedestrianSpanFilterSensitiveLog,
+  RoutePedestrianOverviewSummaryFilterSensitiveLog,
+  RoutePedestrianTravelOnlySummaryFilterSensitiveLog,
+  RoutePedestrianSummaryFilterSensitiveLog,
+  RouteContinueStepDetailsFilterSensitiveLog,
+  RouteRoadFilterSensitiveLog,
+  RouteKeepStepDetailsFilterSensitiveLog,
+  RouteRoundaboutEnterStepDetailsFilterSensitiveLog,
+  RouteRoundaboutExitStepDetailsFilterSensitiveLog,
+  RouteRoundaboutPassStepDetailsFilterSensitiveLog,
+  RouteSignpostLabelFilterSensitiveLog,
+  RouteSignpostFilterSensitiveLog,
+  RouteTurnStepDetailsFilterSensitiveLog,
+  RoutePedestrianTravelStepFilterSensitiveLog,
+  RoutePedestrianLegDetailsFilterSensitiveLog,
+  RouteVehiclePlaceFilterSensitiveLog,
+  RouteVehicleArrivalFilterSensitiveLog,
+  RouteVehicleDepartureFilterSensitiveLog,
+  RouteVehicleIncidentFilterSensitiveLog,
+  RouteWeightConstraintFilterSensitiveLog,
+  RouteViolatedConstraintsFilterSensitiveLog,
+  RouteVehicleNoticeDetailFilterSensitiveLog,
+  RouteVehicleNoticeFilterSensitiveLog,
+  RouteVehicleSpanFilterSensitiveLog,
+  RouteVehicleOverviewSummaryFilterSensitiveLog,
+  RouteVehicleTravelOnlySummaryFilterSensitiveLog,
+  RouteVehicleSummaryFilterSensitiveLog,
+  RouteTollPaymentSiteFilterSensitiveLog,
+  RouteTollPriceValueRangeFilterSensitiveLog,
+  RouteTollPriceFilterSensitiveLog,
+  RouteTollPassValidityPeriodFilterSensitiveLog,
+  RouteTollPassFilterSensitiveLog,
+  RouteTransponderFilterSensitiveLog,
+  RouteTollRateFilterSensitiveLog,
+  RouteTollFilterSensitiveLog,
+  RouteTollSystemFilterSensitiveLog,
+  RouteContinueHighwayStepDetailsFilterSensitiveLog,
+  RouteEnterHighwayStepDetailsFilterSensitiveLog,
+  RouteExitStepDetailsFilterSensitiveLog,
+  RouteRampStepDetailsFilterSensitiveLog,
+  RouteUTurnStepDetailsFilterSensitiveLog,
+  RouteVehicleTravelStepFilterSensitiveLog,
+  RouteZoneFilterSensitiveLog,
+  RouteVehicleLegDetailsFilterSensitiveLog,
+  RouteLegFilterSensitiveLog,
+  RouteMajorRoadLabelFilterSensitiveLog,
+  RouteTollPriceSummaryFilterSensitiveLog,
+  RouteTollSummaryFilterSensitiveLog,
+  RouteSummaryFilterSensitiveLog,
+  RouteFilterSensitiveLog,
+  CalculateRoutesResponseFilterSensitiveLog,
+  WaypointOptimizationAvoidanceAreaGeometryFilterSensitiveLog,
+  WaypointOptimizationAvoidanceAreaFilterSensitiveLog,
+  WaypointOptimizationAvoidanceOptionsFilterSensitiveLog,
+  WaypointOptimizationDrivingDistanceOptionsFilterSensitiveLog,
+  WaypointOptimizationClusteringOptionsFilterSensitiveLog,
+  WaypointOptimizationAccessHoursEntryFilterSensitiveLog,
+  WaypointOptimizationAccessHoursFilterSensitiveLog,
+  WaypointOptimizationSideOfStreetOptionsFilterSensitiveLog,
+  WaypointOptimizationDestinationOptionsFilterSensitiveLog,
+  WaypointOptimizationRestCycleDurationsFilterSensitiveLog,
+  WaypointOptimizationRestCyclesFilterSensitiveLog,
+  WaypointOptimizationRestProfileFilterSensitiveLog,
+  WaypointOptimizationDriverOptionsFilterSensitiveLog,
+  WaypointOptimizationExclusionOptionsFilterSensitiveLog,
+  WaypointOptimizationPedestrianOptionsFilterSensitiveLog,
+  WaypointOptimizationTrailerOptionsFilterSensitiveLog,
+  WaypointOptimizationTruckOptionsFilterSensitiveLog,
+  WaypointOptimizationTravelModeOptionsFilterSensitiveLog,
+  WaypointOptimizationWaypointFilterSensitiveLog,
+  OptimizeWaypointsRequestFilterSensitiveLog,
+  WaypointOptimizationConnectionFilterSensitiveLog,
+  WaypointOptimizationFailedConstraintFilterSensitiveLog,
+  WaypointOptimizationImpedingWaypointFilterSensitiveLog,
+  WaypointOptimizationOptimizedWaypointFilterSensitiveLog,
+  WaypointOptimizationTimeBreakdownFilterSensitiveLog,
+  OptimizeWaypointsResponseFilterSensitiveLog,
+  RoadSnapTracePointFilterSensitiveLog,
+  RoadSnapTrailerOptionsFilterSensitiveLog,
+  RoadSnapTruckOptionsFilterSensitiveLog,
+  RoadSnapTravelModeOptionsFilterSensitiveLog,
+  SnapToRoadsRequestFilterSensitiveLog,
+  RoadSnapNoticeFilterSensitiveLog,
+  RoadSnapSnappedGeometryFilterSensitiveLog,
+  RoadSnapSnappedTracePointFilterSensitiveLog,
+  SnapToRoadsResponseFilterSensitiveLog
+});
+