pub fn serialize_structure_crate_input_associate_gateway_to_server_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateGatewayToServerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.gateway_arn {
object.key("GatewayArn").string(var_1.as_str());
}
if let Some(var_2) = &input.server_arn {
object.key("ServerArn").string(var_2.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_gateway_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateGatewayInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3) = &input.activation_key {
object.key("ActivationKey").string(var_3.as_str());
}
if let Some(var_4) = &input.gateway_display_name {
object.key("GatewayDisplayName").string(var_4.as_str());
}
if let Some(var_5) = &input.gateway_type {
object.key("GatewayType").string(var_5.as_str());
}
if let Some(var_6) = &input.tags {
let mut array_7 = object.key("Tags").start_array();
for item_8 in var_6 {
{
#[allow(unused_mut)]
let mut object_9 = array_7.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_9, item_8)?;
object_9.finish();
}
}
array_7.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_gateway_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteGatewayInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_10) = &input.gateway_arn {
object.key("GatewayArn").string(var_10.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_hypervisor_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteHypervisorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_11) = &input.hypervisor_arn {
object.key("HypervisorArn").string(var_11.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_gateway_from_server_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateGatewayFromServerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_12) = &input.gateway_arn {
object.key("GatewayArn").string(var_12.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_bandwidth_rate_limit_schedule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetBandwidthRateLimitScheduleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_13) = &input.gateway_arn {
object.key("GatewayArn").string(var_13.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_gateway_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetGatewayInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_14) = &input.gateway_arn {
object.key("GatewayArn").string(var_14.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_hypervisor_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetHypervisorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_15) = &input.hypervisor_arn {
object.key("HypervisorArn").string(var_15.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_hypervisor_property_mappings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetHypervisorPropertyMappingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_16) = &input.hypervisor_arn {
object.key("HypervisorArn").string(var_16.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_virtual_machine_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetVirtualMachineInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_17) = &input.resource_arn {
object.key("ResourceArn").string(var_17.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_import_hypervisor_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ImportHypervisorConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_18) = &input.name {
object.key("Name").string(var_18.as_str());
}
if let Some(var_19) = &input.host {
object.key("Host").string(var_19.as_str());
}
if let Some(var_20) = &input.username {
object.key("Username").string(var_20.as_str());
}
if let Some(var_21) = &input.password {
object.key("Password").string(var_21.as_str());
}
if let Some(var_22) = &input.kms_key_arn {
object.key("KmsKeyArn").string(var_22.as_str());
}
if let Some(var_23) = &input.tags {
let mut array_24 = object.key("Tags").start_array();
for item_25 in var_23 {
{
#[allow(unused_mut)]
let mut object_26 = array_24.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_26, item_25)?;
object_26.finish();
}
}
array_24.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_gateways_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListGatewaysInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_27) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_27).into()),
);
}
if let Some(var_28) = &input.next_token {
object.key("NextToken").string(var_28.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_hypervisors_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListHypervisorsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_29) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_29).into()),
);
}
if let Some(var_30) = &input.next_token {
object.key("NextToken").string(var_30.as_str());
}
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_31) = &input.resource_arn {
object.key("ResourceArn").string(var_31.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_virtual_machines_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListVirtualMachinesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_32) = &input.hypervisor_arn {
object.key("HypervisorArn").string(var_32.as_str());
}
if let Some(var_33) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_33).into()),
);
}
if let Some(var_34) = &input.next_token {
object.key("NextToken").string(var_34.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_bandwidth_rate_limit_schedule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutBandwidthRateLimitScheduleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_35) = &input.gateway_arn {
object.key("GatewayArn").string(var_35.as_str());
}
if let Some(var_36) = &input.bandwidth_rate_limit_intervals {
let mut array_37 = object.key("BandwidthRateLimitIntervals").start_array();
for item_38 in var_36 {
{
#[allow(unused_mut)]
let mut object_39 = array_37.value().start_object();
crate::json_ser::serialize_structure_crate_model_bandwidth_rate_limit_interval(
&mut object_39,
item_38,
)?;
object_39.finish();
}
}
array_37.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_hypervisor_property_mappings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutHypervisorPropertyMappingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_40) = &input.hypervisor_arn {
object.key("HypervisorArn").string(var_40.as_str());
}
if let Some(var_41) = &input.vmware_to_aws_tag_mappings {
let mut array_42 = object.key("VmwareToAwsTagMappings").start_array();
for item_43 in var_41 {
{
#[allow(unused_mut)]
let mut object_44 = array_42.value().start_object();
crate::json_ser::serialize_structure_crate_model_vmware_to_aws_tag_mapping(
&mut object_44,
item_43,
)?;
object_44.finish();
}
}
array_42.finish();
}
if let Some(var_45) = &input.iam_role_arn {
object.key("IamRoleArn").string(var_45.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_maintenance_start_time_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutMaintenanceStartTimeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_46) = &input.gateway_arn {
object.key("GatewayArn").string(var_46.as_str());
}
if let Some(var_47) = &input.hour_of_day {
object.key("HourOfDay").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_47).into()),
);
}
if let Some(var_48) = &input.minute_of_hour {
object.key("MinuteOfHour").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_48).into()),
);
}
if let Some(var_49) = &input.day_of_week {
object.key("DayOfWeek").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_49).into()),
);
}
if let Some(var_50) = &input.day_of_month {
object.key("DayOfMonth").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_50).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_start_virtual_machines_metadata_sync_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartVirtualMachinesMetadataSyncInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_51) = &input.hypervisor_arn {
object.key("HypervisorArn").string(var_51.as_str());
}
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_52) = &input.resource_arn {
object.key("ResourceARN").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_test_hypervisor_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TestHypervisorConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_57) = &input.gateway_arn {
object.key("GatewayArn").string(var_57.as_str());
}
if let Some(var_58) = &input.host {
object.key("Host").string(var_58.as_str());
}
if let Some(var_59) = &input.username {
object.key("Username").string(var_59.as_str());
}
if let Some(var_60) = &input.password {
object.key("Password").string(var_60.as_str());
}
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_61) = &input.resource_arn {
object.key("ResourceARN").string(var_61.as_str());
}
if let Some(var_62) = &input.tag_keys {
let mut array_63 = object.key("TagKeys").start_array();
for item_64 in var_62 {
{
array_63.value().string(item_64.as_str());
}
}
array_63.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_gateway_information_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateGatewayInformationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_65) = &input.gateway_arn {
object.key("GatewayArn").string(var_65.as_str());
}
if let Some(var_66) = &input.gateway_display_name {
object.key("GatewayDisplayName").string(var_66.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_gateway_software_now_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateGatewaySoftwareNowInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_67) = &input.gateway_arn {
object.key("GatewayArn").string(var_67.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_hypervisor_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateHypervisorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_68) = &input.hypervisor_arn {
object.key("HypervisorArn").string(var_68.as_str());
}
if let Some(var_69) = &input.host {
object.key("Host").string(var_69.as_str());
}
if let Some(var_70) = &input.username {
object.key("Username").string(var_70.as_str());
}
if let Some(var_71) = &input.password {
object.key("Password").string(var_71.as_str());
}
if let Some(var_72) = &input.name {
object.key("Name").string(var_72.as_str());
}
if let Some(var_73) = &input.log_group_arn {
object.key("LogGroupArn").string(var_73.as_str());
}
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_74) = &input.key {
object.key("Key").string(var_74.as_str());
}
if let Some(var_75) = &input.value {
object.key("Value").string(var_75.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_bandwidth_rate_limit_interval(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BandwidthRateLimitInterval,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_76) = &input.average_upload_rate_limit_in_bits_per_sec {
object.key("AverageUploadRateLimitInBitsPerSec").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_76).into()),
);
}
if let Some(var_77) = &input.start_hour_of_day {
object.key("StartHourOfDay").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_77).into()),
);
}
if let Some(var_78) = &input.end_hour_of_day {
object.key("EndHourOfDay").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_78).into()),
);
}
if let Some(var_79) = &input.start_minute_of_hour {
object.key("StartMinuteOfHour").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_79).into()),
);
}
if let Some(var_80) = &input.end_minute_of_hour {
object.key("EndMinuteOfHour").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_80).into()),
);
}
if let Some(var_81) = &input.days_of_week {
let mut array_82 = object.key("DaysOfWeek").start_array();
for item_83 in var_81 {
{
array_82.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*item_83).into()),
);
}
}
array_82.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_vmware_to_aws_tag_mapping(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VmwareToAwsTagMapping,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_84) = &input.vmware_category {
object.key("VmwareCategory").string(var_84.as_str());
}
if let Some(var_85) = &input.vmware_tag_name {
object.key("VmwareTagName").string(var_85.as_str());
}
if let Some(var_86) = &input.aws_tag_key {
object.key("AwsTagKey").string(var_86.as_str());
}
if let Some(var_87) = &input.aws_tag_value {
object.key("AwsTagValue").string(var_87.as_str());
}
Ok(())
}