@aws-sdk/client-geo-routes 3.683.0

package/dist-es/models/models_0.js

@@ -0,0 +1,927 @@
+import { SENSITIVE_STRING } from "@smithy/smithy-client";
+import { GeoRoutesServiceException as __BaseException } from "./GeoRoutesServiceException";
+export class AccessDeniedException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "AccessDeniedException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "AccessDeniedException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, AccessDeniedException.prototype);
+        this.Message = opts.Message;
+    }
+}
+export const IsolineZoneCategory = {
+    CONGESTION_PRICING: "CongestionPricing",
+    ENVIRONMENTAL: "Environmental",
+    VIGNETTE: "Vignette",
+};
+export const MatchingStrategy = {
+    MATCH_ANY: "MatchAny",
+    MATCH_MOST_SIGNIFICANT_ROAD: "MatchMostSignificantRoad",
+};
+export const SideOfStreetMatchingStrategy = {
+    ANY_STREET: "AnyStreet",
+    DIVIDED_STREET_ONLY: "DividedStreetOnly",
+};
+export const GeometryFormat = {
+    FLEXIBLE_POLYLINE: "FlexiblePolyline",
+    SIMPLE: "Simple",
+};
+export const IsolineOptimizationObjective = {
+    ACCURATE_CALCULATION: "AccurateCalculation",
+    BALANCED_CALCULATION: "BalancedCalculation",
+    FAST_CALCULATION: "FastCalculation",
+};
+export const RoutingObjective = {
+    FASTEST_ROUTE: "FastestRoute",
+    SHORTEST_ROUTE: "ShortestRoute",
+};
+export const TrafficUsage = {
+    IGNORE_TRAFFIC_DATA: "IgnoreTrafficData",
+    USE_TRAFFIC_DATA: "UseTrafficData",
+};
+export const IsolineTravelMode = {
+    CAR: "Car",
+    PEDESTRIAN: "Pedestrian",
+    SCOOTER: "Scooter",
+    TRUCK: "Truck",
+};
+export const IsolineEngineType = {
+    ELECTRIC: "Electric",
+    INTERNAL_COMBUSTION: "InternalCombustion",
+    PLUGIN_HYBRID: "PluginHybrid",
+};
+export const 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",
+};
+export const IsolineTruckType = {
+    LIGHT_TRUCK: "LightTruck",
+    STRAIGHT_TRUCK: "StraightTruck",
+    TRACTOR: "Tractor",
+};
+export class InternalServerException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "InternalServerException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "InternalServerException";
+        this.$fault = "server";
+        this.$retryable = {};
+        Object.setPrototypeOf(this, InternalServerException.prototype);
+        this.Message = opts.Message;
+    }
+}
+export class ThrottlingException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ThrottlingException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ThrottlingException";
+        this.$fault = "client";
+        this.$retryable = {};
+        Object.setPrototypeOf(this, ThrottlingException.prototype);
+        this.Message = opts.Message;
+    }
+}
+export const ValidationExceptionReason = {
+    CANNOT_PARSE: "CannotParse",
+    FIELD_VALIDATION_FAILED: "FieldValidationFailed",
+    MISSING: "Missing",
+    OTHER: "Other",
+    UNKNOWN_FIELD: "UnknownField",
+    UNKNOWN_OPERATION: "UnknownOperation",
+};
+export class ValidationException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ValidationException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ValidationException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ValidationException.prototype);
+        this.Message = opts.Message;
+        this.Reason = opts.Reason;
+        this.FieldList = opts.FieldList;
+    }
+}
+export const RouteMatrixZoneCategory = {
+    CONGESTION_PRICING: "CongestionPricing",
+    ENVIRONMENTAL: "Environmental",
+    VIGNETTE: "Vignette",
+};
+export const RouteMatrixTravelMode = {
+    CAR: "Car",
+    PEDESTRIAN: "Pedestrian",
+    SCOOTER: "Scooter",
+    TRUCK: "Truck",
+};
+export const 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",
+};
+export const RouteMatrixTruckType = {
+    LIGHT_TRUCK: "LightTruck",
+    STRAIGHT_TRUCK: "StraightTruck",
+    TRACTOR: "Tractor",
+};
+export const 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",
+};
+export const RouteZoneCategory = {
+    CONGESTION_PRICING: "CongestionPricing",
+    ENVIRONMENTAL: "Environmental",
+    VIGNETTE: "Vignette",
+};
+export const MeasurementSystem = {
+    IMPERIAL: "Imperial",
+    METRIC: "Metric",
+};
+export const 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",
+};
+export const 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",
+};
+export const RouteTollVehicleCategory = {
+    MINIBUS: "Minibus",
+};
+export const RouteTravelMode = {
+    CAR: "Car",
+    PEDESTRIAN: "Pedestrian",
+    SCOOTER: "Scooter",
+    TRUCK: "Truck",
+};
+export const RouteEngineType = {
+    ELECTRIC: "Electric",
+    INTERNAL_COMBUSTION: "InternalCombustion",
+    PLUGIN_HYBRID: "PluginHybrid",
+};
+export const 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",
+};
+export const RouteTruckType = {
+    LIGHT_TRUCK: "LightTruck",
+    STRAIGHT_TRUCK: "StraightTruck",
+    TRACTOR: "Tractor",
+};
+export const RouteTravelStepType = {
+    DEFAULT: "Default",
+    TURN_BY_TURN: "TurnByTurn",
+};
+export const RouteResponseNoticeCode = {
+    MAIN_LANGUAGE_NOT_FOUND: "MainLanguageNotFound",
+    OTHER: "Other",
+    TRAVEL_TIME_EXCEEDS_DRIVER_WORK_HOURS: "TravelTimeExceedsDriverWorkHours",
+};
+export const RouteNoticeImpact = {
+    HIGH: "High",
+    LOW: "Low",
+};
+export const RouteFerryAfterTravelStepType = {
+    DEBOARD: "Deboard",
+};
+export const RouteFerryBeforeTravelStepType = {
+    BOARD: "Board",
+};
+export const RouteFerryNoticeCode = {
+    ACCURATE_POLYLINE_UNAVAILABLE: "AccuratePolylineUnavailable",
+    NO_SCHEDULE: "NoSchedule",
+    OTHER: "Other",
+    VIOLATED_AVOID_FERRY: "ViolatedAvoidFerry",
+    VIOLATED_AVOID_RAIL_FERRY: "ViolatedAvoidRailFerry",
+};
+export const RouteFerryTravelStepType = {
+    ARRIVE: "Arrive",
+    CONTINUE: "Continue",
+    DEPART: "Depart",
+};
+export const RouteSideOfStreet = {
+    LEFT: "Left",
+    RIGHT: "Right",
+};
+export const RoutePedestrianNoticeCode = {
+    ACCURATE_POLYLINE_UNAVAILABLE: "AccuratePolylineUnavailable",
+    OTHER: "Other",
+    VIOLATED_AVOID_DIRT_ROAD: "ViolatedAvoidDirtRoad",
+    VIOLATED_AVOID_TUNNEL: "ViolatedAvoidTunnel",
+    VIOLATED_PEDESTRIAN_OPTION: "ViolatedPedestrianOption",
+};
+export const RouteSpanPedestrianAccessAttribute = {
+    ALLOWED: "Allowed",
+    INDOORS: "Indoors",
+    NO_THROUGH_TRAFFIC: "NoThroughTraffic",
+    PARK: "Park",
+    STAIRS: "Stairs",
+    TOLL_ROAD: "TollRoad",
+};
+export const 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",
+};
+export const RouteDirection = {
+    EAST: "East",
+    NORTH: "North",
+    SOUTH: "South",
+    WEST: "West",
+};
+export const RouteRoadType = {
+    HIGHWAY: "Highway",
+    RURAL: "Rural",
+    URBAN: "Urban",
+};
+export const RouteSteeringDirection = {
+    LEFT: "Left",
+    RIGHT: "Right",
+    STRAIGHT: "Straight",
+};
+export const RouteTurnIntensity = {
+    SHARP: "Sharp",
+    SLIGHT: "Slight",
+    TYPICAL: "Typical",
+};
+export const 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",
+};
+export const RouteLegTravelMode = {
+    CAR: "Car",
+    FERRY: "Ferry",
+    PEDESTRIAN: "Pedestrian",
+    SCOOTER: "Scooter",
+    TRUCK: "Truck",
+};
+export const RouteLegType = {
+    FERRY: "Ferry",
+    PEDESTRIAN: "Pedestrian",
+    VEHICLE: "Vehicle",
+};
+export const RouteVehicleIncidentSeverity = {
+    CRITICAL: "Critical",
+    HIGH: "High",
+    LOW: "Low",
+    MEDIUM: "Medium",
+};
+export const 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",
+};
+export const 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",
+};
+export const RouteWeightConstraintType = {
+    CURRENT: "Current",
+    GROSS: "Gross",
+    UNKNOWN: "Unknown",
+};
+export const RouteSpanCarAccessAttribute = {
+    ALLOWED: "Allowed",
+    NO_THROUGH_TRAFFIC: "NoThroughTraffic",
+    TOLL_ROAD: "TollRoad",
+};
+export const RouteSpanGateAttribute = {
+    EMERGENCY: "Emergency",
+    KEY_ACCESS: "KeyAccess",
+    PERMISSION_REQUIRED: "PermissionRequired",
+};
+export const RouteSpanRailwayCrossingAttribute = {
+    PROTECTED: "Protected",
+    UNPROTECTED: "Unprotected",
+};
+export const RouteSpanScooterAccessAttribute = {
+    ALLOWED: "Allowed",
+    NO_THROUGH_TRAFFIC: "NoThroughTraffic",
+    TOLL_ROAD: "TollRoad",
+};
+export const RouteSpanTruckAccessAttribute = {
+    ALLOWED: "Allowed",
+    NO_THROUGH_TRAFFIC: "NoThroughTraffic",
+    TOLL_ROAD: "TollRoad",
+};
+export const RouteTollPassValidityPeriodType = {
+    ANNUAL: "Annual",
+    DAYS: "Days",
+    EXTENDED_ANNUAL: "ExtendedAnnual",
+    MINUTES: "Minutes",
+    MONTHS: "Months",
+};
+export const RouteTollPaymentMethod = {
+    BANK_CARD: "BankCard",
+    CASH: "Cash",
+    CASH_EXACT: "CashExact",
+    CREDIT_CARD: "CreditCard",
+    PASS_SUBSCRIPTION: "PassSubscription",
+    TRANSPONDER: "Transponder",
+    TRAVEL_CARD: "TravelCard",
+    VIDEO_TOLL: "VideoToll",
+};
+export const 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",
+};
+export const DayOfWeek = {
+    FRIDAY: "Friday",
+    MONDAY: "Monday",
+    SATURDAY: "Saturday",
+    SUNDAY: "Sunday",
+    THURSDAY: "Thursday",
+    TUESDAY: "Tuesday",
+    WEDNESDAY: "Wednesday",
+};
+export const WaypointOptimizationServiceTimeTreatment = {
+    REST: "Rest",
+    WORK: "Work",
+};
+export const WaypointOptimizationSequencingObjective = {
+    FASTEST_ROUTE: "FastestRoute",
+    SHORTEST_ROUTE: "ShortestRoute",
+};
+export const WaypointOptimizationTravelMode = {
+    CAR: "Car",
+    PEDESTRIAN: "Pedestrian",
+    SCOOTER: "Scooter",
+    TRUCK: "Truck",
+};
+export const 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",
+};
+export const WaypointOptimizationTruckType = {
+    STRAIGHT_TRUCK: "StraightTruck",
+    TRACTOR: "Tractor",
+};
+export const WaypointOptimizationConstraint = {
+    ACCESS_HOURS: "AccessHours",
+    APPOINTMENT_TIME: "AppointmentTime",
+    BEFORE: "Before",
+    HEADING: "Heading",
+    SERVICE_DURATION: "ServiceDuration",
+    SIDE_OF_STREET: "SideOfStreet",
+};
+export const RoadSnapTravelMode = {
+    CAR: "Car",
+    PEDESTRIAN: "Pedestrian",
+    SCOOTER: "Scooter",
+    TRUCK: "Truck",
+};
+export const 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",
+};
+export const 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",
+};
+export const CorridorFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.LineString && { LineString: SENSITIVE_STRING }),
+});
+export const PolylineCorridorFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Polyline && { Polyline: SENSITIVE_STRING }),
+});
+export const IsolineAvoidanceAreaGeometryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.BoundingBox && { BoundingBox: SENSITIVE_STRING }),
+    ...(obj.Corridor && { Corridor: SENSITIVE_STRING }),
+    ...(obj.Polygon && { Polygon: obj.Polygon.map((item) => SENSITIVE_STRING) }),
+    ...(obj.PolylineCorridor && { PolylineCorridor: SENSITIVE_STRING }),
+    ...(obj.PolylinePolygon && { PolylinePolygon: SENSITIVE_STRING }),
+});
+export const IsolineAvoidanceAreaFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Except && { Except: obj.Except.map((item) => IsolineAvoidanceAreaGeometryFilterSensitiveLog(item)) }),
+    ...(obj.Geometry && { Geometry: IsolineAvoidanceAreaGeometryFilterSensitiveLog(obj.Geometry) }),
+});
+export const IsolineAvoidanceOptionsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Areas && { Areas: obj.Areas.map((item) => IsolineAvoidanceAreaFilterSensitiveLog(item)) }),
+});
+export const IsolineMatchingOptionsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.NameHint && { NameHint: SENSITIVE_STRING }),
+});
+export const IsolineSideOfStreetOptionsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Position && { Position: SENSITIVE_STRING }),
+});
+export const IsolineDestinationOptionsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Matching && { Matching: IsolineMatchingOptionsFilterSensitiveLog(obj.Matching) }),
+    ...(obj.SideOfStreet && { SideOfStreet: IsolineSideOfStreetOptionsFilterSensitiveLog(obj.SideOfStreet) }),
+});
+export const IsolineOriginOptionsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Matching && { Matching: IsolineMatchingOptionsFilterSensitiveLog(obj.Matching) }),
+    ...(obj.SideOfStreet && { SideOfStreet: IsolineSideOfStreetOptionsFilterSensitiveLog(obj.SideOfStreet) }),
+});
+export const CalculateIsolinesRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Avoid && { Avoid: IsolineAvoidanceOptionsFilterSensitiveLog(obj.Avoid) }),
+    ...(obj.Destination && { Destination: SENSITIVE_STRING }),
+    ...(obj.DestinationOptions && {
+        DestinationOptions: IsolineDestinationOptionsFilterSensitiveLog(obj.DestinationOptions),
+    }),
+    ...(obj.Key && { Key: SENSITIVE_STRING }),
+    ...(obj.Origin && { Origin: SENSITIVE_STRING }),
+    ...(obj.OriginOptions && { OriginOptions: IsolineOriginOptionsFilterSensitiveLog(obj.OriginOptions) }),
+});
+export const IsolineConnectionGeometryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.LineString && { LineString: SENSITIVE_STRING }),
+    ...(obj.Polyline && { Polyline: SENSITIVE_STRING }),
+});
+export const IsolineConnectionFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Geometry && { Geometry: IsolineConnectionGeometryFilterSensitiveLog(obj.Geometry) }),
+});
+export const IsolineShapeGeometryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Polygon && { Polygon: obj.Polygon.map((item) => SENSITIVE_STRING) }),
+    ...(obj.PolylinePolygon && { PolylinePolygon: SENSITIVE_STRING }),
+});
+export const IsolineFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Connections && { Connections: obj.Connections.map((item) => IsolineConnectionFilterSensitiveLog(item)) }),
+    ...(obj.Geometries && { Geometries: obj.Geometries.map((item) => IsolineShapeGeometryFilterSensitiveLog(item)) }),
+});
+export const CalculateIsolinesResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.SnappedDestination && { SnappedDestination: SENSITIVE_STRING }),
+    ...(obj.SnappedOrigin && { SnappedOrigin: SENSITIVE_STRING }),
+});
+export const RouteMatrixAvoidanceAreaGeometryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.BoundingBox && { BoundingBox: SENSITIVE_STRING }),
+    ...(obj.Polygon && { Polygon: obj.Polygon.map((item) => SENSITIVE_STRING) }),
+    ...(obj.PolylinePolygon && { PolylinePolygon: SENSITIVE_STRING }),
+});
+export const RouteMatrixAvoidanceAreaFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Geometry && { Geometry: RouteMatrixAvoidanceAreaGeometryFilterSensitiveLog(obj.Geometry) }),
+});
+export const RouteMatrixAvoidanceOptionsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Areas && { Areas: obj.Areas.map((item) => RouteMatrixAvoidanceAreaFilterSensitiveLog(item)) }),
+});
+export const RouteMatrixMatchingOptionsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.NameHint && { NameHint: SENSITIVE_STRING }),
+});
+export const RouteMatrixSideOfStreetOptionsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Position && { Position: SENSITIVE_STRING }),
+});
+export const RouteMatrixDestinationOptionsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Matching && { Matching: RouteMatrixMatchingOptionsFilterSensitiveLog(obj.Matching) }),
+    ...(obj.SideOfStreet && { SideOfStreet: RouteMatrixSideOfStreetOptionsFilterSensitiveLog(obj.SideOfStreet) }),
+});
+export const RouteMatrixDestinationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Options && { Options: RouteMatrixDestinationOptionsFilterSensitiveLog(obj.Options) }),
+    ...(obj.Position && { Position: SENSITIVE_STRING }),
+});
+export const RouteMatrixOriginOptionsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Matching && { Matching: RouteMatrixMatchingOptionsFilterSensitiveLog(obj.Matching) }),
+    ...(obj.SideOfStreet && { SideOfStreet: RouteMatrixSideOfStreetOptionsFilterSensitiveLog(obj.SideOfStreet) }),
+});
+export const RouteMatrixOriginFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Options && { Options: RouteMatrixOriginOptionsFilterSensitiveLog(obj.Options) }),
+    ...(obj.Position && { Position: SENSITIVE_STRING }),
+});
+export const CircleFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Center && { Center: SENSITIVE_STRING }),
+});
+export const RouteMatrixBoundaryGeometryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Circle && { Circle: SENSITIVE_STRING }),
+    ...(obj.BoundingBox && { BoundingBox: SENSITIVE_STRING }),
+    ...(obj.Polygon && { Polygon: obj.Polygon.map((item) => SENSITIVE_STRING) }),
+});
+export const RouteMatrixBoundaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Geometry && { Geometry: RouteMatrixBoundaryGeometryFilterSensitiveLog(obj.Geometry) }),
+});
+export const CalculateRouteMatrixRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Avoid && { Avoid: RouteMatrixAvoidanceOptionsFilterSensitiveLog(obj.Avoid) }),
+    ...(obj.Destinations && {
+        Destinations: obj.Destinations.map((item) => RouteMatrixDestinationFilterSensitiveLog(item)),
+    }),
+    ...(obj.Key && { Key: SENSITIVE_STRING }),
+    ...(obj.Origins && { Origins: obj.Origins.map((item) => RouteMatrixOriginFilterSensitiveLog(item)) }),
+    ...(obj.RoutingBoundary && { RoutingBoundary: RouteMatrixBoundaryFilterSensitiveLog(obj.RoutingBoundary) }),
+});
+export const CalculateRouteMatrixResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.RoutingBoundary && { RoutingBoundary: RouteMatrixBoundaryFilterSensitiveLog(obj.RoutingBoundary) }),
+});
+export const RouteAvoidanceAreaGeometryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Corridor && { Corridor: SENSITIVE_STRING }),
+    ...(obj.BoundingBox && { BoundingBox: SENSITIVE_STRING }),
+    ...(obj.Polygon && { Polygon: obj.Polygon.map((item) => SENSITIVE_STRING) }),
+    ...(obj.PolylineCorridor && { PolylineCorridor: SENSITIVE_STRING }),
+    ...(obj.PolylinePolygon && { PolylinePolygon: SENSITIVE_STRING }),
+});
+export const RouteAvoidanceAreaFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Except && { Except: obj.Except.map((item) => RouteAvoidanceAreaGeometryFilterSensitiveLog(item)) }),
+    ...(obj.Geometry && { Geometry: RouteAvoidanceAreaGeometryFilterSensitiveLog(obj.Geometry) }),
+});
+export const RouteAvoidanceOptionsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Areas && { Areas: obj.Areas.map((item) => RouteAvoidanceAreaFilterSensitiveLog(item)) }),
+});
+export const RouteMatchingOptionsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.NameHint && { NameHint: SENSITIVE_STRING }),
+});
+export const RouteSideOfStreetOptionsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Position && { Position: SENSITIVE_STRING }),
+});
+export const RouteDestinationOptionsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Matching && { Matching: RouteMatchingOptionsFilterSensitiveLog(obj.Matching) }),
+    ...(obj.SideOfStreet && { SideOfStreet: RouteSideOfStreetOptionsFilterSensitiveLog(obj.SideOfStreet) }),
+});
+export const RouteOriginOptionsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Matching && { Matching: RouteMatchingOptionsFilterSensitiveLog(obj.Matching) }),
+    ...(obj.SideOfStreet && { SideOfStreet: RouteSideOfStreetOptionsFilterSensitiveLog(obj.SideOfStreet) }),
+});
+export const RouteWaypointFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Matching && { Matching: RouteMatchingOptionsFilterSensitiveLog(obj.Matching) }),
+    ...(obj.Position && { Position: SENSITIVE_STRING }),
+    ...(obj.SideOfStreet && { SideOfStreet: RouteSideOfStreetOptionsFilterSensitiveLog(obj.SideOfStreet) }),
+});
+export const CalculateRoutesRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Avoid && { Avoid: RouteAvoidanceOptionsFilterSensitiveLog(obj.Avoid) }),
+    ...(obj.Destination && { Destination: SENSITIVE_STRING }),
+    ...(obj.DestinationOptions && {
+        DestinationOptions: RouteDestinationOptionsFilterSensitiveLog(obj.DestinationOptions),
+    }),
+    ...(obj.Key && { Key: SENSITIVE_STRING }),
+    ...(obj.Origin && { Origin: SENSITIVE_STRING }),
+    ...(obj.OriginOptions && { OriginOptions: RouteOriginOptionsFilterSensitiveLog(obj.OriginOptions) }),
+    ...(obj.Waypoints && { Waypoints: obj.Waypoints.map((item) => RouteWaypointFilterSensitiveLog(item)) }),
+});
+export const RouteFerryPlaceFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.OriginalPosition && { OriginalPosition: SENSITIVE_STRING }),
+    ...(obj.Position && { Position: SENSITIVE_STRING }),
+});
+export const RouteFerryArrivalFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Place && { Place: RouteFerryPlaceFilterSensitiveLog(obj.Place) }),
+});
+export const RouteFerryDepartureFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Place && { Place: RouteFerryPlaceFilterSensitiveLog(obj.Place) }),
+});
+export const RoutePassThroughPlaceFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.OriginalPosition && { OriginalPosition: SENSITIVE_STRING }),
+    ...(obj.Position && { Position: SENSITIVE_STRING }),
+});
+export const RoutePassThroughWaypointFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Place && { Place: RoutePassThroughPlaceFilterSensitiveLog(obj.Place) }),
+});
+export const RouteFerryLegDetailsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Arrival && { Arrival: RouteFerryArrivalFilterSensitiveLog(obj.Arrival) }),
+    ...(obj.Departure && { Departure: RouteFerryDepartureFilterSensitiveLog(obj.Departure) }),
+    ...(obj.PassThroughWaypoints && {
+        PassThroughWaypoints: obj.PassThroughWaypoints.map((item) => RoutePassThroughWaypointFilterSensitiveLog(item)),
+    }),
+});
+export const RouteLegGeometryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.LineString && { LineString: SENSITIVE_STRING }),
+    ...(obj.Polyline && { Polyline: SENSITIVE_STRING }),
+});
+export const RoutePedestrianPlaceFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.OriginalPosition && { OriginalPosition: SENSITIVE_STRING }),
+    ...(obj.Position && { Position: SENSITIVE_STRING }),
+});
+export const RoutePedestrianArrivalFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Place && { Place: RoutePedestrianPlaceFilterSensitiveLog(obj.Place) }),
+});
+export const RoutePedestrianDepartureFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Place && { Place: RoutePedestrianPlaceFilterSensitiveLog(obj.Place) }),
+});
+export const RoutePedestrianLegDetailsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Arrival && { Arrival: RoutePedestrianArrivalFilterSensitiveLog(obj.Arrival) }),
+    ...(obj.Departure && { Departure: RoutePedestrianDepartureFilterSensitiveLog(obj.Departure) }),
+    ...(obj.PassThroughWaypoints && {
+        PassThroughWaypoints: obj.PassThroughWaypoints.map((item) => RoutePassThroughWaypointFilterSensitiveLog(item)),
+    }),
+});
+export const RouteVehiclePlaceFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.OriginalPosition && { OriginalPosition: SENSITIVE_STRING }),
+    ...(obj.Position && { Position: SENSITIVE_STRING }),
+});
+export const RouteVehicleArrivalFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Place && { Place: RouteVehiclePlaceFilterSensitiveLog(obj.Place) }),
+});
+export const RouteVehicleDepartureFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Place && { Place: RouteVehiclePlaceFilterSensitiveLog(obj.Place) }),
+});
+export const RouteTollPaymentSiteFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Position && { Position: SENSITIVE_STRING }),
+});
+export const RouteTollFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.PaymentSites && {
+        PaymentSites: obj.PaymentSites.map((item) => RouteTollPaymentSiteFilterSensitiveLog(item)),
+    }),
+});
+export const RouteVehicleLegDetailsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Arrival && { Arrival: RouteVehicleArrivalFilterSensitiveLog(obj.Arrival) }),
+    ...(obj.Departure && { Departure: RouteVehicleDepartureFilterSensitiveLog(obj.Departure) }),
+    ...(obj.PassThroughWaypoints && {
+        PassThroughWaypoints: obj.PassThroughWaypoints.map((item) => RoutePassThroughWaypointFilterSensitiveLog(item)),
+    }),
+});
+export const RouteLegFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.FerryLegDetails && { FerryLegDetails: RouteFerryLegDetailsFilterSensitiveLog(obj.FerryLegDetails) }),
+    ...(obj.Geometry && { Geometry: RouteLegGeometryFilterSensitiveLog(obj.Geometry) }),
+    ...(obj.PedestrianLegDetails && {
+        PedestrianLegDetails: RoutePedestrianLegDetailsFilterSensitiveLog(obj.PedestrianLegDetails),
+    }),
+    ...(obj.VehicleLegDetails && { VehicleLegDetails: RouteVehicleLegDetailsFilterSensitiveLog(obj.VehicleLegDetails) }),
+});
+export const RouteFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Legs && { Legs: obj.Legs.map((item) => RouteLegFilterSensitiveLog(item)) }),
+});
+export const CalculateRoutesResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const WaypointOptimizationAvoidanceAreaGeometryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.BoundingBox && { BoundingBox: SENSITIVE_STRING }),
+});
+export const WaypointOptimizationAvoidanceAreaFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Geometry && { Geometry: WaypointOptimizationAvoidanceAreaGeometryFilterSensitiveLog(obj.Geometry) }),
+});
+export const WaypointOptimizationAvoidanceOptionsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Areas && { Areas: obj.Areas.map((item) => WaypointOptimizationAvoidanceAreaFilterSensitiveLog(item)) }),
+});
+export const WaypointOptimizationSideOfStreetOptionsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Position && { Position: SENSITIVE_STRING }),
+});
+export const WaypointOptimizationDestinationOptionsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.SideOfStreet && {
+        SideOfStreet: WaypointOptimizationSideOfStreetOptionsFilterSensitiveLog(obj.SideOfStreet),
+    }),
+});
+export const WaypointOptimizationWaypointFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Position && { Position: SENSITIVE_STRING }),
+    ...(obj.SideOfStreet && {
+        SideOfStreet: WaypointOptimizationSideOfStreetOptionsFilterSensitiveLog(obj.SideOfStreet),
+    }),
+});
+export const OptimizeWaypointsRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Avoid && { Avoid: WaypointOptimizationAvoidanceOptionsFilterSensitiveLog(obj.Avoid) }),
+    ...(obj.Destination && { Destination: SENSITIVE_STRING }),
+    ...(obj.DestinationOptions && {
+        DestinationOptions: WaypointOptimizationDestinationOptionsFilterSensitiveLog(obj.DestinationOptions),
+    }),
+    ...(obj.Key && { Key: SENSITIVE_STRING }),
+    ...(obj.Origin && { Origin: SENSITIVE_STRING }),
+    ...(obj.Waypoints && {
+        Waypoints: obj.Waypoints.map((item) => WaypointOptimizationWaypointFilterSensitiveLog(item)),
+    }),
+});
+export const WaypointOptimizationImpedingWaypointFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Position && { Position: SENSITIVE_STRING }),
+});
+export const WaypointOptimizationOptimizedWaypointFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Position && { Position: SENSITIVE_STRING }),
+});
+export const OptimizeWaypointsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ImpedingWaypoints && {
+        ImpedingWaypoints: obj.ImpedingWaypoints.map((item) => WaypointOptimizationImpedingWaypointFilterSensitiveLog(item)),
+    }),
+    ...(obj.OptimizedWaypoints && {
+        OptimizedWaypoints: obj.OptimizedWaypoints.map((item) => WaypointOptimizationOptimizedWaypointFilterSensitiveLog(item)),
+    }),
+});
+export const RoadSnapTracePointFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Position && { Position: SENSITIVE_STRING }),
+});
+export const SnapToRoadsRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Key && { Key: SENSITIVE_STRING }),
+    ...(obj.TracePoints && { TracePoints: obj.TracePoints.map((item) => RoadSnapTracePointFilterSensitiveLog(item)) }),
+});
+export const RoadSnapSnappedGeometryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.LineString && { LineString: SENSITIVE_STRING }),
+    ...(obj.Polyline && { Polyline: SENSITIVE_STRING }),
+});
+export const RoadSnapSnappedTracePointFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.OriginalPosition && { OriginalPosition: SENSITIVE_STRING }),
+    ...(obj.SnappedPosition && { SnappedPosition: SENSITIVE_STRING }),
+});
+export const SnapToRoadsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.SnappedGeometry && { SnappedGeometry: RoadSnapSnappedGeometryFilterSensitiveLog(obj.SnappedGeometry) }),
+    ...(obj.SnappedTracePoints && {
+        SnappedTracePoints: obj.SnappedTracePoints.map((item) => RoadSnapSnappedTracePointFilterSensitiveLog(item)),
+    }),
+});