pub fn serialize_structure_crate_input_associate_connect_peer_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateConnectPeerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.connect_peer_id {
object.key("ConnectPeerId").string(var_1.as_str());
}
if let Some(var_2) = &input.device_id {
object.key("DeviceId").string(var_2.as_str());
}
if let Some(var_3) = &input.link_id {
object.key("LinkId").string(var_3.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_customer_gateway_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateCustomerGatewayInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_4) = &input.customer_gateway_arn {
object.key("CustomerGatewayArn").string(var_4.as_str());
}
if let Some(var_5) = &input.device_id {
object.key("DeviceId").string(var_5.as_str());
}
if let Some(var_6) = &input.link_id {
object.key("LinkId").string(var_6.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_link_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateLinkInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_7) = &input.device_id {
object.key("DeviceId").string(var_7.as_str());
}
if let Some(var_8) = &input.link_id {
object.key("LinkId").string(var_8.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_transit_gateway_connect_peer_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateTransitGatewayConnectPeerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_9) = &input.device_id {
object.key("DeviceId").string(var_9.as_str());
}
if let Some(var_10) = &input.link_id {
object.key("LinkId").string(var_10.as_str());
}
if let Some(var_11) = &input.transit_gateway_connect_peer_arn {
object
.key("TransitGatewayConnectPeerArn")
.string(var_11.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_connect_attachment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateConnectAttachmentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_12) = &input.client_token {
object.key("ClientToken").string(var_12.as_str());
}
if let Some(var_13) = &input.core_network_id {
object.key("CoreNetworkId").string(var_13.as_str());
}
if let Some(var_14) = &input.edge_location {
object.key("EdgeLocation").string(var_14.as_str());
}
if let Some(var_15) = &input.options {
#[allow(unused_mut)]
let mut object_16 = object.key("Options").start_object();
crate::json_ser::serialize_structure_crate_model_connect_attachment_options(
&mut object_16,
var_15,
)?;
object_16.finish();
}
if let Some(var_17) = &input.tags {
let mut array_18 = object.key("Tags").start_array();
for item_19 in var_17 {
{
#[allow(unused_mut)]
let mut object_20 = array_18.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_20, item_19)?;
object_20.finish();
}
}
array_18.finish();
}
if let Some(var_21) = &input.transport_attachment_id {
object.key("TransportAttachmentId").string(var_21.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_connection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateConnectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_22) = &input.connected_device_id {
object.key("ConnectedDeviceId").string(var_22.as_str());
}
if let Some(var_23) = &input.connected_link_id {
object.key("ConnectedLinkId").string(var_23.as_str());
}
if let Some(var_24) = &input.description {
object.key("Description").string(var_24.as_str());
}
if let Some(var_25) = &input.device_id {
object.key("DeviceId").string(var_25.as_str());
}
if let Some(var_26) = &input.link_id {
object.key("LinkId").string(var_26.as_str());
}
if let Some(var_27) = &input.tags {
let mut array_28 = object.key("Tags").start_array();
for item_29 in var_27 {
{
#[allow(unused_mut)]
let mut object_30 = array_28.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_30, item_29)?;
object_30.finish();
}
}
array_28.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_connect_peer_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateConnectPeerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_31) = &input.bgp_options {
#[allow(unused_mut)]
let mut object_32 = object.key("BgpOptions").start_object();
crate::json_ser::serialize_structure_crate_model_bgp_options(&mut object_32, var_31)?;
object_32.finish();
}
if let Some(var_33) = &input.client_token {
object.key("ClientToken").string(var_33.as_str());
}
if let Some(var_34) = &input.connect_attachment_id {
object.key("ConnectAttachmentId").string(var_34.as_str());
}
if let Some(var_35) = &input.core_network_address {
object.key("CoreNetworkAddress").string(var_35.as_str());
}
if let Some(var_36) = &input.inside_cidr_blocks {
let mut array_37 = object.key("InsideCidrBlocks").start_array();
for item_38 in var_36 {
{
array_37.value().string(item_38.as_str());
}
}
array_37.finish();
}
if let Some(var_39) = &input.peer_address {
object.key("PeerAddress").string(var_39.as_str());
}
if let Some(var_40) = &input.tags {
let mut array_41 = object.key("Tags").start_array();
for item_42 in var_40 {
{
#[allow(unused_mut)]
let mut object_43 = array_41.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_43, item_42)?;
object_43.finish();
}
}
array_41.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_core_network_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateCoreNetworkInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_44) = &input.client_token {
object.key("ClientToken").string(var_44.as_str());
}
if let Some(var_45) = &input.description {
object.key("Description").string(var_45.as_str());
}
if let Some(var_46) = &input.global_network_id {
object.key("GlobalNetworkId").string(var_46.as_str());
}
if let Some(var_47) = &input.policy_document {
object.key("PolicyDocument").string(var_47.as_str());
}
if let Some(var_48) = &input.tags {
let mut array_49 = object.key("Tags").start_array();
for item_50 in var_48 {
{
#[allow(unused_mut)]
let mut object_51 = array_49.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_51, item_50)?;
object_51.finish();
}
}
array_49.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_device_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDeviceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_52) = &input.aws_location {
#[allow(unused_mut)]
let mut object_53 = object.key("AWSLocation").start_object();
crate::json_ser::serialize_structure_crate_model_aws_location(&mut object_53, var_52)?;
object_53.finish();
}
if let Some(var_54) = &input.description {
object.key("Description").string(var_54.as_str());
}
if let Some(var_55) = &input.location {
#[allow(unused_mut)]
let mut object_56 = object.key("Location").start_object();
crate::json_ser::serialize_structure_crate_model_location(&mut object_56, var_55)?;
object_56.finish();
}
if let Some(var_57) = &input.model {
object.key("Model").string(var_57.as_str());
}
if let Some(var_58) = &input.serial_number {
object.key("SerialNumber").string(var_58.as_str());
}
if let Some(var_59) = &input.site_id {
object.key("SiteId").string(var_59.as_str());
}
if let Some(var_60) = &input.tags {
let mut array_61 = object.key("Tags").start_array();
for item_62 in var_60 {
{
#[allow(unused_mut)]
let mut object_63 = array_61.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_63, item_62)?;
object_63.finish();
}
}
array_61.finish();
}
if let Some(var_64) = &input.r#type {
object.key("Type").string(var_64.as_str());
}
if let Some(var_65) = &input.vendor {
object.key("Vendor").string(var_65.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_global_network_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateGlobalNetworkInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_66) = &input.description {
object.key("Description").string(var_66.as_str());
}
if let Some(var_67) = &input.tags {
let mut array_68 = object.key("Tags").start_array();
for item_69 in var_67 {
{
#[allow(unused_mut)]
let mut object_70 = array_68.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_70, item_69)?;
object_70.finish();
}
}
array_68.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_link_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLinkInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_71) = &input.bandwidth {
#[allow(unused_mut)]
let mut object_72 = object.key("Bandwidth").start_object();
crate::json_ser::serialize_structure_crate_model_bandwidth(&mut object_72, var_71)?;
object_72.finish();
}
if let Some(var_73) = &input.description {
object.key("Description").string(var_73.as_str());
}
if let Some(var_74) = &input.provider {
object.key("Provider").string(var_74.as_str());
}
if let Some(var_75) = &input.site_id {
object.key("SiteId").string(var_75.as_str());
}
if let Some(var_76) = &input.tags {
let mut array_77 = object.key("Tags").start_array();
for item_78 in var_76 {
{
#[allow(unused_mut)]
let mut object_79 = array_77.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_79, item_78)?;
object_79.finish();
}
}
array_77.finish();
}
if let Some(var_80) = &input.r#type {
object.key("Type").string(var_80.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_site_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSiteInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_81) = &input.description {
object.key("Description").string(var_81.as_str());
}
if let Some(var_82) = &input.location {
#[allow(unused_mut)]
let mut object_83 = object.key("Location").start_object();
crate::json_ser::serialize_structure_crate_model_location(&mut object_83, var_82)?;
object_83.finish();
}
if let Some(var_84) = &input.tags {
let mut array_85 = object.key("Tags").start_array();
for item_86 in var_84 {
{
#[allow(unused_mut)]
let mut object_87 = array_85.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_87, item_86)?;
object_87.finish();
}
}
array_85.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_site_to_site_vpn_attachment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSiteToSiteVpnAttachmentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_88) = &input.client_token {
object.key("ClientToken").string(var_88.as_str());
}
if let Some(var_89) = &input.core_network_id {
object.key("CoreNetworkId").string(var_89.as_str());
}
if let Some(var_90) = &input.tags {
let mut array_91 = object.key("Tags").start_array();
for item_92 in var_90 {
{
#[allow(unused_mut)]
let mut object_93 = array_91.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_93, item_92)?;
object_93.finish();
}
}
array_91.finish();
}
if let Some(var_94) = &input.vpn_connection_arn {
object.key("VpnConnectionArn").string(var_94.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_transit_gateway_peering_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateTransitGatewayPeeringInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_95) = &input.client_token {
object.key("ClientToken").string(var_95.as_str());
}
if let Some(var_96) = &input.core_network_id {
object.key("CoreNetworkId").string(var_96.as_str());
}
if let Some(var_97) = &input.tags {
let mut array_98 = object.key("Tags").start_array();
for item_99 in var_97 {
{
#[allow(unused_mut)]
let mut object_100 = array_98.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_100, item_99)?;
object_100.finish();
}
}
array_98.finish();
}
if let Some(var_101) = &input.transit_gateway_arn {
object.key("TransitGatewayArn").string(var_101.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_transit_gateway_route_table_attachment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateTransitGatewayRouteTableAttachmentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_102) = &input.client_token {
object.key("ClientToken").string(var_102.as_str());
}
if let Some(var_103) = &input.peering_id {
object.key("PeeringId").string(var_103.as_str());
}
if let Some(var_104) = &input.tags {
let mut array_105 = object.key("Tags").start_array();
for item_106 in var_104 {
{
#[allow(unused_mut)]
let mut object_107 = array_105.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_107, item_106)?;
object_107.finish();
}
}
array_105.finish();
}
if let Some(var_108) = &input.transit_gateway_route_table_arn {
object
.key("TransitGatewayRouteTableArn")
.string(var_108.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_vpc_attachment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateVpcAttachmentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_109) = &input.client_token {
object.key("ClientToken").string(var_109.as_str());
}
if let Some(var_110) = &input.core_network_id {
object.key("CoreNetworkId").string(var_110.as_str());
}
if let Some(var_111) = &input.options {
#[allow(unused_mut)]
let mut object_112 = object.key("Options").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_options(&mut object_112, var_111)?;
object_112.finish();
}
if let Some(var_113) = &input.subnet_arns {
let mut array_114 = object.key("SubnetArns").start_array();
for item_115 in var_113 {
{
array_114.value().string(item_115.as_str());
}
}
array_114.finish();
}
if let Some(var_116) = &input.tags {
let mut array_117 = object.key("Tags").start_array();
for item_118 in var_116 {
{
#[allow(unused_mut)]
let mut object_119 = array_117.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_119, item_118)?;
object_119.finish();
}
}
array_117.finish();
}
if let Some(var_120) = &input.vpc_arn {
object.key("VpcArn").string(var_120.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_network_routes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetNetworkRoutesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_121) = &input.destination_filters {
#[allow(unused_mut)]
let mut object_122 = object.key("DestinationFilters").start_object();
for (key_123, value_124) in var_121 {
{
let mut array_125 = object_122.key(key_123.as_str()).start_array();
for item_126 in value_124 {
{
array_125.value().string(item_126.as_str());
}
}
array_125.finish();
}
}
object_122.finish();
}
if let Some(var_127) = &input.exact_cidr_matches {
let mut array_128 = object.key("ExactCidrMatches").start_array();
for item_129 in var_127 {
{
array_128.value().string(item_129.as_str());
}
}
array_128.finish();
}
if let Some(var_130) = &input.longest_prefix_matches {
let mut array_131 = object.key("LongestPrefixMatches").start_array();
for item_132 in var_130 {
{
array_131.value().string(item_132.as_str());
}
}
array_131.finish();
}
if let Some(var_133) = &input.prefix_list_ids {
let mut array_134 = object.key("PrefixListIds").start_array();
for item_135 in var_133 {
{
array_134.value().string(item_135.as_str());
}
}
array_134.finish();
}
if let Some(var_136) = &input.route_table_identifier {
#[allow(unused_mut)]
let mut object_137 = object.key("RouteTableIdentifier").start_object();
crate::json_ser::serialize_structure_crate_model_route_table_identifier(
&mut object_137,
var_136,
)?;
object_137.finish();
}
if let Some(var_138) = &input.states {
let mut array_139 = object.key("States").start_array();
for item_140 in var_138 {
{
array_139.value().string(item_140.as_str());
}
}
array_139.finish();
}
if let Some(var_141) = &input.subnet_of_matches {
let mut array_142 = object.key("SubnetOfMatches").start_array();
for item_143 in var_141 {
{
array_142.value().string(item_143.as_str());
}
}
array_142.finish();
}
if let Some(var_144) = &input.supernet_of_matches {
let mut array_145 = object.key("SupernetOfMatches").start_array();
for item_146 in var_144 {
{
array_145.value().string(item_146.as_str());
}
}
array_145.finish();
}
if let Some(var_147) = &input.types {
let mut array_148 = object.key("Types").start_array();
for item_149 in var_147 {
{
array_148.value().string(item_149.as_str());
}
}
array_148.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_core_network_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutCoreNetworkPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_150) = &input.client_token {
object.key("ClientToken").string(var_150.as_str());
}
if let Some(var_151) = &input.description {
object.key("Description").string(var_151.as_str());
}
if let Some(var_152) = &input.latest_version_id {
object.key("LatestVersionId").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_152).into()),
);
}
if let Some(var_153) = &input.policy_document {
object.key("PolicyDocument").string(var_153.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_resource_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutResourcePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_154) = &input.policy_document {
object.key("PolicyDocument").string(var_154.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_register_transit_gateway_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RegisterTransitGatewayInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_155) = &input.transit_gateway_arn {
object.key("TransitGatewayArn").string(var_155.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_organization_service_access_update_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartOrganizationServiceAccessUpdateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_156) = &input.action {
object.key("Action").string(var_156.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_route_analysis_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartRouteAnalysisInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_157) = &input.destination {
#[allow(unused_mut)]
let mut object_158 = object.key("Destination").start_object();
crate::json_ser::serialize_structure_crate_model_route_analysis_endpoint_options_specification(&mut object_158, var_157)?;
object_158.finish();
}
if input.include_return_path {
object
.key("IncludeReturnPath")
.boolean(input.include_return_path);
}
if let Some(var_159) = &input.source {
#[allow(unused_mut)]
let mut object_160 = object.key("Source").start_object();
crate::json_ser::serialize_structure_crate_model_route_analysis_endpoint_options_specification(&mut object_160, var_159)?;
object_160.finish();
}
if input.use_middleboxes {
object.key("UseMiddleboxes").boolean(input.use_middleboxes);
}
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_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_update_connection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateConnectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_165) = &input.connected_link_id {
object.key("ConnectedLinkId").string(var_165.as_str());
}
if let Some(var_166) = &input.description {
object.key("Description").string(var_166.as_str());
}
if let Some(var_167) = &input.link_id {
object.key("LinkId").string(var_167.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_core_network_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateCoreNetworkInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_168) = &input.description {
object.key("Description").string(var_168.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_device_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDeviceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_169) = &input.aws_location {
#[allow(unused_mut)]
let mut object_170 = object.key("AWSLocation").start_object();
crate::json_ser::serialize_structure_crate_model_aws_location(&mut object_170, var_169)?;
object_170.finish();
}
if let Some(var_171) = &input.description {
object.key("Description").string(var_171.as_str());
}
if let Some(var_172) = &input.location {
#[allow(unused_mut)]
let mut object_173 = object.key("Location").start_object();
crate::json_ser::serialize_structure_crate_model_location(&mut object_173, var_172)?;
object_173.finish();
}
if let Some(var_174) = &input.model {
object.key("Model").string(var_174.as_str());
}
if let Some(var_175) = &input.serial_number {
object.key("SerialNumber").string(var_175.as_str());
}
if let Some(var_176) = &input.site_id {
object.key("SiteId").string(var_176.as_str());
}
if let Some(var_177) = &input.r#type {
object.key("Type").string(var_177.as_str());
}
if let Some(var_178) = &input.vendor {
object.key("Vendor").string(var_178.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_global_network_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateGlobalNetworkInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_179) = &input.description {
object.key("Description").string(var_179.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_link_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateLinkInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_180) = &input.bandwidth {
#[allow(unused_mut)]
let mut object_181 = object.key("Bandwidth").start_object();
crate::json_ser::serialize_structure_crate_model_bandwidth(&mut object_181, var_180)?;
object_181.finish();
}
if let Some(var_182) = &input.description {
object.key("Description").string(var_182.as_str());
}
if let Some(var_183) = &input.provider {
object.key("Provider").string(var_183.as_str());
}
if let Some(var_184) = &input.r#type {
object.key("Type").string(var_184.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_network_resource_metadata_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateNetworkResourceMetadataInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_185) = &input.metadata {
#[allow(unused_mut)]
let mut object_186 = object.key("Metadata").start_object();
for (key_187, value_188) in var_185 {
{
object_186.key(key_187.as_str()).string(value_188.as_str());
}
}
object_186.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_site_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSiteInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_189) = &input.description {
object.key("Description").string(var_189.as_str());
}
if let Some(var_190) = &input.location {
#[allow(unused_mut)]
let mut object_191 = object.key("Location").start_object();
crate::json_ser::serialize_structure_crate_model_location(&mut object_191, var_190)?;
object_191.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_vpc_attachment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateVpcAttachmentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_192) = &input.add_subnet_arns {
let mut array_193 = object.key("AddSubnetArns").start_array();
for item_194 in var_192 {
{
array_193.value().string(item_194.as_str());
}
}
array_193.finish();
}
if let Some(var_195) = &input.options {
#[allow(unused_mut)]
let mut object_196 = object.key("Options").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_options(&mut object_196, var_195)?;
object_196.finish();
}
if let Some(var_197) = &input.remove_subnet_arns {
let mut array_198 = object.key("RemoveSubnetArns").start_array();
for item_199 in var_197 {
{
array_198.value().string(item_199.as_str());
}
}
array_198.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_connect_attachment_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConnectAttachmentOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_200) = &input.protocol {
object.key("Protocol").string(var_200.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_201) = &input.key {
object.key("Key").string(var_201.as_str());
}
if let Some(var_202) = &input.value {
object.key("Value").string(var_202.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_bgp_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BgpOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_203) = &input.peer_asn {
object.key("PeerAsn").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_203).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_location(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsLocation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_204) = &input.zone {
object.key("Zone").string(var_204.as_str());
}
if let Some(var_205) = &input.subnet_arn {
object.key("SubnetArn").string(var_205.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_location(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Location,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_206) = &input.address {
object.key("Address").string(var_206.as_str());
}
if let Some(var_207) = &input.latitude {
object.key("Latitude").string(var_207.as_str());
}
if let Some(var_208) = &input.longitude {
object.key("Longitude").string(var_208.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_bandwidth(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Bandwidth,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_209) = &input.upload_speed {
object.key("UploadSpeed").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_209).into()),
);
}
if let Some(var_210) = &input.download_speed {
object.key("DownloadSpeed").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_210).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_vpc_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VpcOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.ipv6_support {
object.key("Ipv6Support").boolean(input.ipv6_support);
}
if input.appliance_mode_support {
object
.key("ApplianceModeSupport")
.boolean(input.appliance_mode_support);
}
Ok(())
}
pub fn serialize_structure_crate_model_route_table_identifier(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RouteTableIdentifier,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_211) = &input.transit_gateway_route_table_arn {
object
.key("TransitGatewayRouteTableArn")
.string(var_211.as_str());
}
if let Some(var_212) = &input.core_network_segment_edge {
#[allow(unused_mut)]
let mut object_213 = object.key("CoreNetworkSegmentEdge").start_object();
crate::json_ser::serialize_structure_crate_model_core_network_segment_edge_identifier(
&mut object_213,
var_212,
)?;
object_213.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_route_analysis_endpoint_options_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RouteAnalysisEndpointOptionsSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_214) = &input.transit_gateway_attachment_arn {
object
.key("TransitGatewayAttachmentArn")
.string(var_214.as_str());
}
if let Some(var_215) = &input.ip_address {
object.key("IpAddress").string(var_215.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_core_network_segment_edge_identifier(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CoreNetworkSegmentEdgeIdentifier,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_216) = &input.core_network_id {
object.key("CoreNetworkId").string(var_216.as_str());
}
if let Some(var_217) = &input.segment_name {
object.key("SegmentName").string(var_217.as_str());
}
if let Some(var_218) = &input.edge_location {
object.key("EdgeLocation").string(var_218.as_str());
}
Ok(())
}