pub fn serialize_structure_crate_input_associate_vehicle_fleet_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateVehicleFleetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.vehicle_name {
object.key("vehicleName").string(var_1.as_str());
}
if let Some(var_2) = &input.fleet_id {
object.key("fleetId").string(var_2.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_create_vehicle_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchCreateVehicleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3) = &input.vehicles {
let mut array_4 = object.key("vehicles").start_array();
for item_5 in var_3 {
{
#[allow(unused_mut)]
let mut object_6 = array_4.value().start_object();
crate::json_ser::serialize_structure_crate_model_create_vehicle_request_item(
&mut object_6,
item_5,
)?;
object_6.finish();
}
}
array_4.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_update_vehicle_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchUpdateVehicleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_7) = &input.vehicles {
let mut array_8 = object.key("vehicles").start_array();
for item_9 in var_7 {
{
#[allow(unused_mut)]
let mut object_10 = array_8.value().start_object();
crate::json_ser::serialize_structure_crate_model_update_vehicle_request_item(
&mut object_10,
item_9,
)?;
object_10.finish();
}
}
array_8.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_campaign_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateCampaignInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_11) = &input.name {
object.key("name").string(var_11.as_str());
}
if let Some(var_12) = &input.description {
object.key("description").string(var_12.as_str());
}
if let Some(var_13) = &input.signal_catalog_arn {
object.key("signalCatalogArn").string(var_13.as_str());
}
if let Some(var_14) = &input.target_arn {
object.key("targetArn").string(var_14.as_str());
}
if let Some(var_15) = &input.start_time {
object
.key("startTime")
.date_time(var_15, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_16) = &input.expiry_time {
object
.key("expiryTime")
.date_time(var_16, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_17) = &input.post_trigger_collection_duration {
object.key("postTriggerCollectionDuration").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_17).into()),
);
}
if let Some(var_18) = &input.diagnostics_mode {
object.key("diagnosticsMode").string(var_18.as_str());
}
if let Some(var_19) = &input.spooling_mode {
object.key("spoolingMode").string(var_19.as_str());
}
if let Some(var_20) = &input.compression {
object.key("compression").string(var_20.as_str());
}
if let Some(var_21) = &input.priority {
object.key("priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_21).into()),
);
}
if let Some(var_22) = &input.signals_to_collect {
let mut array_23 = object.key("signalsToCollect").start_array();
for item_24 in var_22 {
{
#[allow(unused_mut)]
let mut object_25 = array_23.value().start_object();
crate::json_ser::serialize_structure_crate_model_signal_information(
&mut object_25,
item_24,
)?;
object_25.finish();
}
}
array_23.finish();
}
if let Some(var_26) = &input.collection_scheme {
#[allow(unused_mut)]
let mut object_27 = object.key("collectionScheme").start_object();
crate::json_ser::serialize_union_crate_model_collection_scheme(&mut object_27, var_26)?;
object_27.finish();
}
if let Some(var_28) = &input.data_extra_dimensions {
let mut array_29 = object.key("dataExtraDimensions").start_array();
for item_30 in var_28 {
{
array_29.value().string(item_30.as_str());
}
}
array_29.finish();
}
if let Some(var_31) = &input.tags {
let mut array_32 = object.key("tags").start_array();
for item_33 in var_31 {
{
#[allow(unused_mut)]
let mut object_34 = array_32.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_34, item_33)?;
object_34.finish();
}
}
array_32.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_decoder_manifest_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDecoderManifestInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_35) = &input.name {
object.key("name").string(var_35.as_str());
}
if let Some(var_36) = &input.description {
object.key("description").string(var_36.as_str());
}
if let Some(var_37) = &input.model_manifest_arn {
object.key("modelManifestArn").string(var_37.as_str());
}
if let Some(var_38) = &input.signal_decoders {
let mut array_39 = object.key("signalDecoders").start_array();
for item_40 in var_38 {
{
#[allow(unused_mut)]
let mut object_41 = array_39.value().start_object();
crate::json_ser::serialize_structure_crate_model_signal_decoder(
&mut object_41,
item_40,
)?;
object_41.finish();
}
}
array_39.finish();
}
if let Some(var_42) = &input.network_interfaces {
let mut array_43 = object.key("networkInterfaces").start_array();
for item_44 in var_42 {
{
#[allow(unused_mut)]
let mut object_45 = array_43.value().start_object();
crate::json_ser::serialize_structure_crate_model_network_interface(
&mut object_45,
item_44,
)?;
object_45.finish();
}
}
array_43.finish();
}
if let Some(var_46) = &input.tags {
let mut array_47 = object.key("tags").start_array();
for item_48 in var_46 {
{
#[allow(unused_mut)]
let mut object_49 = array_47.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_49, item_48)?;
object_49.finish();
}
}
array_47.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_fleet_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFleetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_50) = &input.fleet_id {
object.key("fleetId").string(var_50.as_str());
}
if let Some(var_51) = &input.description {
object.key("description").string(var_51.as_str());
}
if let Some(var_52) = &input.signal_catalog_arn {
object.key("signalCatalogArn").string(var_52.as_str());
}
if let Some(var_53) = &input.tags {
let mut array_54 = object.key("tags").start_array();
for item_55 in var_53 {
{
#[allow(unused_mut)]
let mut object_56 = array_54.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_56, item_55)?;
object_56.finish();
}
}
array_54.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_model_manifest_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateModelManifestInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_57) = &input.name {
object.key("name").string(var_57.as_str());
}
if let Some(var_58) = &input.description {
object.key("description").string(var_58.as_str());
}
if let Some(var_59) = &input.nodes {
let mut array_60 = object.key("nodes").start_array();
for item_61 in var_59 {
{
array_60.value().string(item_61.as_str());
}
}
array_60.finish();
}
if let Some(var_62) = &input.signal_catalog_arn {
object.key("signalCatalogArn").string(var_62.as_str());
}
if let Some(var_63) = &input.tags {
let mut array_64 = object.key("tags").start_array();
for item_65 in var_63 {
{
#[allow(unused_mut)]
let mut object_66 = array_64.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_66, item_65)?;
object_66.finish();
}
}
array_64.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_signal_catalog_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSignalCatalogInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_67) = &input.name {
object.key("name").string(var_67.as_str());
}
if let Some(var_68) = &input.description {
object.key("description").string(var_68.as_str());
}
if let Some(var_69) = &input.nodes {
let mut array_70 = object.key("nodes").start_array();
for item_71 in var_69 {
{
#[allow(unused_mut)]
let mut object_72 = array_70.value().start_object();
crate::json_ser::serialize_union_crate_model_node(&mut object_72, item_71)?;
object_72.finish();
}
}
array_70.finish();
}
if let Some(var_73) = &input.tags {
let mut array_74 = object.key("tags").start_array();
for item_75 in var_73 {
{
#[allow(unused_mut)]
let mut object_76 = array_74.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_76, item_75)?;
object_76.finish();
}
}
array_74.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_vehicle_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateVehicleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_77) = &input.vehicle_name {
object.key("vehicleName").string(var_77.as_str());
}
if let Some(var_78) = &input.model_manifest_arn {
object.key("modelManifestArn").string(var_78.as_str());
}
if let Some(var_79) = &input.decoder_manifest_arn {
object.key("decoderManifestArn").string(var_79.as_str());
}
if let Some(var_80) = &input.attributes {
#[allow(unused_mut)]
let mut object_81 = object.key("attributes").start_object();
for (key_82, value_83) in var_80 {
{
object_81.key(key_82.as_str()).string(value_83.as_str());
}
}
object_81.finish();
}
if let Some(var_84) = &input.association_behavior {
object.key("associationBehavior").string(var_84.as_str());
}
if let Some(var_85) = &input.tags {
let mut array_86 = object.key("tags").start_array();
for item_87 in var_85 {
{
#[allow(unused_mut)]
let mut object_88 = array_86.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_88, item_87)?;
object_88.finish();
}
}
array_86.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_campaign_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteCampaignInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_89) = &input.name {
object.key("name").string(var_89.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_decoder_manifest_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteDecoderManifestInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_90) = &input.name {
object.key("name").string(var_90.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_fleet_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteFleetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_91) = &input.fleet_id {
object.key("fleetId").string(var_91.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_model_manifest_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteModelManifestInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_92) = &input.name {
object.key("name").string(var_92.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_signal_catalog_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteSignalCatalogInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_93) = &input.name {
object.key("name").string(var_93.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_vehicle_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteVehicleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_94) = &input.vehicle_name {
object.key("vehicleName").string(var_94.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_vehicle_fleet_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateVehicleFleetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_95) = &input.vehicle_name {
object.key("vehicleName").string(var_95.as_str());
}
if let Some(var_96) = &input.fleet_id {
object.key("fleetId").string(var_96.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_campaign_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetCampaignInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_97) = &input.name {
object.key("name").string(var_97.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_decoder_manifest_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetDecoderManifestInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_98) = &input.name {
object.key("name").string(var_98.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_fleet_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetFleetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_99) = &input.fleet_id {
object.key("fleetId").string(var_99.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_model_manifest_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetModelManifestInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_100) = &input.name {
object.key("name").string(var_100.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_signal_catalog_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetSignalCatalogInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_101) = &input.name {
object.key("name").string(var_101.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_vehicle_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetVehicleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_102) = &input.vehicle_name {
object.key("vehicleName").string(var_102.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_vehicle_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetVehicleStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_103) = &input.next_token {
object.key("nextToken").string(var_103.as_str());
}
if let Some(var_104) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_104).into()),
);
}
if let Some(var_105) = &input.vehicle_name {
object.key("vehicleName").string(var_105.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_import_decoder_manifest_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ImportDecoderManifestInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_106) = &input.name {
object.key("name").string(var_106.as_str());
}
if let Some(var_107) = &input.network_file_definitions {
let mut array_108 = object.key("networkFileDefinitions").start_array();
for item_109 in var_107 {
{
#[allow(unused_mut)]
let mut object_110 = array_108.value().start_object();
crate::json_ser::serialize_union_crate_model_network_file_definition(
&mut object_110,
item_109,
)?;
object_110.finish();
}
}
array_108.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_import_signal_catalog_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ImportSignalCatalogInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_111) = &input.name {
object.key("name").string(var_111.as_str());
}
if let Some(var_112) = &input.description {
object.key("description").string(var_112.as_str());
}
if let Some(var_113) = &input.vss {
#[allow(unused_mut)]
let mut object_114 = object.key("vss").start_object();
crate::json_ser::serialize_union_crate_model_formatted_vss(&mut object_114, var_113)?;
object_114.finish();
}
if let Some(var_115) = &input.tags {
let mut array_116 = object.key("tags").start_array();
for item_117 in var_115 {
{
#[allow(unused_mut)]
let mut object_118 = array_116.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_118, item_117)?;
object_118.finish();
}
}
array_116.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_campaigns_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListCampaignsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_119) = &input.next_token {
object.key("nextToken").string(var_119.as_str());
}
if let Some(var_120) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_120).into()),
);
}
if let Some(var_121) = &input.status {
object.key("status").string(var_121.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_decoder_manifest_network_interfaces_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDecoderManifestNetworkInterfacesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_122) = &input.name {
object.key("name").string(var_122.as_str());
}
if let Some(var_123) = &input.next_token {
object.key("nextToken").string(var_123.as_str());
}
if let Some(var_124) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_124).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_decoder_manifests_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDecoderManifestsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_125) = &input.model_manifest_arn {
object.key("modelManifestArn").string(var_125.as_str());
}
if let Some(var_126) = &input.next_token {
object.key("nextToken").string(var_126.as_str());
}
if let Some(var_127) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_127).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_decoder_manifest_signals_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDecoderManifestSignalsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_128) = &input.name {
object.key("name").string(var_128.as_str());
}
if let Some(var_129) = &input.next_token {
object.key("nextToken").string(var_129.as_str());
}
if let Some(var_130) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_130).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_fleets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListFleetsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_131) = &input.next_token {
object.key("nextToken").string(var_131.as_str());
}
if let Some(var_132) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_132).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_fleets_for_vehicle_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListFleetsForVehicleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_133) = &input.vehicle_name {
object.key("vehicleName").string(var_133.as_str());
}
if let Some(var_134) = &input.next_token {
object.key("nextToken").string(var_134.as_str());
}
if let Some(var_135) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_135).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_model_manifest_nodes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListModelManifestNodesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_136) = &input.name {
object.key("name").string(var_136.as_str());
}
if let Some(var_137) = &input.next_token {
object.key("nextToken").string(var_137.as_str());
}
if let Some(var_138) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_138).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_model_manifests_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListModelManifestsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_139) = &input.signal_catalog_arn {
object.key("signalCatalogArn").string(var_139.as_str());
}
if let Some(var_140) = &input.next_token {
object.key("nextToken").string(var_140.as_str());
}
if let Some(var_141) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_141).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_signal_catalog_nodes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListSignalCatalogNodesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_142) = &input.name {
object.key("name").string(var_142.as_str());
}
if let Some(var_143) = &input.next_token {
object.key("nextToken").string(var_143.as_str());
}
if let Some(var_144) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_144).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_signal_catalogs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListSignalCatalogsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_145) = &input.next_token {
object.key("nextToken").string(var_145.as_str());
}
if let Some(var_146) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_146).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_tags_for_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTagsForResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_147) = &input.resource_arn {
object.key("ResourceARN").string(var_147.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_vehicles_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListVehiclesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_148) = &input.model_manifest_arn {
object.key("modelManifestArn").string(var_148.as_str());
}
if let Some(var_149) = &input.next_token {
object.key("nextToken").string(var_149.as_str());
}
if let Some(var_150) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_150).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_vehicles_in_fleet_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListVehiclesInFleetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_151) = &input.fleet_id {
object.key("fleetId").string(var_151.as_str());
}
if let Some(var_152) = &input.next_token {
object.key("nextToken").string(var_152.as_str());
}
if let Some(var_153) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_153).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_logging_options_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutLoggingOptionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_154) = &input.cloud_watch_log_delivery {
#[allow(unused_mut)]
let mut object_155 = object.key("cloudWatchLogDelivery").start_object();
crate::json_ser::serialize_structure_crate_model_cloud_watch_log_delivery_options(
&mut object_155,
var_154,
)?;
object_155.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_register_account_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RegisterAccountInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_156) = &input.timestream_resources {
#[allow(unused_mut)]
let mut object_157 = object.key("timestreamResources").start_object();
crate::json_ser::serialize_structure_crate_model_timestream_resources(
&mut object_157,
var_156,
)?;
object_157.finish();
}
if let Some(var_158) = &input.iam_resources {
#[allow(unused_mut)]
let mut object_159 = object.key("iamResources").start_object();
crate::json_ser::serialize_structure_crate_model_iam_resources(&mut object_159, var_158)?;
object_159.finish();
}
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::error::SerializationError> {
if let Some(var_160) = &input.resource_arn {
object.key("ResourceARN").string(var_160.as_str());
}
if let Some(var_161) = &input.tags {
let mut array_162 = object.key("Tags").start_array();
for item_163 in var_161 {
{
#[allow(unused_mut)]
let mut object_164 = array_162.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_164, item_163)?;
object_164.finish();
}
}
array_162.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_untag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UntagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_165) = &input.resource_arn {
object.key("ResourceARN").string(var_165.as_str());
}
if let Some(var_166) = &input.tag_keys {
let mut array_167 = object.key("TagKeys").start_array();
for item_168 in var_166 {
{
array_167.value().string(item_168.as_str());
}
}
array_167.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_campaign_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateCampaignInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_169) = &input.name {
object.key("name").string(var_169.as_str());
}
if let Some(var_170) = &input.description {
object.key("description").string(var_170.as_str());
}
if let Some(var_171) = &input.data_extra_dimensions {
let mut array_172 = object.key("dataExtraDimensions").start_array();
for item_173 in var_171 {
{
array_172.value().string(item_173.as_str());
}
}
array_172.finish();
}
if let Some(var_174) = &input.action {
object.key("action").string(var_174.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_decoder_manifest_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDecoderManifestInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_175) = &input.name {
object.key("name").string(var_175.as_str());
}
if let Some(var_176) = &input.description {
object.key("description").string(var_176.as_str());
}
if let Some(var_177) = &input.signal_decoders_to_add {
let mut array_178 = object.key("signalDecodersToAdd").start_array();
for item_179 in var_177 {
{
#[allow(unused_mut)]
let mut object_180 = array_178.value().start_object();
crate::json_ser::serialize_structure_crate_model_signal_decoder(
&mut object_180,
item_179,
)?;
object_180.finish();
}
}
array_178.finish();
}
if let Some(var_181) = &input.signal_decoders_to_update {
let mut array_182 = object.key("signalDecodersToUpdate").start_array();
for item_183 in var_181 {
{
#[allow(unused_mut)]
let mut object_184 = array_182.value().start_object();
crate::json_ser::serialize_structure_crate_model_signal_decoder(
&mut object_184,
item_183,
)?;
object_184.finish();
}
}
array_182.finish();
}
if let Some(var_185) = &input.signal_decoders_to_remove {
let mut array_186 = object.key("signalDecodersToRemove").start_array();
for item_187 in var_185 {
{
array_186.value().string(item_187.as_str());
}
}
array_186.finish();
}
if let Some(var_188) = &input.network_interfaces_to_add {
let mut array_189 = object.key("networkInterfacesToAdd").start_array();
for item_190 in var_188 {
{
#[allow(unused_mut)]
let mut object_191 = array_189.value().start_object();
crate::json_ser::serialize_structure_crate_model_network_interface(
&mut object_191,
item_190,
)?;
object_191.finish();
}
}
array_189.finish();
}
if let Some(var_192) = &input.network_interfaces_to_update {
let mut array_193 = object.key("networkInterfacesToUpdate").start_array();
for item_194 in var_192 {
{
#[allow(unused_mut)]
let mut object_195 = array_193.value().start_object();
crate::json_ser::serialize_structure_crate_model_network_interface(
&mut object_195,
item_194,
)?;
object_195.finish();
}
}
array_193.finish();
}
if let Some(var_196) = &input.network_interfaces_to_remove {
let mut array_197 = object.key("networkInterfacesToRemove").start_array();
for item_198 in var_196 {
{
array_197.value().string(item_198.as_str());
}
}
array_197.finish();
}
if let Some(var_199) = &input.status {
object.key("status").string(var_199.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_fleet_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFleetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_200) = &input.fleet_id {
object.key("fleetId").string(var_200.as_str());
}
if let Some(var_201) = &input.description {
object.key("description").string(var_201.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_model_manifest_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateModelManifestInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_202) = &input.name {
object.key("name").string(var_202.as_str());
}
if let Some(var_203) = &input.description {
object.key("description").string(var_203.as_str());
}
if let Some(var_204) = &input.nodes_to_add {
let mut array_205 = object.key("nodesToAdd").start_array();
for item_206 in var_204 {
{
array_205.value().string(item_206.as_str());
}
}
array_205.finish();
}
if let Some(var_207) = &input.nodes_to_remove {
let mut array_208 = object.key("nodesToRemove").start_array();
for item_209 in var_207 {
{
array_208.value().string(item_209.as_str());
}
}
array_208.finish();
}
if let Some(var_210) = &input.status {
object.key("status").string(var_210.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_signal_catalog_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSignalCatalogInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_211) = &input.name {
object.key("name").string(var_211.as_str());
}
if let Some(var_212) = &input.description {
object.key("description").string(var_212.as_str());
}
if let Some(var_213) = &input.nodes_to_add {
let mut array_214 = object.key("nodesToAdd").start_array();
for item_215 in var_213 {
{
#[allow(unused_mut)]
let mut object_216 = array_214.value().start_object();
crate::json_ser::serialize_union_crate_model_node(&mut object_216, item_215)?;
object_216.finish();
}
}
array_214.finish();
}
if let Some(var_217) = &input.nodes_to_update {
let mut array_218 = object.key("nodesToUpdate").start_array();
for item_219 in var_217 {
{
#[allow(unused_mut)]
let mut object_220 = array_218.value().start_object();
crate::json_ser::serialize_union_crate_model_node(&mut object_220, item_219)?;
object_220.finish();
}
}
array_218.finish();
}
if let Some(var_221) = &input.nodes_to_remove {
let mut array_222 = object.key("nodesToRemove").start_array();
for item_223 in var_221 {
{
array_222.value().string(item_223.as_str());
}
}
array_222.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_vehicle_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateVehicleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_224) = &input.vehicle_name {
object.key("vehicleName").string(var_224.as_str());
}
if let Some(var_225) = &input.model_manifest_arn {
object.key("modelManifestArn").string(var_225.as_str());
}
if let Some(var_226) = &input.decoder_manifest_arn {
object.key("decoderManifestArn").string(var_226.as_str());
}
if let Some(var_227) = &input.attributes {
#[allow(unused_mut)]
let mut object_228 = object.key("attributes").start_object();
for (key_229, value_230) in var_227 {
{
object_228.key(key_229.as_str()).string(value_230.as_str());
}
}
object_228.finish();
}
if let Some(var_231) = &input.attribute_update_mode {
object.key("attributeUpdateMode").string(var_231.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_create_vehicle_request_item(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateVehicleRequestItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_232) = &input.vehicle_name {
object.key("vehicleName").string(var_232.as_str());
}
if let Some(var_233) = &input.model_manifest_arn {
object.key("modelManifestArn").string(var_233.as_str());
}
if let Some(var_234) = &input.decoder_manifest_arn {
object.key("decoderManifestArn").string(var_234.as_str());
}
if let Some(var_235) = &input.attributes {
#[allow(unused_mut)]
let mut object_236 = object.key("attributes").start_object();
for (key_237, value_238) in var_235 {
{
object_236.key(key_237.as_str()).string(value_238.as_str());
}
}
object_236.finish();
}
if let Some(var_239) = &input.association_behavior {
object.key("associationBehavior").string(var_239.as_str());
}
if let Some(var_240) = &input.tags {
let mut array_241 = object.key("tags").start_array();
for item_242 in var_240 {
{
#[allow(unused_mut)]
let mut object_243 = array_241.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_243, item_242)?;
object_243.finish();
}
}
array_241.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_update_vehicle_request_item(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateVehicleRequestItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_244) = &input.vehicle_name {
object.key("vehicleName").string(var_244.as_str());
}
if let Some(var_245) = &input.model_manifest_arn {
object.key("modelManifestArn").string(var_245.as_str());
}
if let Some(var_246) = &input.decoder_manifest_arn {
object.key("decoderManifestArn").string(var_246.as_str());
}
if let Some(var_247) = &input.attributes {
#[allow(unused_mut)]
let mut object_248 = object.key("attributes").start_object();
for (key_249, value_250) in var_247 {
{
object_248.key(key_249.as_str()).string(value_250.as_str());
}
}
object_248.finish();
}
if let Some(var_251) = &input.attribute_update_mode {
object.key("attributeUpdateMode").string(var_251.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_signal_information(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SignalInformation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_252) = &input.name {
object.key("name").string(var_252.as_str());
}
if let Some(var_253) = &input.max_sample_count {
object.key("maxSampleCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_253).into()),
);
}
if let Some(var_254) = &input.minimum_sampling_interval_ms {
object.key("minimumSamplingIntervalMs").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_254).into()),
);
}
Ok(())
}
pub fn serialize_union_crate_model_collection_scheme(
object_27: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CollectionScheme,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::CollectionScheme::TimeBasedCollectionScheme(inner) => {
#[allow(unused_mut)]
let mut object_255 = object_27.key("timeBasedCollectionScheme").start_object();
crate::json_ser::serialize_structure_crate_model_time_based_collection_scheme(
&mut object_255,
inner,
)?;
object_255.finish();
}
crate::model::CollectionScheme::ConditionBasedCollectionScheme(inner) => {
#[allow(unused_mut)]
let mut object_256 = object_27
.key("conditionBasedCollectionScheme")
.start_object();
crate::json_ser::serialize_structure_crate_model_condition_based_collection_scheme(
&mut object_256,
inner,
)?;
object_256.finish();
}
crate::model::CollectionScheme::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"CollectionScheme",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_257) = &input.key {
object.key("Key").string(var_257.as_str());
}
if let Some(var_258) = &input.value {
object.key("Value").string(var_258.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_signal_decoder(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SignalDecoder,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_259) = &input.fully_qualified_name {
object.key("fullyQualifiedName").string(var_259.as_str());
}
if let Some(var_260) = &input.r#type {
object.key("type").string(var_260.as_str());
}
if let Some(var_261) = &input.interface_id {
object.key("interfaceId").string(var_261.as_str());
}
if let Some(var_262) = &input.can_signal {
#[allow(unused_mut)]
let mut object_263 = object.key("canSignal").start_object();
crate::json_ser::serialize_structure_crate_model_can_signal(&mut object_263, var_262)?;
object_263.finish();
}
if let Some(var_264) = &input.obd_signal {
#[allow(unused_mut)]
let mut object_265 = object.key("obdSignal").start_object();
crate::json_ser::serialize_structure_crate_model_obd_signal(&mut object_265, var_264)?;
object_265.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_network_interface(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NetworkInterface,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_266) = &input.interface_id {
object.key("interfaceId").string(var_266.as_str());
}
if let Some(var_267) = &input.r#type {
object.key("type").string(var_267.as_str());
}
if let Some(var_268) = &input.can_interface {
#[allow(unused_mut)]
let mut object_269 = object.key("canInterface").start_object();
crate::json_ser::serialize_structure_crate_model_can_interface(&mut object_269, var_268)?;
object_269.finish();
}
if let Some(var_270) = &input.obd_interface {
#[allow(unused_mut)]
let mut object_271 = object.key("obdInterface").start_object();
crate::json_ser::serialize_structure_crate_model_obd_interface(&mut object_271, var_270)?;
object_271.finish();
}
Ok(())
}
pub fn serialize_union_crate_model_node(
object_72: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Node,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::Node::Branch(inner) => {
#[allow(unused_mut)]
let mut object_272 = object_72.key("branch").start_object();
crate::json_ser::serialize_structure_crate_model_branch(&mut object_272, inner)?;
object_272.finish();
}
crate::model::Node::Sensor(inner) => {
#[allow(unused_mut)]
let mut object_273 = object_72.key("sensor").start_object();
crate::json_ser::serialize_structure_crate_model_sensor(&mut object_273, inner)?;
object_273.finish();
}
crate::model::Node::Actuator(inner) => {
#[allow(unused_mut)]
let mut object_274 = object_72.key("actuator").start_object();
crate::json_ser::serialize_structure_crate_model_actuator(&mut object_274, inner)?;
object_274.finish();
}
crate::model::Node::Attribute(inner) => {
#[allow(unused_mut)]
let mut object_275 = object_72.key("attribute").start_object();
crate::json_ser::serialize_structure_crate_model_attribute(&mut object_275, inner)?;
object_275.finish();
}
crate::model::Node::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant("Node"),
)
}
}
Ok(())
}
pub fn serialize_union_crate_model_network_file_definition(
object_110: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NetworkFileDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::NetworkFileDefinition::CanDbc(inner) => {
#[allow(unused_mut)]
let mut object_276 = object_110.key("canDbc").start_object();
crate::json_ser::serialize_structure_crate_model_can_dbc_definition(
&mut object_276,
inner,
)?;
object_276.finish();
}
crate::model::NetworkFileDefinition::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"NetworkFileDefinition",
),
)
}
}
Ok(())
}
pub fn serialize_union_crate_model_formatted_vss(
object_114: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FormattedVss,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::FormattedVss::VssJson(inner) => {
object_114.key("vssJson").string(inner.as_str());
}
crate::model::FormattedVss::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"FormattedVss",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_cloud_watch_log_delivery_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CloudWatchLogDeliveryOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_277) = &input.log_type {
object.key("logType").string(var_277.as_str());
}
if let Some(var_278) = &input.log_group_name {
object.key("logGroupName").string(var_278.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_timestream_resources(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TimestreamResources,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_279) = &input.timestream_database_name {
object
.key("timestreamDatabaseName")
.string(var_279.as_str());
}
if let Some(var_280) = &input.timestream_table_name {
object.key("timestreamTableName").string(var_280.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_iam_resources(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IamResources,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_281) = &input.role_arn {
object.key("roleArn").string(var_281.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_time_based_collection_scheme(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TimeBasedCollectionScheme,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_282) = &input.period_ms {
object.key("periodMs").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_282).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_condition_based_collection_scheme(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConditionBasedCollectionScheme,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_283) = &input.expression {
object.key("expression").string(var_283.as_str());
}
if let Some(var_284) = &input.minimum_trigger_interval_ms {
object.key("minimumTriggerIntervalMs").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_284).into()),
);
}
if let Some(var_285) = &input.trigger_mode {
object.key("triggerMode").string(var_285.as_str());
}
if let Some(var_286) = &input.condition_language_version {
object.key("conditionLanguageVersion").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_286).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_can_signal(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CanSignal,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("messageId").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.message_id).into()),
);
}
{
object.key("isBigEndian").boolean(input.is_big_endian);
}
{
object.key("isSigned").boolean(input.is_signed);
}
{
object.key("startBit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.start_bit).into()),
);
}
if let Some(var_287) = &input.offset {
object.key("offset").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_287).into()),
);
}
if let Some(var_288) = &input.factor {
object.key("factor").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_288).into()),
);
}
{
object.key("length").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.length).into()),
);
}
if let Some(var_289) = &input.name {
object.key("name").string(var_289.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_obd_signal(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ObdSignal,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("pidResponseLength").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.pid_response_length).into()),
);
}
{
object.key("serviceMode").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.service_mode).into()),
);
}
{
object.key("pid").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.pid).into()),
);
}
if let Some(var_290) = &input.scaling {
object.key("scaling").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_290).into()),
);
}
if let Some(var_291) = &input.offset {
object.key("offset").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_291).into()),
);
}
{
object.key("startByte").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.start_byte).into()),
);
}
if let Some(var_292) = &input.byte_length {
object.key("byteLength").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_292).into()),
);
}
if input.bit_right_shift != 0 {
object.key("bitRightShift").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.bit_right_shift).into()),
);
}
if let Some(var_293) = &input.bit_mask_length {
object.key("bitMaskLength").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_293).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_can_interface(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CanInterface,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_294) = &input.name {
object.key("name").string(var_294.as_str());
}
if let Some(var_295) = &input.protocol_name {
object.key("protocolName").string(var_295.as_str());
}
if let Some(var_296) = &input.protocol_version {
object.key("protocolVersion").string(var_296.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_obd_interface(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ObdInterface,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_297) = &input.name {
object.key("name").string(var_297.as_str());
}
{
object.key("requestMessageId").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.request_message_id).into()),
);
}
if let Some(var_298) = &input.obd_standard {
object.key("obdStandard").string(var_298.as_str());
}
if input.pid_request_interval_seconds != 0 {
object.key("pidRequestIntervalSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.pid_request_interval_seconds).into()),
);
}
if input.dtc_request_interval_seconds != 0 {
object.key("dtcRequestIntervalSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.dtc_request_interval_seconds).into()),
);
}
if input.use_extended_ids {
object.key("useExtendedIds").boolean(input.use_extended_ids);
}
if input.has_transmission_ecu {
object
.key("hasTransmissionEcu")
.boolean(input.has_transmission_ecu);
}
Ok(())
}
pub fn serialize_structure_crate_model_branch(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Branch,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_299) = &input.fully_qualified_name {
object.key("fullyQualifiedName").string(var_299.as_str());
}
if let Some(var_300) = &input.description {
object.key("description").string(var_300.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sensor(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Sensor,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_301) = &input.fully_qualified_name {
object.key("fullyQualifiedName").string(var_301.as_str());
}
if let Some(var_302) = &input.data_type {
object.key("dataType").string(var_302.as_str());
}
if let Some(var_303) = &input.description {
object.key("description").string(var_303.as_str());
}
if let Some(var_304) = &input.unit {
object.key("unit").string(var_304.as_str());
}
if let Some(var_305) = &input.allowed_values {
let mut array_306 = object.key("allowedValues").start_array();
for item_307 in var_305 {
{
array_306.value().string(item_307.as_str());
}
}
array_306.finish();
}
if let Some(var_308) = &input.min {
object.key("min").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_308).into()),
);
}
if let Some(var_309) = &input.max {
object.key("max").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_309).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_actuator(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Actuator,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_310) = &input.fully_qualified_name {
object.key("fullyQualifiedName").string(var_310.as_str());
}
if let Some(var_311) = &input.data_type {
object.key("dataType").string(var_311.as_str());
}
if let Some(var_312) = &input.description {
object.key("description").string(var_312.as_str());
}
if let Some(var_313) = &input.unit {
object.key("unit").string(var_313.as_str());
}
if let Some(var_314) = &input.allowed_values {
let mut array_315 = object.key("allowedValues").start_array();
for item_316 in var_314 {
{
array_315.value().string(item_316.as_str());
}
}
array_315.finish();
}
if let Some(var_317) = &input.min {
object.key("min").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_317).into()),
);
}
if let Some(var_318) = &input.max {
object.key("max").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_318).into()),
);
}
if let Some(var_319) = &input.assigned_value {
object.key("assignedValue").string(var_319.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_attribute(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Attribute,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_320) = &input.fully_qualified_name {
object.key("fullyQualifiedName").string(var_320.as_str());
}
if let Some(var_321) = &input.data_type {
object.key("dataType").string(var_321.as_str());
}
if let Some(var_322) = &input.description {
object.key("description").string(var_322.as_str());
}
if let Some(var_323) = &input.unit {
object.key("unit").string(var_323.as_str());
}
if let Some(var_324) = &input.allowed_values {
let mut array_325 = object.key("allowedValues").start_array();
for item_326 in var_324 {
{
array_325.value().string(item_326.as_str());
}
}
array_325.finish();
}
if let Some(var_327) = &input.min {
object.key("min").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_327).into()),
);
}
if let Some(var_328) = &input.max {
object.key("max").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_328).into()),
);
}
if let Some(var_329) = &input.assigned_value {
object.key("assignedValue").string(var_329.as_str());
}
if let Some(var_330) = &input.default_value {
object.key("defaultValue").string(var_330.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_can_dbc_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CanDbcDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_331) = &input.network_interface {
object.key("networkInterface").string(var_331.as_str());
}
if let Some(var_332) = &input.can_dbc_files {
let mut array_333 = object.key("canDbcFiles").start_array();
for item_334 in var_332 {
{
array_333
.value()
.string_unchecked(&aws_smithy_types::base64::encode(item_334));
}
}
array_333.finish();
}
if let Some(var_335) = &input.signals_map {
#[allow(unused_mut)]
let mut object_336 = object.key("signalsMap").start_object();
for (key_337, value_338) in var_335 {
{
object_336.key(key_337.as_str()).string(value_338.as_str());
}
}
object_336.finish();
}
Ok(())
}