pub fn serialize_structure_crate_input_associate_tracker_consumer_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateTrackerConsumerInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_1) = &input.consumer_arn {
object.key("ConsumerArn").string(var_1);
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_delete_device_position_history_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchDeleteDevicePositionHistoryInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_2) = &input.device_ids {
let mut array_3 = object.key("DeviceIds").start_array();
for item_4 in var_2 {
{
array_3.value().string(item_4);
}
}
array_3.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_delete_geofence_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchDeleteGeofenceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_5) = &input.geofence_ids {
let mut array_6 = object.key("GeofenceIds").start_array();
for item_7 in var_5 {
{
array_6.value().string(item_7);
}
}
array_6.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_evaluate_geofences_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchEvaluateGeofencesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_8) = &input.device_position_updates {
let mut array_9 = object.key("DevicePositionUpdates").start_array();
for item_10 in var_8 {
{
let mut object_11 = array_9.value().start_object();
crate::json_ser::serialize_structure_crate_model_device_position_update(
&mut object_11,
item_10,
)?;
object_11.finish();
}
}
array_9.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_get_device_position_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchGetDevicePositionInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_12) = &input.device_ids {
let mut array_13 = object.key("DeviceIds").start_array();
for item_14 in var_12 {
{
array_13.value().string(item_14);
}
}
array_13.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_put_geofence_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchPutGeofenceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_15) = &input.entries {
let mut array_16 = object.key("Entries").start_array();
for item_17 in var_15 {
{
let mut object_18 = array_16.value().start_object();
crate::json_ser::serialize_structure_crate_model_batch_put_geofence_request_entry(
&mut object_18,
item_17,
)?;
object_18.finish();
}
}
array_16.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_update_device_position_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchUpdateDevicePositionInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_19) = &input.updates {
let mut array_20 = object.key("Updates").start_array();
for item_21 in var_19 {
{
let mut object_22 = array_20.value().start_object();
crate::json_ser::serialize_structure_crate_model_device_position_update(
&mut object_22,
item_21,
)?;
object_22.finish();
}
}
array_20.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_calculate_route_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CalculateRouteInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_23) = &input.car_mode_options {
let mut object_24 = object.key("CarModeOptions").start_object();
crate::json_ser::serialize_structure_crate_model_calculate_route_car_mode_options(
&mut object_24,
var_23,
)?;
object_24.finish();
}
if let Some(var_25) = &input.depart_now {
object.key("DepartNow").boolean(*var_25);
}
if let Some(var_26) = &input.departure_position {
let mut array_27 = object.key("DeparturePosition").start_array();
for item_28 in var_26 {
{
array_27.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*item_28).into()),
);
}
}
array_27.finish();
}
if let Some(var_29) = &input.departure_time {
object
.key("DepartureTime")
.date_time(var_29, aws_smithy_types::date_time::Format::DateTime)?;
}
if let Some(var_30) = &input.destination_position {
let mut array_31 = object.key("DestinationPosition").start_array();
for item_32 in var_30 {
{
array_31.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*item_32).into()),
);
}
}
array_31.finish();
}
if let Some(var_33) = &input.distance_unit {
object.key("DistanceUnit").string(var_33.as_str());
}
if let Some(var_34) = &input.include_leg_geometry {
object.key("IncludeLegGeometry").boolean(*var_34);
}
if let Some(var_35) = &input.travel_mode {
object.key("TravelMode").string(var_35.as_str());
}
if let Some(var_36) = &input.truck_mode_options {
let mut object_37 = object.key("TruckModeOptions").start_object();
crate::json_ser::serialize_structure_crate_model_calculate_route_truck_mode_options(
&mut object_37,
var_36,
)?;
object_37.finish();
}
if let Some(var_38) = &input.waypoint_positions {
let mut array_39 = object.key("WaypointPositions").start_array();
for item_40 in var_38 {
{
let mut array_41 = array_39.value().start_array();
for item_42 in item_40 {
{
array_41.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*item_42).into()),
);
}
}
array_41.finish();
}
}
array_39.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_geofence_collection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateGeofenceCollectionInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_43) = &input.collection_name {
object.key("CollectionName").string(var_43);
}
if let Some(var_44) = &input.description {
object.key("Description").string(var_44);
}
if let Some(var_45) = &input.kms_key_id {
object.key("KmsKeyId").string(var_45);
}
if let Some(var_46) = &input.pricing_plan {
object.key("PricingPlan").string(var_46.as_str());
}
if let Some(var_47) = &input.pricing_plan_data_source {
object.key("PricingPlanDataSource").string(var_47);
}
if let Some(var_48) = &input.tags {
let mut object_49 = object.key("Tags").start_object();
for (key_50, value_51) in var_48 {
{
object_49.key(key_50).string(value_51);
}
}
object_49.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_map_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateMapInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_52) = &input.configuration {
let mut object_53 = object.key("Configuration").start_object();
crate::json_ser::serialize_structure_crate_model_map_configuration(&mut object_53, var_52)?;
object_53.finish();
}
if let Some(var_54) = &input.description {
object.key("Description").string(var_54);
}
if let Some(var_55) = &input.map_name {
object.key("MapName").string(var_55);
}
if let Some(var_56) = &input.pricing_plan {
object.key("PricingPlan").string(var_56.as_str());
}
if let Some(var_57) = &input.tags {
let mut object_58 = object.key("Tags").start_object();
for (key_59, value_60) in var_57 {
{
object_58.key(key_59).string(value_60);
}
}
object_58.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_place_index_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreatePlaceIndexInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_61) = &input.data_source {
object.key("DataSource").string(var_61);
}
if let Some(var_62) = &input.data_source_configuration {
let mut object_63 = object.key("DataSourceConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_data_source_configuration(
&mut object_63,
var_62,
)?;
object_63.finish();
}
if let Some(var_64) = &input.description {
object.key("Description").string(var_64);
}
if let Some(var_65) = &input.index_name {
object.key("IndexName").string(var_65);
}
if let Some(var_66) = &input.pricing_plan {
object.key("PricingPlan").string(var_66.as_str());
}
if let Some(var_67) = &input.tags {
let mut object_68 = object.key("Tags").start_object();
for (key_69, value_70) in var_67 {
{
object_68.key(key_69).string(value_70);
}
}
object_68.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_route_calculator_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateRouteCalculatorInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_71) = &input.calculator_name {
object.key("CalculatorName").string(var_71);
}
if let Some(var_72) = &input.data_source {
object.key("DataSource").string(var_72);
}
if let Some(var_73) = &input.description {
object.key("Description").string(var_73);
}
if let Some(var_74) = &input.pricing_plan {
object.key("PricingPlan").string(var_74.as_str());
}
if let Some(var_75) = &input.tags {
let mut object_76 = object.key("Tags").start_object();
for (key_77, value_78) in var_75 {
{
object_76.key(key_77).string(value_78);
}
}
object_76.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_tracker_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateTrackerInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_79) = &input.description {
object.key("Description").string(var_79);
}
if let Some(var_80) = &input.kms_key_id {
object.key("KmsKeyId").string(var_80);
}
if let Some(var_81) = &input.position_filtering {
object.key("PositionFiltering").string(var_81.as_str());
}
if let Some(var_82) = &input.pricing_plan {
object.key("PricingPlan").string(var_82.as_str());
}
if let Some(var_83) = &input.pricing_plan_data_source {
object.key("PricingPlanDataSource").string(var_83);
}
if let Some(var_84) = &input.tags {
let mut object_85 = object.key("Tags").start_object();
for (key_86, value_87) in var_84 {
{
object_85.key(key_86).string(value_87);
}
}
object_85.finish();
}
if let Some(var_88) = &input.tracker_name {
object.key("TrackerName").string(var_88);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_device_position_history_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetDevicePositionHistoryInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_89) = &input.end_time_exclusive {
object
.key("EndTimeExclusive")
.date_time(var_89, aws_smithy_types::date_time::Format::DateTime)?;
}
if let Some(var_90) = &input.next_token {
object.key("NextToken").string(var_90);
}
if let Some(var_91) = &input.start_time_inclusive {
object
.key("StartTimeInclusive")
.date_time(var_91, aws_smithy_types::date_time::Format::DateTime)?;
}
Ok(())
}
pub fn serialize_structure_crate_input_list_device_positions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDevicePositionsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_92) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_92).into()),
);
}
if let Some(var_93) = &input.next_token {
object.key("NextToken").string(var_93);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_geofence_collections_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListGeofenceCollectionsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_94) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_94).into()),
);
}
if let Some(var_95) = &input.next_token {
object.key("NextToken").string(var_95);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_geofences_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListGeofencesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_96) = &input.next_token {
object.key("NextToken").string(var_96);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_maps_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListMapsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_97) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_97).into()),
);
}
if let Some(var_98) = &input.next_token {
object.key("NextToken").string(var_98);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_place_indexes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListPlaceIndexesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_99) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_99).into()),
);
}
if let Some(var_100) = &input.next_token {
object.key("NextToken").string(var_100);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_route_calculators_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListRouteCalculatorsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_101) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_101).into()),
);
}
if let Some(var_102) = &input.next_token {
object.key("NextToken").string(var_102);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_tracker_consumers_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTrackerConsumersInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_103) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_103).into()),
);
}
if let Some(var_104) = &input.next_token {
object.key("NextToken").string(var_104);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_trackers_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTrackersInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_105) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_105).into()),
);
}
if let Some(var_106) = &input.next_token {
object.key("NextToken").string(var_106);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_geofence_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutGeofenceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_107) = &input.geometry {
let mut object_108 = object.key("Geometry").start_object();
crate::json_ser::serialize_structure_crate_model_geofence_geometry(
&mut object_108,
var_107,
)?;
object_108.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_search_place_index_for_position_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchPlaceIndexForPositionInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_109) = &input.language {
object.key("Language").string(var_109);
}
if input.max_results != 0 {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_110) = &input.position {
let mut array_111 = object.key("Position").start_array();
for item_112 in var_110 {
{
array_111.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*item_112).into()),
);
}
}
array_111.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_search_place_index_for_suggestions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchPlaceIndexForSuggestionsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_113) = &input.bias_position {
let mut array_114 = object.key("BiasPosition").start_array();
for item_115 in var_113 {
{
array_114.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*item_115).into()),
);
}
}
array_114.finish();
}
if let Some(var_116) = &input.filter_b_box {
let mut array_117 = object.key("FilterBBox").start_array();
for item_118 in var_116 {
{
array_117.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*item_118).into()),
);
}
}
array_117.finish();
}
if let Some(var_119) = &input.filter_countries {
let mut array_120 = object.key("FilterCountries").start_array();
for item_121 in var_119 {
{
array_120.value().string(item_121);
}
}
array_120.finish();
}
if let Some(var_122) = &input.language {
object.key("Language").string(var_122);
}
if let Some(var_123) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_123).into()),
);
}
if let Some(var_124) = &input.text {
object.key("Text").string(var_124);
}
Ok(())
}
pub fn serialize_structure_crate_input_search_place_index_for_text_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchPlaceIndexForTextInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_125) = &input.bias_position {
let mut array_126 = object.key("BiasPosition").start_array();
for item_127 in var_125 {
{
array_126.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*item_127).into()),
);
}
}
array_126.finish();
}
if let Some(var_128) = &input.filter_b_box {
let mut array_129 = object.key("FilterBBox").start_array();
for item_130 in var_128 {
{
array_129.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*item_130).into()),
);
}
}
array_129.finish();
}
if let Some(var_131) = &input.filter_countries {
let mut array_132 = object.key("FilterCountries").start_array();
for item_133 in var_131 {
{
array_132.value().string(item_133);
}
}
array_132.finish();
}
if let Some(var_134) = &input.language {
object.key("Language").string(var_134);
}
if input.max_results != 0 {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_135) = &input.text {
object.key("Text").string(var_135);
}
Ok(())
}
pub fn serialize_structure_crate_input_tag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_136) = &input.tags {
let mut object_137 = object.key("Tags").start_object();
for (key_138, value_139) in var_136 {
{
object_137.key(key_138).string(value_139);
}
}
object_137.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_geofence_collection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateGeofenceCollectionInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_140) = &input.description {
object.key("Description").string(var_140);
}
if let Some(var_141) = &input.pricing_plan {
object.key("PricingPlan").string(var_141.as_str());
}
if let Some(var_142) = &input.pricing_plan_data_source {
object.key("PricingPlanDataSource").string(var_142);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_map_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateMapInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_143) = &input.description {
object.key("Description").string(var_143);
}
if let Some(var_144) = &input.pricing_plan {
object.key("PricingPlan").string(var_144.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_place_index_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdatePlaceIndexInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_145) = &input.data_source_configuration {
let mut object_146 = object.key("DataSourceConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_data_source_configuration(
&mut object_146,
var_145,
)?;
object_146.finish();
}
if let Some(var_147) = &input.description {
object.key("Description").string(var_147);
}
if let Some(var_148) = &input.pricing_plan {
object.key("PricingPlan").string(var_148.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_route_calculator_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateRouteCalculatorInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_149) = &input.description {
object.key("Description").string(var_149);
}
if let Some(var_150) = &input.pricing_plan {
object.key("PricingPlan").string(var_150.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_tracker_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateTrackerInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_151) = &input.description {
object.key("Description").string(var_151);
}
if let Some(var_152) = &input.position_filtering {
object.key("PositionFiltering").string(var_152.as_str());
}
if let Some(var_153) = &input.pricing_plan {
object.key("PricingPlan").string(var_153.as_str());
}
if let Some(var_154) = &input.pricing_plan_data_source {
object.key("PricingPlanDataSource").string(var_154);
}
Ok(())
}
pub fn serialize_structure_crate_model_device_position_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DevicePositionUpdate,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_155) = &input.device_id {
object.key("DeviceId").string(var_155);
}
if let Some(var_156) = &input.sample_time {
object
.key("SampleTime")
.date_time(var_156, aws_smithy_types::date_time::Format::DateTime)?;
}
if let Some(var_157) = &input.position {
let mut array_158 = object.key("Position").start_array();
for item_159 in var_157 {
{
array_158.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*item_159).into()),
);
}
}
array_158.finish();
}
if let Some(var_160) = &input.accuracy {
let mut object_161 = object.key("Accuracy").start_object();
crate::json_ser::serialize_structure_crate_model_positional_accuracy(
&mut object_161,
var_160,
)?;
object_161.finish();
}
if let Some(var_162) = &input.position_properties {
let mut object_163 = object.key("PositionProperties").start_object();
for (key_164, value_165) in var_162 {
{
object_163.key(key_164).string(value_165);
}
}
object_163.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_batch_put_geofence_request_entry(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BatchPutGeofenceRequestEntry,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_166) = &input.geofence_id {
object.key("GeofenceId").string(var_166);
}
if let Some(var_167) = &input.geometry {
let mut object_168 = object.key("Geometry").start_object();
crate::json_ser::serialize_structure_crate_model_geofence_geometry(
&mut object_168,
var_167,
)?;
object_168.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_calculate_route_car_mode_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CalculateRouteCarModeOptions,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_169) = &input.avoid_ferries {
object.key("AvoidFerries").boolean(*var_169);
}
if let Some(var_170) = &input.avoid_tolls {
object.key("AvoidTolls").boolean(*var_170);
}
Ok(())
}
pub fn serialize_structure_crate_model_calculate_route_truck_mode_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CalculateRouteTruckModeOptions,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_171) = &input.avoid_ferries {
object.key("AvoidFerries").boolean(*var_171);
}
if let Some(var_172) = &input.avoid_tolls {
object.key("AvoidTolls").boolean(*var_172);
}
if let Some(var_173) = &input.dimensions {
let mut object_174 = object.key("Dimensions").start_object();
crate::json_ser::serialize_structure_crate_model_truck_dimensions(
&mut object_174,
var_173,
)?;
object_174.finish();
}
if let Some(var_175) = &input.weight {
let mut object_176 = object.key("Weight").start_object();
crate::json_ser::serialize_structure_crate_model_truck_weight(&mut object_176, var_175)?;
object_176.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_map_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MapConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_177) = &input.style {
object.key("Style").string(var_177);
}
Ok(())
}
pub fn serialize_structure_crate_model_data_source_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataSourceConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_178) = &input.intended_use {
object.key("IntendedUse").string(var_178.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_geofence_geometry(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GeofenceGeometry,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_179) = &input.polygon {
let mut array_180 = object.key("Polygon").start_array();
for item_181 in var_179 {
{
let mut array_182 = array_180.value().start_array();
for item_183 in item_181 {
{
let mut array_184 = array_182.value().start_array();
for item_185 in item_183 {
{
array_184.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*item_185).into()),
);
}
}
array_184.finish();
}
}
array_182.finish();
}
}
array_180.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_positional_accuracy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PositionalAccuracy,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_186) = &input.horizontal {
object.key("Horizontal").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_186).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_truck_dimensions(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TruckDimensions,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_187) = &input.length {
object.key("Length").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_187).into()),
);
}
if let Some(var_188) = &input.height {
object.key("Height").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_188).into()),
);
}
if let Some(var_189) = &input.width {
object.key("Width").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_189).into()),
);
}
if let Some(var_190) = &input.unit {
object.key("Unit").string(var_190.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_truck_weight(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TruckWeight,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_191) = &input.total {
object.key("Total").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_191).into()),
);
}
if let Some(var_192) = &input.unit {
object.key("Unit").string(var_192.as_str());
}
Ok(())
}