// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
pub fn serialize_structure_crate_input_create_gateway_route_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateGatewayRouteInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_1) = &input.client_token {
        object.key("clientToken").string(var_1.as_str());
    }
    if let Some(var_2) = &input.gateway_route_name {
        object.key("gatewayRouteName").string(var_2.as_str());
    }
    if let Some(var_3) = &input.spec {
        #[allow(unused_mut)]
        let mut object_4 = object.key("spec").start_object();
        crate::json_ser::serialize_structure_crate_model_gateway_route_spec(&mut object_4, var_3)?;
        object_4.finish();
    }
    if let Some(var_5) = &input.tags {
        let mut array_6 = object.key("tags").start_array();
        for item_7 in var_5 {
            {
                #[allow(unused_mut)]
                let mut object_8 = array_6.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag_ref(&mut object_8, item_7)?;
                object_8.finish();
            }
        }
        array_6.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_mesh_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateMeshInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_9) = &input.client_token {
        object.key("clientToken").string(var_9.as_str());
    }
    if let Some(var_10) = &input.mesh_name {
        object.key("meshName").string(var_10.as_str());
    }
    if let Some(var_11) = &input.spec {
        #[allow(unused_mut)]
        let mut object_12 = object.key("spec").start_object();
        crate::json_ser::serialize_structure_crate_model_mesh_spec(&mut object_12, var_11)?;
        object_12.finish();
    }
    if let Some(var_13) = &input.tags {
        let mut array_14 = object.key("tags").start_array();
        for item_15 in var_13 {
            {
                #[allow(unused_mut)]
                let mut object_16 = array_14.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag_ref(&mut object_16, item_15)?;
                object_16.finish();
            }
        }
        array_14.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_route_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateRouteInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_17) = &input.client_token {
        object.key("clientToken").string(var_17.as_str());
    }
    if let Some(var_18) = &input.route_name {
        object.key("routeName").string(var_18.as_str());
    }
    if let Some(var_19) = &input.spec {
        #[allow(unused_mut)]
        let mut object_20 = object.key("spec").start_object();
        crate::json_ser::serialize_structure_crate_model_route_spec(&mut object_20, var_19)?;
        object_20.finish();
    }
    if let Some(var_21) = &input.tags {
        let mut array_22 = object.key("tags").start_array();
        for item_23 in var_21 {
            {
                #[allow(unused_mut)]
                let mut object_24 = array_22.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag_ref(&mut object_24, item_23)?;
                object_24.finish();
            }
        }
        array_22.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_virtual_gateway_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateVirtualGatewayInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_25) = &input.client_token {
        object.key("clientToken").string(var_25.as_str());
    }
    if let Some(var_26) = &input.spec {
        #[allow(unused_mut)]
        let mut object_27 = object.key("spec").start_object();
        crate::json_ser::serialize_structure_crate_model_virtual_gateway_spec(
            &mut object_27,
            var_26,
        )?;
        object_27.finish();
    }
    if let Some(var_28) = &input.tags {
        let mut array_29 = object.key("tags").start_array();
        for item_30 in var_28 {
            {
                #[allow(unused_mut)]
                let mut object_31 = array_29.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag_ref(&mut object_31, item_30)?;
                object_31.finish();
            }
        }
        array_29.finish();
    }
    if let Some(var_32) = &input.virtual_gateway_name {
        object.key("virtualGatewayName").string(var_32.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_virtual_node_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateVirtualNodeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_33) = &input.client_token {
        object.key("clientToken").string(var_33.as_str());
    }
    if let Some(var_34) = &input.spec {
        #[allow(unused_mut)]
        let mut object_35 = object.key("spec").start_object();
        crate::json_ser::serialize_structure_crate_model_virtual_node_spec(&mut object_35, var_34)?;
        object_35.finish();
    }
    if let Some(var_36) = &input.tags {
        let mut array_37 = object.key("tags").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_tag_ref(&mut object_39, item_38)?;
                object_39.finish();
            }
        }
        array_37.finish();
    }
    if let Some(var_40) = &input.virtual_node_name {
        object.key("virtualNodeName").string(var_40.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_virtual_router_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateVirtualRouterInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_41) = &input.client_token {
        object.key("clientToken").string(var_41.as_str());
    }
    if let Some(var_42) = &input.spec {
        #[allow(unused_mut)]
        let mut object_43 = object.key("spec").start_object();
        crate::json_ser::serialize_structure_crate_model_virtual_router_spec(
            &mut object_43,
            var_42,
        )?;
        object_43.finish();
    }
    if let Some(var_44) = &input.tags {
        let mut array_45 = object.key("tags").start_array();
        for item_46 in var_44 {
            {
                #[allow(unused_mut)]
                let mut object_47 = array_45.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag_ref(&mut object_47, item_46)?;
                object_47.finish();
            }
        }
        array_45.finish();
    }
    if let Some(var_48) = &input.virtual_router_name {
        object.key("virtualRouterName").string(var_48.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_virtual_service_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateVirtualServiceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_49) = &input.client_token {
        object.key("clientToken").string(var_49.as_str());
    }
    if let Some(var_50) = &input.spec {
        #[allow(unused_mut)]
        let mut object_51 = object.key("spec").start_object();
        crate::json_ser::serialize_structure_crate_model_virtual_service_spec(
            &mut object_51,
            var_50,
        )?;
        object_51.finish();
    }
    if let Some(var_52) = &input.tags {
        let mut array_53 = object.key("tags").start_array();
        for item_54 in var_52 {
            {
                #[allow(unused_mut)]
                let mut object_55 = array_53.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag_ref(&mut object_55, item_54)?;
                object_55.finish();
            }
        }
        array_53.finish();
    }
    if let Some(var_56) = &input.virtual_service_name {
        object.key("virtualServiceName").string(var_56.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_57) = &input.tags {
        let mut array_58 = object.key("tags").start_array();
        for item_59 in var_57 {
            {
                #[allow(unused_mut)]
                let mut object_60 = array_58.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag_ref(&mut object_60, item_59)?;
                object_60.finish();
            }
        }
        array_58.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_61) = &input.tag_keys {
        let mut array_62 = object.key("tagKeys").start_array();
        for item_63 in var_61 {
            {
                array_62.value().string(item_63.as_str());
            }
        }
        array_62.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_gateway_route_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateGatewayRouteInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_64) = &input.client_token {
        object.key("clientToken").string(var_64.as_str());
    }
    if let Some(var_65) = &input.spec {
        #[allow(unused_mut)]
        let mut object_66 = object.key("spec").start_object();
        crate::json_ser::serialize_structure_crate_model_gateway_route_spec(
            &mut object_66,
            var_65,
        )?;
        object_66.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_mesh_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateMeshInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_67) = &input.client_token {
        object.key("clientToken").string(var_67.as_str());
    }
    if let Some(var_68) = &input.spec {
        #[allow(unused_mut)]
        let mut object_69 = object.key("spec").start_object();
        crate::json_ser::serialize_structure_crate_model_mesh_spec(&mut object_69, var_68)?;
        object_69.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_route_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateRouteInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_70) = &input.client_token {
        object.key("clientToken").string(var_70.as_str());
    }
    if let Some(var_71) = &input.spec {
        #[allow(unused_mut)]
        let mut object_72 = object.key("spec").start_object();
        crate::json_ser::serialize_structure_crate_model_route_spec(&mut object_72, var_71)?;
        object_72.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_virtual_gateway_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateVirtualGatewayInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_73) = &input.client_token {
        object.key("clientToken").string(var_73.as_str());
    }
    if let Some(var_74) = &input.spec {
        #[allow(unused_mut)]
        let mut object_75 = object.key("spec").start_object();
        crate::json_ser::serialize_structure_crate_model_virtual_gateway_spec(
            &mut object_75,
            var_74,
        )?;
        object_75.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_virtual_node_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateVirtualNodeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_76) = &input.client_token {
        object.key("clientToken").string(var_76.as_str());
    }
    if let Some(var_77) = &input.spec {
        #[allow(unused_mut)]
        let mut object_78 = object.key("spec").start_object();
        crate::json_ser::serialize_structure_crate_model_virtual_node_spec(&mut object_78, var_77)?;
        object_78.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_virtual_router_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateVirtualRouterInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_79) = &input.client_token {
        object.key("clientToken").string(var_79.as_str());
    }
    if let Some(var_80) = &input.spec {
        #[allow(unused_mut)]
        let mut object_81 = object.key("spec").start_object();
        crate::json_ser::serialize_structure_crate_model_virtual_router_spec(
            &mut object_81,
            var_80,
        )?;
        object_81.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_virtual_service_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateVirtualServiceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_82) = &input.client_token {
        object.key("clientToken").string(var_82.as_str());
    }
    if let Some(var_83) = &input.spec {
        #[allow(unused_mut)]
        let mut object_84 = object.key("spec").start_object();
        crate::json_ser::serialize_structure_crate_model_virtual_service_spec(
            &mut object_84,
            var_83,
        )?;
        object_84.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_gateway_route_spec(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GatewayRouteSpec,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_85) = &input.priority {
        object.key("priority").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_85).into()),
        );
    }
    if let Some(var_86) = &input.http_route {
        #[allow(unused_mut)]
        let mut object_87 = object.key("httpRoute").start_object();
        crate::json_ser::serialize_structure_crate_model_http_gateway_route(
            &mut object_87,
            var_86,
        )?;
        object_87.finish();
    }
    if let Some(var_88) = &input.http2_route {
        #[allow(unused_mut)]
        let mut object_89 = object.key("http2Route").start_object();
        crate::json_ser::serialize_structure_crate_model_http_gateway_route(
            &mut object_89,
            var_88,
        )?;
        object_89.finish();
    }
    if let Some(var_90) = &input.grpc_route {
        #[allow(unused_mut)]
        let mut object_91 = object.key("grpcRoute").start_object();
        crate::json_ser::serialize_structure_crate_model_grpc_gateway_route(
            &mut object_91,
            var_90,
        )?;
        object_91.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_tag_ref(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TagRef,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_92) = &input.key {
        object.key("key").string(var_92.as_str());
    }
    if let Some(var_93) = &input.value {
        object.key("value").string(var_93.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_mesh_spec(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MeshSpec,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_94) = &input.egress_filter {
        #[allow(unused_mut)]
        let mut object_95 = object.key("egressFilter").start_object();
        crate::json_ser::serialize_structure_crate_model_egress_filter(&mut object_95, var_94)?;
        object_95.finish();
    }
    if let Some(var_96) = &input.service_discovery {
        #[allow(unused_mut)]
        let mut object_97 = object.key("serviceDiscovery").start_object();
        crate::json_ser::serialize_structure_crate_model_mesh_service_discovery(
            &mut object_97,
            var_96,
        )?;
        object_97.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_route_spec(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::RouteSpec,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_98) = &input.priority {
        object.key("priority").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_98).into()),
        );
    }
    if let Some(var_99) = &input.http_route {
        #[allow(unused_mut)]
        let mut object_100 = object.key("httpRoute").start_object();
        crate::json_ser::serialize_structure_crate_model_http_route(&mut object_100, var_99)?;
        object_100.finish();
    }
    if let Some(var_101) = &input.tcp_route {
        #[allow(unused_mut)]
        let mut object_102 = object.key("tcpRoute").start_object();
        crate::json_ser::serialize_structure_crate_model_tcp_route(&mut object_102, var_101)?;
        object_102.finish();
    }
    if let Some(var_103) = &input.http2_route {
        #[allow(unused_mut)]
        let mut object_104 = object.key("http2Route").start_object();
        crate::json_ser::serialize_structure_crate_model_http_route(&mut object_104, var_103)?;
        object_104.finish();
    }
    if let Some(var_105) = &input.grpc_route {
        #[allow(unused_mut)]
        let mut object_106 = object.key("grpcRoute").start_object();
        crate::json_ser::serialize_structure_crate_model_grpc_route(&mut object_106, var_105)?;
        object_106.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_gateway_spec(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewaySpec,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_107) = &input.backend_defaults {
        #[allow(unused_mut)]
        let mut object_108 = object.key("backendDefaults").start_object();
        crate::json_ser::serialize_structure_crate_model_virtual_gateway_backend_defaults(
            &mut object_108,
            var_107,
        )?;
        object_108.finish();
    }
    if let Some(var_109) = &input.listeners {
        let mut array_110 = object.key("listeners").start_array();
        for item_111 in var_109 {
            {
                #[allow(unused_mut)]
                let mut object_112 = array_110.value().start_object();
                crate::json_ser::serialize_structure_crate_model_virtual_gateway_listener(
                    &mut object_112,
                    item_111,
                )?;
                object_112.finish();
            }
        }
        array_110.finish();
    }
    if let Some(var_113) = &input.logging {
        #[allow(unused_mut)]
        let mut object_114 = object.key("logging").start_object();
        crate::json_ser::serialize_structure_crate_model_virtual_gateway_logging(
            &mut object_114,
            var_113,
        )?;
        object_114.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_node_spec(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualNodeSpec,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_115) = &input.service_discovery {
        #[allow(unused_mut)]
        let mut object_116 = object.key("serviceDiscovery").start_object();
        crate::json_ser::serialize_union_crate_model_service_discovery(&mut object_116, var_115)?;
        object_116.finish();
    }
    if let Some(var_117) = &input.listeners {
        let mut array_118 = object.key("listeners").start_array();
        for item_119 in var_117 {
            {
                #[allow(unused_mut)]
                let mut object_120 = array_118.value().start_object();
                crate::json_ser::serialize_structure_crate_model_listener(
                    &mut object_120,
                    item_119,
                )?;
                object_120.finish();
            }
        }
        array_118.finish();
    }
    if let Some(var_121) = &input.backends {
        let mut array_122 = object.key("backends").start_array();
        for item_123 in var_121 {
            {
                #[allow(unused_mut)]
                let mut object_124 = array_122.value().start_object();
                crate::json_ser::serialize_union_crate_model_backend(&mut object_124, item_123)?;
                object_124.finish();
            }
        }
        array_122.finish();
    }
    if let Some(var_125) = &input.backend_defaults {
        #[allow(unused_mut)]
        let mut object_126 = object.key("backendDefaults").start_object();
        crate::json_ser::serialize_structure_crate_model_backend_defaults(
            &mut object_126,
            var_125,
        )?;
        object_126.finish();
    }
    if let Some(var_127) = &input.logging {
        #[allow(unused_mut)]
        let mut object_128 = object.key("logging").start_object();
        crate::json_ser::serialize_structure_crate_model_logging(&mut object_128, var_127)?;
        object_128.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_router_spec(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualRouterSpec,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_129) = &input.listeners {
        let mut array_130 = object.key("listeners").start_array();
        for item_131 in var_129 {
            {
                #[allow(unused_mut)]
                let mut object_132 = array_130.value().start_object();
                crate::json_ser::serialize_structure_crate_model_virtual_router_listener(
                    &mut object_132,
                    item_131,
                )?;
                object_132.finish();
            }
        }
        array_130.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_service_spec(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualServiceSpec,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_133) = &input.provider {
        #[allow(unused_mut)]
        let mut object_134 = object.key("provider").start_object();
        crate::json_ser::serialize_union_crate_model_virtual_service_provider(
            &mut object_134,
            var_133,
        )?;
        object_134.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_http_gateway_route(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HttpGatewayRoute,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_135) = &input.r#match {
        #[allow(unused_mut)]
        let mut object_136 = object.key("match").start_object();
        crate::json_ser::serialize_structure_crate_model_http_gateway_route_match(
            &mut object_136,
            var_135,
        )?;
        object_136.finish();
    }
    if let Some(var_137) = &input.action {
        #[allow(unused_mut)]
        let mut object_138 = object.key("action").start_object();
        crate::json_ser::serialize_structure_crate_model_http_gateway_route_action(
            &mut object_138,
            var_137,
        )?;
        object_138.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_grpc_gateway_route(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GrpcGatewayRoute,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_139) = &input.r#match {
        #[allow(unused_mut)]
        let mut object_140 = object.key("match").start_object();
        crate::json_ser::serialize_structure_crate_model_grpc_gateway_route_match(
            &mut object_140,
            var_139,
        )?;
        object_140.finish();
    }
    if let Some(var_141) = &input.action {
        #[allow(unused_mut)]
        let mut object_142 = object.key("action").start_object();
        crate::json_ser::serialize_structure_crate_model_grpc_gateway_route_action(
            &mut object_142,
            var_141,
        )?;
        object_142.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_egress_filter(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::EgressFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_143) = &input.r#type {
        object.key("type").string(var_143.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_mesh_service_discovery(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MeshServiceDiscovery,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_144) = &input.ip_preference {
        object.key("ipPreference").string(var_144.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_http_route(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HttpRoute,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_145) = &input.r#match {
        #[allow(unused_mut)]
        let mut object_146 = object.key("match").start_object();
        crate::json_ser::serialize_structure_crate_model_http_route_match(
            &mut object_146,
            var_145,
        )?;
        object_146.finish();
    }
    if let Some(var_147) = &input.action {
        #[allow(unused_mut)]
        let mut object_148 = object.key("action").start_object();
        crate::json_ser::serialize_structure_crate_model_http_route_action(
            &mut object_148,
            var_147,
        )?;
        object_148.finish();
    }
    if let Some(var_149) = &input.retry_policy {
        #[allow(unused_mut)]
        let mut object_150 = object.key("retryPolicy").start_object();
        crate::json_ser::serialize_structure_crate_model_http_retry_policy(
            &mut object_150,
            var_149,
        )?;
        object_150.finish();
    }
    if let Some(var_151) = &input.timeout {
        #[allow(unused_mut)]
        let mut object_152 = object.key("timeout").start_object();
        crate::json_ser::serialize_structure_crate_model_http_timeout(&mut object_152, var_151)?;
        object_152.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_tcp_route(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TcpRoute,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_153) = &input.action {
        #[allow(unused_mut)]
        let mut object_154 = object.key("action").start_object();
        crate::json_ser::serialize_structure_crate_model_tcp_route_action(
            &mut object_154,
            var_153,
        )?;
        object_154.finish();
    }
    if let Some(var_155) = &input.timeout {
        #[allow(unused_mut)]
        let mut object_156 = object.key("timeout").start_object();
        crate::json_ser::serialize_structure_crate_model_tcp_timeout(&mut object_156, var_155)?;
        object_156.finish();
    }
    if let Some(var_157) = &input.r#match {
        #[allow(unused_mut)]
        let mut object_158 = object.key("match").start_object();
        crate::json_ser::serialize_structure_crate_model_tcp_route_match(&mut object_158, var_157)?;
        object_158.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_grpc_route(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GrpcRoute,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_159) = &input.action {
        #[allow(unused_mut)]
        let mut object_160 = object.key("action").start_object();
        crate::json_ser::serialize_structure_crate_model_grpc_route_action(
            &mut object_160,
            var_159,
        )?;
        object_160.finish();
    }
    if let Some(var_161) = &input.r#match {
        #[allow(unused_mut)]
        let mut object_162 = object.key("match").start_object();
        crate::json_ser::serialize_structure_crate_model_grpc_route_match(
            &mut object_162,
            var_161,
        )?;
        object_162.finish();
    }
    if let Some(var_163) = &input.retry_policy {
        #[allow(unused_mut)]
        let mut object_164 = object.key("retryPolicy").start_object();
        crate::json_ser::serialize_structure_crate_model_grpc_retry_policy(
            &mut object_164,
            var_163,
        )?;
        object_164.finish();
    }
    if let Some(var_165) = &input.timeout {
        #[allow(unused_mut)]
        let mut object_166 = object.key("timeout").start_object();
        crate::json_ser::serialize_structure_crate_model_grpc_timeout(&mut object_166, var_165)?;
        object_166.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_gateway_backend_defaults(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayBackendDefaults,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_167) = &input.client_policy {
        #[allow(unused_mut)]
        let mut object_168 = object.key("clientPolicy").start_object();
        crate::json_ser::serialize_structure_crate_model_virtual_gateway_client_policy(
            &mut object_168,
            var_167,
        )?;
        object_168.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_gateway_listener(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayListener,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_169) = &input.health_check {
        #[allow(unused_mut)]
        let mut object_170 = object.key("healthCheck").start_object();
        crate::json_ser::serialize_structure_crate_model_virtual_gateway_health_check_policy(
            &mut object_170,
            var_169,
        )?;
        object_170.finish();
    }
    if let Some(var_171) = &input.port_mapping {
        #[allow(unused_mut)]
        let mut object_172 = object.key("portMapping").start_object();
        crate::json_ser::serialize_structure_crate_model_virtual_gateway_port_mapping(
            &mut object_172,
            var_171,
        )?;
        object_172.finish();
    }
    if let Some(var_173) = &input.tls {
        #[allow(unused_mut)]
        let mut object_174 = object.key("tls").start_object();
        crate::json_ser::serialize_structure_crate_model_virtual_gateway_listener_tls(
            &mut object_174,
            var_173,
        )?;
        object_174.finish();
    }
    if let Some(var_175) = &input.connection_pool {
        #[allow(unused_mut)]
        let mut object_176 = object.key("connectionPool").start_object();
        crate::json_ser::serialize_union_crate_model_virtual_gateway_connection_pool(
            &mut object_176,
            var_175,
        )?;
        object_176.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_gateway_logging(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayLogging,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_177) = &input.access_log {
        #[allow(unused_mut)]
        let mut object_178 = object.key("accessLog").start_object();
        crate::json_ser::serialize_union_crate_model_virtual_gateway_access_log(
            &mut object_178,
            var_177,
        )?;
        object_178.finish();
    }
    Ok(())
}

pub fn serialize_union_crate_model_service_discovery(
    object_116: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ServiceDiscovery,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    match input {
        crate::model::ServiceDiscovery::Dns(inner) => {
            #[allow(unused_mut)]
            let mut object_179 = object_116.key("dns").start_object();
            crate::json_ser::serialize_structure_crate_model_dns_service_discovery(
                &mut object_179,
                inner,
            )?;
            object_179.finish();
        }
        crate::model::ServiceDiscovery::AwsCloudMap(inner) => {
            #[allow(unused_mut)]
            let mut object_180 = object_116.key("awsCloudMap").start_object();
            crate::json_ser::serialize_structure_crate_model_aws_cloud_map_service_discovery(
                &mut object_180,
                inner,
            )?;
            object_180.finish();
        }
        crate::model::ServiceDiscovery::Unknown => {
            return Err(
                aws_smithy_http::operation::error::SerializationError::unknown_variant(
                    "ServiceDiscovery",
                ),
            )
        }
    }
    Ok(())
}

pub fn serialize_structure_crate_model_listener(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Listener,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_181) = &input.port_mapping {
        #[allow(unused_mut)]
        let mut object_182 = object.key("portMapping").start_object();
        crate::json_ser::serialize_structure_crate_model_port_mapping(&mut object_182, var_181)?;
        object_182.finish();
    }
    if let Some(var_183) = &input.tls {
        #[allow(unused_mut)]
        let mut object_184 = object.key("tls").start_object();
        crate::json_ser::serialize_structure_crate_model_listener_tls(&mut object_184, var_183)?;
        object_184.finish();
    }
    if let Some(var_185) = &input.health_check {
        #[allow(unused_mut)]
        let mut object_186 = object.key("healthCheck").start_object();
        crate::json_ser::serialize_structure_crate_model_health_check_policy(
            &mut object_186,
            var_185,
        )?;
        object_186.finish();
    }
    if let Some(var_187) = &input.timeout {
        #[allow(unused_mut)]
        let mut object_188 = object.key("timeout").start_object();
        crate::json_ser::serialize_union_crate_model_listener_timeout(&mut object_188, var_187)?;
        object_188.finish();
    }
    if let Some(var_189) = &input.outlier_detection {
        #[allow(unused_mut)]
        let mut object_190 = object.key("outlierDetection").start_object();
        crate::json_ser::serialize_structure_crate_model_outlier_detection(
            &mut object_190,
            var_189,
        )?;
        object_190.finish();
    }
    if let Some(var_191) = &input.connection_pool {
        #[allow(unused_mut)]
        let mut object_192 = object.key("connectionPool").start_object();
        crate::json_ser::serialize_union_crate_model_virtual_node_connection_pool(
            &mut object_192,
            var_191,
        )?;
        object_192.finish();
    }
    Ok(())
}

pub fn serialize_union_crate_model_backend(
    object_124: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Backend,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    match input {
        crate::model::Backend::VirtualService(inner) => {
            #[allow(unused_mut)]
            let mut object_193 = object_124.key("virtualService").start_object();
            crate::json_ser::serialize_structure_crate_model_virtual_service_backend(
                &mut object_193,
                inner,
            )?;
            object_193.finish();
        }
        crate::model::Backend::Unknown => {
            return Err(
                aws_smithy_http::operation::error::SerializationError::unknown_variant("Backend"),
            )
        }
    }
    Ok(())
}

pub fn serialize_structure_crate_model_backend_defaults(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::BackendDefaults,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_194) = &input.client_policy {
        #[allow(unused_mut)]
        let mut object_195 = object.key("clientPolicy").start_object();
        crate::json_ser::serialize_structure_crate_model_client_policy(&mut object_195, var_194)?;
        object_195.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_logging(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Logging,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_196) = &input.access_log {
        #[allow(unused_mut)]
        let mut object_197 = object.key("accessLog").start_object();
        crate::json_ser::serialize_union_crate_model_access_log(&mut object_197, var_196)?;
        object_197.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_router_listener(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualRouterListener,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_198) = &input.port_mapping {
        #[allow(unused_mut)]
        let mut object_199 = object.key("portMapping").start_object();
        crate::json_ser::serialize_structure_crate_model_port_mapping(&mut object_199, var_198)?;
        object_199.finish();
    }
    Ok(())
}

pub fn serialize_union_crate_model_virtual_service_provider(
    object_134: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualServiceProvider,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    match input {
        crate::model::VirtualServiceProvider::VirtualNode(inner) => {
            #[allow(unused_mut)]
            let mut object_200 = object_134.key("virtualNode").start_object();
            crate::json_ser::serialize_structure_crate_model_virtual_node_service_provider(
                &mut object_200,
                inner,
            )?;
            object_200.finish();
        }
        crate::model::VirtualServiceProvider::VirtualRouter(inner) => {
            #[allow(unused_mut)]
            let mut object_201 = object_134.key("virtualRouter").start_object();
            crate::json_ser::serialize_structure_crate_model_virtual_router_service_provider(
                &mut object_201,
                inner,
            )?;
            object_201.finish();
        }
        crate::model::VirtualServiceProvider::Unknown => {
            return Err(
                aws_smithy_http::operation::error::SerializationError::unknown_variant(
                    "VirtualServiceProvider",
                ),
            )
        }
    }
    Ok(())
}

pub fn serialize_structure_crate_model_http_gateway_route_match(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HttpGatewayRouteMatch,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_202) = &input.prefix {
        object.key("prefix").string(var_202.as_str());
    }
    if let Some(var_203) = &input.path {
        #[allow(unused_mut)]
        let mut object_204 = object.key("path").start_object();
        crate::json_ser::serialize_structure_crate_model_http_path_match(&mut object_204, var_203)?;
        object_204.finish();
    }
    if let Some(var_205) = &input.query_parameters {
        let mut array_206 = object.key("queryParameters").start_array();
        for item_207 in var_205 {
            {
                #[allow(unused_mut)]
                let mut object_208 = array_206.value().start_object();
                crate::json_ser::serialize_structure_crate_model_http_query_parameter(
                    &mut object_208,
                    item_207,
                )?;
                object_208.finish();
            }
        }
        array_206.finish();
    }
    if let Some(var_209) = &input.method {
        object.key("method").string(var_209.as_str());
    }
    if let Some(var_210) = &input.hostname {
        #[allow(unused_mut)]
        let mut object_211 = object.key("hostname").start_object();
        crate::json_ser::serialize_structure_crate_model_gateway_route_hostname_match(
            &mut object_211,
            var_210,
        )?;
        object_211.finish();
    }
    if let Some(var_212) = &input.headers {
        let mut array_213 = object.key("headers").start_array();
        for item_214 in var_212 {
            {
                #[allow(unused_mut)]
                let mut object_215 = array_213.value().start_object();
                crate::json_ser::serialize_structure_crate_model_http_gateway_route_header(
                    &mut object_215,
                    item_214,
                )?;
                object_215.finish();
            }
        }
        array_213.finish();
    }
    if let Some(var_216) = &input.port {
        object.key("port").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_216).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_http_gateway_route_action(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HttpGatewayRouteAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_217) = &input.target {
        #[allow(unused_mut)]
        let mut object_218 = object.key("target").start_object();
        crate::json_ser::serialize_structure_crate_model_gateway_route_target(
            &mut object_218,
            var_217,
        )?;
        object_218.finish();
    }
    if let Some(var_219) = &input.rewrite {
        #[allow(unused_mut)]
        let mut object_220 = object.key("rewrite").start_object();
        crate::json_ser::serialize_structure_crate_model_http_gateway_route_rewrite(
            &mut object_220,
            var_219,
        )?;
        object_220.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_grpc_gateway_route_match(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GrpcGatewayRouteMatch,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_221) = &input.service_name {
        object.key("serviceName").string(var_221.as_str());
    }
    if let Some(var_222) = &input.hostname {
        #[allow(unused_mut)]
        let mut object_223 = object.key("hostname").start_object();
        crate::json_ser::serialize_structure_crate_model_gateway_route_hostname_match(
            &mut object_223,
            var_222,
        )?;
        object_223.finish();
    }
    if let Some(var_224) = &input.metadata {
        let mut array_225 = object.key("metadata").start_array();
        for item_226 in var_224 {
            {
                #[allow(unused_mut)]
                let mut object_227 = array_225.value().start_object();
                crate::json_ser::serialize_structure_crate_model_grpc_gateway_route_metadata(
                    &mut object_227,
                    item_226,
                )?;
                object_227.finish();
            }
        }
        array_225.finish();
    }
    if let Some(var_228) = &input.port {
        object.key("port").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_228).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_grpc_gateway_route_action(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GrpcGatewayRouteAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_229) = &input.target {
        #[allow(unused_mut)]
        let mut object_230 = object.key("target").start_object();
        crate::json_ser::serialize_structure_crate_model_gateway_route_target(
            &mut object_230,
            var_229,
        )?;
        object_230.finish();
    }
    if let Some(var_231) = &input.rewrite {
        #[allow(unused_mut)]
        let mut object_232 = object.key("rewrite").start_object();
        crate::json_ser::serialize_structure_crate_model_grpc_gateway_route_rewrite(
            &mut object_232,
            var_231,
        )?;
        object_232.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_http_route_match(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HttpRouteMatch,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_233) = &input.prefix {
        object.key("prefix").string(var_233.as_str());
    }
    if let Some(var_234) = &input.path {
        #[allow(unused_mut)]
        let mut object_235 = object.key("path").start_object();
        crate::json_ser::serialize_structure_crate_model_http_path_match(&mut object_235, var_234)?;
        object_235.finish();
    }
    if let Some(var_236) = &input.query_parameters {
        let mut array_237 = object.key("queryParameters").start_array();
        for item_238 in var_236 {
            {
                #[allow(unused_mut)]
                let mut object_239 = array_237.value().start_object();
                crate::json_ser::serialize_structure_crate_model_http_query_parameter(
                    &mut object_239,
                    item_238,
                )?;
                object_239.finish();
            }
        }
        array_237.finish();
    }
    if let Some(var_240) = &input.method {
        object.key("method").string(var_240.as_str());
    }
    if let Some(var_241) = &input.scheme {
        object.key("scheme").string(var_241.as_str());
    }
    if let Some(var_242) = &input.headers {
        let mut array_243 = object.key("headers").start_array();
        for item_244 in var_242 {
            {
                #[allow(unused_mut)]
                let mut object_245 = array_243.value().start_object();
                crate::json_ser::serialize_structure_crate_model_http_route_header(
                    &mut object_245,
                    item_244,
                )?;
                object_245.finish();
            }
        }
        array_243.finish();
    }
    if let Some(var_246) = &input.port {
        object.key("port").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_246).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_http_route_action(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HttpRouteAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_247) = &input.weighted_targets {
        let mut array_248 = object.key("weightedTargets").start_array();
        for item_249 in var_247 {
            {
                #[allow(unused_mut)]
                let mut object_250 = array_248.value().start_object();
                crate::json_ser::serialize_structure_crate_model_weighted_target(
                    &mut object_250,
                    item_249,
                )?;
                object_250.finish();
            }
        }
        array_248.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_http_retry_policy(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HttpRetryPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_251) = &input.per_retry_timeout {
        #[allow(unused_mut)]
        let mut object_252 = object.key("perRetryTimeout").start_object();
        crate::json_ser::serialize_structure_crate_model_duration(&mut object_252, var_251)?;
        object_252.finish();
    }
    if let Some(var_253) = &input.max_retries {
        object.key("maxRetries").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_253).into()),
        );
    }
    if let Some(var_254) = &input.http_retry_events {
        let mut array_255 = object.key("httpRetryEvents").start_array();
        for item_256 in var_254 {
            {
                array_255.value().string(item_256.as_str());
            }
        }
        array_255.finish();
    }
    if let Some(var_257) = &input.tcp_retry_events {
        let mut array_258 = object.key("tcpRetryEvents").start_array();
        for item_259 in var_257 {
            {
                array_258.value().string(item_259.as_str());
            }
        }
        array_258.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_http_timeout(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HttpTimeout,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_260) = &input.per_request {
        #[allow(unused_mut)]
        let mut object_261 = object.key("perRequest").start_object();
        crate::json_ser::serialize_structure_crate_model_duration(&mut object_261, var_260)?;
        object_261.finish();
    }
    if let Some(var_262) = &input.idle {
        #[allow(unused_mut)]
        let mut object_263 = object.key("idle").start_object();
        crate::json_ser::serialize_structure_crate_model_duration(&mut object_263, var_262)?;
        object_263.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_tcp_route_action(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TcpRouteAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_264) = &input.weighted_targets {
        let mut array_265 = object.key("weightedTargets").start_array();
        for item_266 in var_264 {
            {
                #[allow(unused_mut)]
                let mut object_267 = array_265.value().start_object();
                crate::json_ser::serialize_structure_crate_model_weighted_target(
                    &mut object_267,
                    item_266,
                )?;
                object_267.finish();
            }
        }
        array_265.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_tcp_timeout(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TcpTimeout,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_268) = &input.idle {
        #[allow(unused_mut)]
        let mut object_269 = object.key("idle").start_object();
        crate::json_ser::serialize_structure_crate_model_duration(&mut object_269, var_268)?;
        object_269.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_tcp_route_match(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TcpRouteMatch,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_270) = &input.port {
        object.key("port").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_270).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_grpc_route_action(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GrpcRouteAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_271) = &input.weighted_targets {
        let mut array_272 = object.key("weightedTargets").start_array();
        for item_273 in var_271 {
            {
                #[allow(unused_mut)]
                let mut object_274 = array_272.value().start_object();
                crate::json_ser::serialize_structure_crate_model_weighted_target(
                    &mut object_274,
                    item_273,
                )?;
                object_274.finish();
            }
        }
        array_272.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_grpc_route_match(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GrpcRouteMatch,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_275) = &input.service_name {
        object.key("serviceName").string(var_275.as_str());
    }
    if let Some(var_276) = &input.method_name {
        object.key("methodName").string(var_276.as_str());
    }
    if let Some(var_277) = &input.metadata {
        let mut array_278 = object.key("metadata").start_array();
        for item_279 in var_277 {
            {
                #[allow(unused_mut)]
                let mut object_280 = array_278.value().start_object();
                crate::json_ser::serialize_structure_crate_model_grpc_route_metadata(
                    &mut object_280,
                    item_279,
                )?;
                object_280.finish();
            }
        }
        array_278.finish();
    }
    if let Some(var_281) = &input.port {
        object.key("port").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_281).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_grpc_retry_policy(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GrpcRetryPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_282) = &input.per_retry_timeout {
        #[allow(unused_mut)]
        let mut object_283 = object.key("perRetryTimeout").start_object();
        crate::json_ser::serialize_structure_crate_model_duration(&mut object_283, var_282)?;
        object_283.finish();
    }
    if let Some(var_284) = &input.max_retries {
        object.key("maxRetries").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_284).into()),
        );
    }
    if let Some(var_285) = &input.http_retry_events {
        let mut array_286 = object.key("httpRetryEvents").start_array();
        for item_287 in var_285 {
            {
                array_286.value().string(item_287.as_str());
            }
        }
        array_286.finish();
    }
    if let Some(var_288) = &input.tcp_retry_events {
        let mut array_289 = object.key("tcpRetryEvents").start_array();
        for item_290 in var_288 {
            {
                array_289.value().string(item_290.as_str());
            }
        }
        array_289.finish();
    }
    if let Some(var_291) = &input.grpc_retry_events {
        let mut array_292 = object.key("grpcRetryEvents").start_array();
        for item_293 in var_291 {
            {
                array_292.value().string(item_293.as_str());
            }
        }
        array_292.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_grpc_timeout(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GrpcTimeout,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_294) = &input.per_request {
        #[allow(unused_mut)]
        let mut object_295 = object.key("perRequest").start_object();
        crate::json_ser::serialize_structure_crate_model_duration(&mut object_295, var_294)?;
        object_295.finish();
    }
    if let Some(var_296) = &input.idle {
        #[allow(unused_mut)]
        let mut object_297 = object.key("idle").start_object();
        crate::json_ser::serialize_structure_crate_model_duration(&mut object_297, var_296)?;
        object_297.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_gateway_client_policy(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayClientPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_298) = &input.tls {
        #[allow(unused_mut)]
        let mut object_299 = object.key("tls").start_object();
        crate::json_ser::serialize_structure_crate_model_virtual_gateway_client_policy_tls(
            &mut object_299,
            var_298,
        )?;
        object_299.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_gateway_health_check_policy(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayHealthCheckPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_300) = &input.timeout_millis {
        object.key("timeoutMillis").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_300).into()),
        );
    }
    if let Some(var_301) = &input.interval_millis {
        object.key("intervalMillis").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_301).into()),
        );
    }
    if let Some(var_302) = &input.protocol {
        object.key("protocol").string(var_302.as_str());
    }
    if input.port != 0 {
        object.key("port").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.port).into()),
        );
    }
    if let Some(var_303) = &input.path {
        object.key("path").string(var_303.as_str());
    }
    {
        object.key("healthyThreshold").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.healthy_threshold).into()),
        );
    }
    {
        object.key("unhealthyThreshold").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.unhealthy_threshold).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_gateway_port_mapping(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayPortMapping,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    {
        object.key("port").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.port).into()),
        );
    }
    if let Some(var_304) = &input.protocol {
        object.key("protocol").string(var_304.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_gateway_listener_tls(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayListenerTls,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_305) = &input.mode {
        object.key("mode").string(var_305.as_str());
    }
    if let Some(var_306) = &input.validation {
        #[allow(unused_mut)]
        let mut object_307 = object.key("validation").start_object();
        crate::json_ser::serialize_structure_crate_model_virtual_gateway_listener_tls_validation_context(&mut object_307, var_306)?;
        object_307.finish();
    }
    if let Some(var_308) = &input.certificate {
        #[allow(unused_mut)]
        let mut object_309 = object.key("certificate").start_object();
        crate::json_ser::serialize_union_crate_model_virtual_gateway_listener_tls_certificate(
            &mut object_309,
            var_308,
        )?;
        object_309.finish();
    }
    Ok(())
}

pub fn serialize_union_crate_model_virtual_gateway_connection_pool(
    object_176: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayConnectionPool,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    match input {
        crate::model::VirtualGatewayConnectionPool::Http(inner) => {
            #[allow(unused_mut)]
            let mut object_310 = object_176.key("http").start_object();
            crate::json_ser::serialize_structure_crate_model_virtual_gateway_http_connection_pool(
                &mut object_310,
                inner,
            )?;
            object_310.finish();
        }
        crate::model::VirtualGatewayConnectionPool::Http2(inner) => {
            #[allow(unused_mut)]
            let mut object_311 = object_176.key("http2").start_object();
            crate::json_ser::serialize_structure_crate_model_virtual_gateway_http2_connection_pool(
                &mut object_311,
                inner,
            )?;
            object_311.finish();
        }
        crate::model::VirtualGatewayConnectionPool::Grpc(inner) => {
            #[allow(unused_mut)]
            let mut object_312 = object_176.key("grpc").start_object();
            crate::json_ser::serialize_structure_crate_model_virtual_gateway_grpc_connection_pool(
                &mut object_312,
                inner,
            )?;
            object_312.finish();
        }
        crate::model::VirtualGatewayConnectionPool::Unknown => {
            return Err(
                aws_smithy_http::operation::error::SerializationError::unknown_variant(
                    "VirtualGatewayConnectionPool",
                ),
            )
        }
    }
    Ok(())
}

pub fn serialize_union_crate_model_virtual_gateway_access_log(
    object_178: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayAccessLog,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    match input {
        crate::model::VirtualGatewayAccessLog::File(inner) => {
            #[allow(unused_mut)]
            let mut object_313 = object_178.key("file").start_object();
            crate::json_ser::serialize_structure_crate_model_virtual_gateway_file_access_log(
                &mut object_313,
                inner,
            )?;
            object_313.finish();
        }
        crate::model::VirtualGatewayAccessLog::Unknown => {
            return Err(
                aws_smithy_http::operation::error::SerializationError::unknown_variant(
                    "VirtualGatewayAccessLog",
                ),
            )
        }
    }
    Ok(())
}

pub fn serialize_structure_crate_model_dns_service_discovery(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DnsServiceDiscovery,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_314) = &input.hostname {
        object.key("hostname").string(var_314.as_str());
    }
    if let Some(var_315) = &input.response_type {
        object.key("responseType").string(var_315.as_str());
    }
    if let Some(var_316) = &input.ip_preference {
        object.key("ipPreference").string(var_316.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_aws_cloud_map_service_discovery(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCloudMapServiceDiscovery,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_317) = &input.namespace_name {
        object.key("namespaceName").string(var_317.as_str());
    }
    if let Some(var_318) = &input.service_name {
        object.key("serviceName").string(var_318.as_str());
    }
    if let Some(var_319) = &input.attributes {
        let mut array_320 = object.key("attributes").start_array();
        for item_321 in var_319 {
            {
                #[allow(unused_mut)]
                let mut object_322 = array_320.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_cloud_map_instance_attribute(
                    &mut object_322,
                    item_321,
                )?;
                object_322.finish();
            }
        }
        array_320.finish();
    }
    if let Some(var_323) = &input.ip_preference {
        object.key("ipPreference").string(var_323.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_port_mapping(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::PortMapping,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    {
        object.key("port").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.port).into()),
        );
    }
    if let Some(var_324) = &input.protocol {
        object.key("protocol").string(var_324.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_listener_tls(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ListenerTls,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_325) = &input.mode {
        object.key("mode").string(var_325.as_str());
    }
    if let Some(var_326) = &input.certificate {
        #[allow(unused_mut)]
        let mut object_327 = object.key("certificate").start_object();
        crate::json_ser::serialize_union_crate_model_listener_tls_certificate(
            &mut object_327,
            var_326,
        )?;
        object_327.finish();
    }
    if let Some(var_328) = &input.validation {
        #[allow(unused_mut)]
        let mut object_329 = object.key("validation").start_object();
        crate::json_ser::serialize_structure_crate_model_listener_tls_validation_context(
            &mut object_329,
            var_328,
        )?;
        object_329.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_health_check_policy(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HealthCheckPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_330) = &input.timeout_millis {
        object.key("timeoutMillis").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_330).into()),
        );
    }
    if let Some(var_331) = &input.interval_millis {
        object.key("intervalMillis").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_331).into()),
        );
    }
    if let Some(var_332) = &input.protocol {
        object.key("protocol").string(var_332.as_str());
    }
    if input.port != 0 {
        object.key("port").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.port).into()),
        );
    }
    if let Some(var_333) = &input.path {
        object.key("path").string(var_333.as_str());
    }
    {
        object.key("healthyThreshold").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.healthy_threshold).into()),
        );
    }
    {
        object.key("unhealthyThreshold").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.unhealthy_threshold).into()),
        );
    }
    Ok(())
}

pub fn serialize_union_crate_model_listener_timeout(
    object_188: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ListenerTimeout,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    match input {
        crate::model::ListenerTimeout::Tcp(inner) => {
            #[allow(unused_mut)]
            let mut object_334 = object_188.key("tcp").start_object();
            crate::json_ser::serialize_structure_crate_model_tcp_timeout(&mut object_334, inner)?;
            object_334.finish();
        }
        crate::model::ListenerTimeout::Http(inner) => {
            #[allow(unused_mut)]
            let mut object_335 = object_188.key("http").start_object();
            crate::json_ser::serialize_structure_crate_model_http_timeout(&mut object_335, inner)?;
            object_335.finish();
        }
        crate::model::ListenerTimeout::Http2(inner) => {
            #[allow(unused_mut)]
            let mut object_336 = object_188.key("http2").start_object();
            crate::json_ser::serialize_structure_crate_model_http_timeout(&mut object_336, inner)?;
            object_336.finish();
        }
        crate::model::ListenerTimeout::Grpc(inner) => {
            #[allow(unused_mut)]
            let mut object_337 = object_188.key("grpc").start_object();
            crate::json_ser::serialize_structure_crate_model_grpc_timeout(&mut object_337, inner)?;
            object_337.finish();
        }
        crate::model::ListenerTimeout::Unknown => {
            return Err(
                aws_smithy_http::operation::error::SerializationError::unknown_variant(
                    "ListenerTimeout",
                ),
            )
        }
    }
    Ok(())
}

pub fn serialize_structure_crate_model_outlier_detection(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::OutlierDetection,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_338) = &input.max_server_errors {
        object.key("maxServerErrors").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_338).into()),
        );
    }
    if let Some(var_339) = &input.interval {
        #[allow(unused_mut)]
        let mut object_340 = object.key("interval").start_object();
        crate::json_ser::serialize_structure_crate_model_duration(&mut object_340, var_339)?;
        object_340.finish();
    }
    if let Some(var_341) = &input.base_ejection_duration {
        #[allow(unused_mut)]
        let mut object_342 = object.key("baseEjectionDuration").start_object();
        crate::json_ser::serialize_structure_crate_model_duration(&mut object_342, var_341)?;
        object_342.finish();
    }
    if let Some(var_343) = &input.max_ejection_percent {
        object.key("maxEjectionPercent").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_343).into()),
        );
    }
    Ok(())
}

pub fn serialize_union_crate_model_virtual_node_connection_pool(
    object_192: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualNodeConnectionPool,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    match input {
        crate::model::VirtualNodeConnectionPool::Tcp(inner) => {
            #[allow(unused_mut)]
            let mut object_344 = object_192.key("tcp").start_object();
            crate::json_ser::serialize_structure_crate_model_virtual_node_tcp_connection_pool(
                &mut object_344,
                inner,
            )?;
            object_344.finish();
        }
        crate::model::VirtualNodeConnectionPool::Http(inner) => {
            #[allow(unused_mut)]
            let mut object_345 = object_192.key("http").start_object();
            crate::json_ser::serialize_structure_crate_model_virtual_node_http_connection_pool(
                &mut object_345,
                inner,
            )?;
            object_345.finish();
        }
        crate::model::VirtualNodeConnectionPool::Http2(inner) => {
            #[allow(unused_mut)]
            let mut object_346 = object_192.key("http2").start_object();
            crate::json_ser::serialize_structure_crate_model_virtual_node_http2_connection_pool(
                &mut object_346,
                inner,
            )?;
            object_346.finish();
        }
        crate::model::VirtualNodeConnectionPool::Grpc(inner) => {
            #[allow(unused_mut)]
            let mut object_347 = object_192.key("grpc").start_object();
            crate::json_ser::serialize_structure_crate_model_virtual_node_grpc_connection_pool(
                &mut object_347,
                inner,
            )?;
            object_347.finish();
        }
        crate::model::VirtualNodeConnectionPool::Unknown => {
            return Err(
                aws_smithy_http::operation::error::SerializationError::unknown_variant(
                    "VirtualNodeConnectionPool",
                ),
            )
        }
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_service_backend(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualServiceBackend,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_348) = &input.virtual_service_name {
        object.key("virtualServiceName").string(var_348.as_str());
    }
    if let Some(var_349) = &input.client_policy {
        #[allow(unused_mut)]
        let mut object_350 = object.key("clientPolicy").start_object();
        crate::json_ser::serialize_structure_crate_model_client_policy(&mut object_350, var_349)?;
        object_350.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_client_policy(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ClientPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_351) = &input.tls {
        #[allow(unused_mut)]
        let mut object_352 = object.key("tls").start_object();
        crate::json_ser::serialize_structure_crate_model_client_policy_tls(
            &mut object_352,
            var_351,
        )?;
        object_352.finish();
    }
    Ok(())
}

pub fn serialize_union_crate_model_access_log(
    object_197: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AccessLog,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    match input {
        crate::model::AccessLog::File(inner) => {
            #[allow(unused_mut)]
            let mut object_353 = object_197.key("file").start_object();
            crate::json_ser::serialize_structure_crate_model_file_access_log(
                &mut object_353,
                inner,
            )?;
            object_353.finish();
        }
        crate::model::AccessLog::Unknown => {
            return Err(
                aws_smithy_http::operation::error::SerializationError::unknown_variant("AccessLog"),
            )
        }
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_node_service_provider(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualNodeServiceProvider,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_354) = &input.virtual_node_name {
        object.key("virtualNodeName").string(var_354.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_router_service_provider(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualRouterServiceProvider,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_355) = &input.virtual_router_name {
        object.key("virtualRouterName").string(var_355.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_http_path_match(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HttpPathMatch,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_356) = &input.exact {
        object.key("exact").string(var_356.as_str());
    }
    if let Some(var_357) = &input.regex {
        object.key("regex").string(var_357.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_http_query_parameter(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HttpQueryParameter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_358) = &input.name {
        object.key("name").string(var_358.as_str());
    }
    if let Some(var_359) = &input.r#match {
        #[allow(unused_mut)]
        let mut object_360 = object.key("match").start_object();
        crate::json_ser::serialize_structure_crate_model_query_parameter_match(
            &mut object_360,
            var_359,
        )?;
        object_360.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_gateway_route_hostname_match(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GatewayRouteHostnameMatch,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_361) = &input.exact {
        object.key("exact").string(var_361.as_str());
    }
    if let Some(var_362) = &input.suffix {
        object.key("suffix").string(var_362.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_http_gateway_route_header(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HttpGatewayRouteHeader,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_363) = &input.name {
        object.key("name").string(var_363.as_str());
    }
    if let Some(var_364) = &input.invert {
        object.key("invert").boolean(*var_364);
    }
    if let Some(var_365) = &input.r#match {
        #[allow(unused_mut)]
        let mut object_366 = object.key("match").start_object();
        crate::json_ser::serialize_union_crate_model_header_match_method(&mut object_366, var_365)?;
        object_366.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_gateway_route_target(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GatewayRouteTarget,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_367) = &input.virtual_service {
        #[allow(unused_mut)]
        let mut object_368 = object.key("virtualService").start_object();
        crate::json_ser::serialize_structure_crate_model_gateway_route_virtual_service(
            &mut object_368,
            var_367,
        )?;
        object_368.finish();
    }
    if let Some(var_369) = &input.port {
        object.key("port").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_369).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_http_gateway_route_rewrite(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HttpGatewayRouteRewrite,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_370) = &input.prefix {
        #[allow(unused_mut)]
        let mut object_371 = object.key("prefix").start_object();
        crate::json_ser::serialize_structure_crate_model_http_gateway_route_prefix_rewrite(
            &mut object_371,
            var_370,
        )?;
        object_371.finish();
    }
    if let Some(var_372) = &input.path {
        #[allow(unused_mut)]
        let mut object_373 = object.key("path").start_object();
        crate::json_ser::serialize_structure_crate_model_http_gateway_route_path_rewrite(
            &mut object_373,
            var_372,
        )?;
        object_373.finish();
    }
    if let Some(var_374) = &input.hostname {
        #[allow(unused_mut)]
        let mut object_375 = object.key("hostname").start_object();
        crate::json_ser::serialize_structure_crate_model_gateway_route_hostname_rewrite(
            &mut object_375,
            var_374,
        )?;
        object_375.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_grpc_gateway_route_metadata(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GrpcGatewayRouteMetadata,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_376) = &input.name {
        object.key("name").string(var_376.as_str());
    }
    if let Some(var_377) = &input.invert {
        object.key("invert").boolean(*var_377);
    }
    if let Some(var_378) = &input.r#match {
        #[allow(unused_mut)]
        let mut object_379 = object.key("match").start_object();
        crate::json_ser::serialize_union_crate_model_grpc_metadata_match_method(
            &mut object_379,
            var_378,
        )?;
        object_379.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_grpc_gateway_route_rewrite(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GrpcGatewayRouteRewrite,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_380) = &input.hostname {
        #[allow(unused_mut)]
        let mut object_381 = object.key("hostname").start_object();
        crate::json_ser::serialize_structure_crate_model_gateway_route_hostname_rewrite(
            &mut object_381,
            var_380,
        )?;
        object_381.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_http_route_header(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HttpRouteHeader,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_382) = &input.name {
        object.key("name").string(var_382.as_str());
    }
    if let Some(var_383) = &input.invert {
        object.key("invert").boolean(*var_383);
    }
    if let Some(var_384) = &input.r#match {
        #[allow(unused_mut)]
        let mut object_385 = object.key("match").start_object();
        crate::json_ser::serialize_union_crate_model_header_match_method(&mut object_385, var_384)?;
        object_385.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_weighted_target(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::WeightedTarget,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_386) = &input.virtual_node {
        object.key("virtualNode").string(var_386.as_str());
    }
    {
        object.key("weight").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.weight).into()),
        );
    }
    if let Some(var_387) = &input.port {
        object.key("port").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_387).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_duration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Duration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_388) = &input.value {
        object.key("value").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_388).into()),
        );
    }
    if let Some(var_389) = &input.unit {
        object.key("unit").string(var_389.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_grpc_route_metadata(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GrpcRouteMetadata,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_390) = &input.name {
        object.key("name").string(var_390.as_str());
    }
    if let Some(var_391) = &input.invert {
        object.key("invert").boolean(*var_391);
    }
    if let Some(var_392) = &input.r#match {
        #[allow(unused_mut)]
        let mut object_393 = object.key("match").start_object();
        crate::json_ser::serialize_union_crate_model_grpc_route_metadata_match_method(
            &mut object_393,
            var_392,
        )?;
        object_393.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_gateway_client_policy_tls(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayClientPolicyTls,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_394) = &input.enforce {
        object.key("enforce").boolean(*var_394);
    }
    if let Some(var_395) = &input.ports {
        let mut array_396 = object.key("ports").start_array();
        for item_397 in var_395 {
            {
                array_396.value().number(
                    #[allow(clippy::useless_conversion)]
                    aws_smithy_types::Number::NegInt((*item_397).into()),
                );
            }
        }
        array_396.finish();
    }
    if let Some(var_398) = &input.certificate {
        #[allow(unused_mut)]
        let mut object_399 = object.key("certificate").start_object();
        crate::json_ser::serialize_union_crate_model_virtual_gateway_client_tls_certificate(
            &mut object_399,
            var_398,
        )?;
        object_399.finish();
    }
    if let Some(var_400) = &input.validation {
        #[allow(unused_mut)]
        let mut object_401 = object.key("validation").start_object();
        crate::json_ser::serialize_structure_crate_model_virtual_gateway_tls_validation_context(
            &mut object_401,
            var_400,
        )?;
        object_401.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_gateway_listener_tls_validation_context(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayListenerTlsValidationContext,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_402) = &input.trust {
        #[allow(unused_mut)]
        let mut object_403 = object.key("trust").start_object();
        crate::json_ser::serialize_union_crate_model_virtual_gateway_listener_tls_validation_context_trust(&mut object_403, var_402)?;
        object_403.finish();
    }
    if let Some(var_404) = &input.subject_alternative_names {
        #[allow(unused_mut)]
        let mut object_405 = object.key("subjectAlternativeNames").start_object();
        crate::json_ser::serialize_structure_crate_model_subject_alternative_names(
            &mut object_405,
            var_404,
        )?;
        object_405.finish();
    }
    Ok(())
}

pub fn serialize_union_crate_model_virtual_gateway_listener_tls_certificate(
    object_309: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayListenerTlsCertificate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    match input {
        crate::model::VirtualGatewayListenerTlsCertificate::Acm(inner) => {
            #[allow(unused_mut)]
            let mut object_406 = object_309.key("acm").start_object();
            crate::json_ser::serialize_structure_crate_model_virtual_gateway_listener_tls_acm_certificate(&mut object_406, inner)?;
            object_406.finish();
        }
        crate::model::VirtualGatewayListenerTlsCertificate::File(inner) => {
            #[allow(unused_mut)]
            let mut object_407 = object_309.key("file").start_object();
            crate::json_ser::serialize_structure_crate_model_virtual_gateway_listener_tls_file_certificate(&mut object_407, inner)?;
            object_407.finish();
        }
        crate::model::VirtualGatewayListenerTlsCertificate::Sds(inner) => {
            #[allow(unused_mut)]
            let mut object_408 = object_309.key("sds").start_object();
            crate::json_ser::serialize_structure_crate_model_virtual_gateway_listener_tls_sds_certificate(&mut object_408, inner)?;
            object_408.finish();
        }
        crate::model::VirtualGatewayListenerTlsCertificate::Unknown => {
            return Err(
                aws_smithy_http::operation::error::SerializationError::unknown_variant(
                    "VirtualGatewayListenerTlsCertificate",
                ),
            )
        }
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_gateway_http_connection_pool(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayHttpConnectionPool,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    {
        object.key("maxConnections").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_connections).into()),
        );
    }
    if let Some(var_409) = &input.max_pending_requests {
        object.key("maxPendingRequests").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_409).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_gateway_http2_connection_pool(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayHttp2ConnectionPool,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    {
        object.key("maxRequests").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_requests).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_gateway_grpc_connection_pool(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayGrpcConnectionPool,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    {
        object.key("maxRequests").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_requests).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_gateway_file_access_log(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayFileAccessLog,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_410) = &input.path {
        object.key("path").string(var_410.as_str());
    }
    if let Some(var_411) = &input.format {
        #[allow(unused_mut)]
        let mut object_412 = object.key("format").start_object();
        crate::json_ser::serialize_union_crate_model_logging_format(&mut object_412, var_411)?;
        object_412.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_aws_cloud_map_instance_attribute(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCloudMapInstanceAttribute,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_413) = &input.key {
        object.key("key").string(var_413.as_str());
    }
    if let Some(var_414) = &input.value {
        object.key("value").string(var_414.as_str());
    }
    Ok(())
}

pub fn serialize_union_crate_model_listener_tls_certificate(
    object_327: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ListenerTlsCertificate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    match input {
        crate::model::ListenerTlsCertificate::Acm(inner) => {
            #[allow(unused_mut)]
            let mut object_415 = object_327.key("acm").start_object();
            crate::json_ser::serialize_structure_crate_model_listener_tls_acm_certificate(
                &mut object_415,
                inner,
            )?;
            object_415.finish();
        }
        crate::model::ListenerTlsCertificate::File(inner) => {
            #[allow(unused_mut)]
            let mut object_416 = object_327.key("file").start_object();
            crate::json_ser::serialize_structure_crate_model_listener_tls_file_certificate(
                &mut object_416,
                inner,
            )?;
            object_416.finish();
        }
        crate::model::ListenerTlsCertificate::Sds(inner) => {
            #[allow(unused_mut)]
            let mut object_417 = object_327.key("sds").start_object();
            crate::json_ser::serialize_structure_crate_model_listener_tls_sds_certificate(
                &mut object_417,
                inner,
            )?;
            object_417.finish();
        }
        crate::model::ListenerTlsCertificate::Unknown => {
            return Err(
                aws_smithy_http::operation::error::SerializationError::unknown_variant(
                    "ListenerTlsCertificate",
                ),
            )
        }
    }
    Ok(())
}

pub fn serialize_structure_crate_model_listener_tls_validation_context(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ListenerTlsValidationContext,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_418) = &input.trust {
        #[allow(unused_mut)]
        let mut object_419 = object.key("trust").start_object();
        crate::json_ser::serialize_union_crate_model_listener_tls_validation_context_trust(
            &mut object_419,
            var_418,
        )?;
        object_419.finish();
    }
    if let Some(var_420) = &input.subject_alternative_names {
        #[allow(unused_mut)]
        let mut object_421 = object.key("subjectAlternativeNames").start_object();
        crate::json_ser::serialize_structure_crate_model_subject_alternative_names(
            &mut object_421,
            var_420,
        )?;
        object_421.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_node_tcp_connection_pool(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualNodeTcpConnectionPool,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    {
        object.key("maxConnections").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_connections).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_node_http_connection_pool(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualNodeHttpConnectionPool,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    {
        object.key("maxConnections").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_connections).into()),
        );
    }
    if let Some(var_422) = &input.max_pending_requests {
        object.key("maxPendingRequests").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_422).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_node_http2_connection_pool(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualNodeHttp2ConnectionPool,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    {
        object.key("maxRequests").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_requests).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_node_grpc_connection_pool(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualNodeGrpcConnectionPool,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    {
        object.key("maxRequests").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.max_requests).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_client_policy_tls(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ClientPolicyTls,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_423) = &input.enforce {
        object.key("enforce").boolean(*var_423);
    }
    if let Some(var_424) = &input.ports {
        let mut array_425 = object.key("ports").start_array();
        for item_426 in var_424 {
            {
                array_425.value().number(
                    #[allow(clippy::useless_conversion)]
                    aws_smithy_types::Number::NegInt((*item_426).into()),
                );
            }
        }
        array_425.finish();
    }
    if let Some(var_427) = &input.certificate {
        #[allow(unused_mut)]
        let mut object_428 = object.key("certificate").start_object();
        crate::json_ser::serialize_union_crate_model_client_tls_certificate(
            &mut object_428,
            var_427,
        )?;
        object_428.finish();
    }
    if let Some(var_429) = &input.validation {
        #[allow(unused_mut)]
        let mut object_430 = object.key("validation").start_object();
        crate::json_ser::serialize_structure_crate_model_tls_validation_context(
            &mut object_430,
            var_429,
        )?;
        object_430.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_file_access_log(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::FileAccessLog,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_431) = &input.path {
        object.key("path").string(var_431.as_str());
    }
    if let Some(var_432) = &input.format {
        #[allow(unused_mut)]
        let mut object_433 = object.key("format").start_object();
        crate::json_ser::serialize_union_crate_model_logging_format(&mut object_433, var_432)?;
        object_433.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_query_parameter_match(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::QueryParameterMatch,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_434) = &input.exact {
        object.key("exact").string(var_434.as_str());
    }
    Ok(())
}

pub fn serialize_union_crate_model_header_match_method(
    object_366: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HeaderMatchMethod,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    match input {
        crate::model::HeaderMatchMethod::Exact(inner) => {
            object_366.key("exact").string(inner.as_str());
        }
        crate::model::HeaderMatchMethod::Regex(inner) => {
            object_366.key("regex").string(inner.as_str());
        }
        crate::model::HeaderMatchMethod::Range(inner) => {
            #[allow(unused_mut)]
            let mut object_435 = object_366.key("range").start_object();
            crate::json_ser::serialize_structure_crate_model_match_range(&mut object_435, inner)?;
            object_435.finish();
        }
        crate::model::HeaderMatchMethod::Prefix(inner) => {
            object_366.key("prefix").string(inner.as_str());
        }
        crate::model::HeaderMatchMethod::Suffix(inner) => {
            object_366.key("suffix").string(inner.as_str());
        }
        crate::model::HeaderMatchMethod::Unknown => {
            return Err(
                aws_smithy_http::operation::error::SerializationError::unknown_variant(
                    "HeaderMatchMethod",
                ),
            )
        }
    }
    Ok(())
}

pub fn serialize_structure_crate_model_gateway_route_virtual_service(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GatewayRouteVirtualService,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_436) = &input.virtual_service_name {
        object.key("virtualServiceName").string(var_436.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_http_gateway_route_prefix_rewrite(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HttpGatewayRoutePrefixRewrite,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_437) = &input.default_prefix {
        object.key("defaultPrefix").string(var_437.as_str());
    }
    if let Some(var_438) = &input.value {
        object.key("value").string(var_438.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_http_gateway_route_path_rewrite(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HttpGatewayRoutePathRewrite,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_439) = &input.exact {
        object.key("exact").string(var_439.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_gateway_route_hostname_rewrite(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GatewayRouteHostnameRewrite,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_440) = &input.default_target_hostname {
        object.key("defaultTargetHostname").string(var_440.as_str());
    }
    Ok(())
}

pub fn serialize_union_crate_model_grpc_metadata_match_method(
    object_379: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GrpcMetadataMatchMethod,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    match input {
        crate::model::GrpcMetadataMatchMethod::Exact(inner) => {
            object_379.key("exact").string(inner.as_str());
        }
        crate::model::GrpcMetadataMatchMethod::Regex(inner) => {
            object_379.key("regex").string(inner.as_str());
        }
        crate::model::GrpcMetadataMatchMethod::Range(inner) => {
            #[allow(unused_mut)]
            let mut object_441 = object_379.key("range").start_object();
            crate::json_ser::serialize_structure_crate_model_match_range(&mut object_441, inner)?;
            object_441.finish();
        }
        crate::model::GrpcMetadataMatchMethod::Prefix(inner) => {
            object_379.key("prefix").string(inner.as_str());
        }
        crate::model::GrpcMetadataMatchMethod::Suffix(inner) => {
            object_379.key("suffix").string(inner.as_str());
        }
        crate::model::GrpcMetadataMatchMethod::Unknown => {
            return Err(
                aws_smithy_http::operation::error::SerializationError::unknown_variant(
                    "GrpcMetadataMatchMethod",
                ),
            )
        }
    }
    Ok(())
}

pub fn serialize_union_crate_model_grpc_route_metadata_match_method(
    object_393: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GrpcRouteMetadataMatchMethod,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    match input {
        crate::model::GrpcRouteMetadataMatchMethod::Exact(inner) => {
            object_393.key("exact").string(inner.as_str());
        }
        crate::model::GrpcRouteMetadataMatchMethod::Regex(inner) => {
            object_393.key("regex").string(inner.as_str());
        }
        crate::model::GrpcRouteMetadataMatchMethod::Range(inner) => {
            #[allow(unused_mut)]
            let mut object_442 = object_393.key("range").start_object();
            crate::json_ser::serialize_structure_crate_model_match_range(&mut object_442, inner)?;
            object_442.finish();
        }
        crate::model::GrpcRouteMetadataMatchMethod::Prefix(inner) => {
            object_393.key("prefix").string(inner.as_str());
        }
        crate::model::GrpcRouteMetadataMatchMethod::Suffix(inner) => {
            object_393.key("suffix").string(inner.as_str());
        }
        crate::model::GrpcRouteMetadataMatchMethod::Unknown => {
            return Err(
                aws_smithy_http::operation::error::SerializationError::unknown_variant(
                    "GrpcRouteMetadataMatchMethod",
                ),
            )
        }
    }
    Ok(())
}

pub fn serialize_union_crate_model_virtual_gateway_client_tls_certificate(
    object_399: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayClientTlsCertificate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    match input {
        crate::model::VirtualGatewayClientTlsCertificate::File(inner) => {
            #[allow(unused_mut)]
            let mut object_443 = object_399.key("file").start_object();
            crate::json_ser::serialize_structure_crate_model_virtual_gateway_listener_tls_file_certificate(&mut object_443, inner)?;
            object_443.finish();
        }
        crate::model::VirtualGatewayClientTlsCertificate::Sds(inner) => {
            #[allow(unused_mut)]
            let mut object_444 = object_399.key("sds").start_object();
            crate::json_ser::serialize_structure_crate_model_virtual_gateway_listener_tls_sds_certificate(&mut object_444, inner)?;
            object_444.finish();
        }
        crate::model::VirtualGatewayClientTlsCertificate::Unknown => {
            return Err(
                aws_smithy_http::operation::error::SerializationError::unknown_variant(
                    "VirtualGatewayClientTlsCertificate",
                ),
            )
        }
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_gateway_tls_validation_context(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayTlsValidationContext,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_445) = &input.trust {
        #[allow(unused_mut)]
        let mut object_446 = object.key("trust").start_object();
        crate::json_ser::serialize_union_crate_model_virtual_gateway_tls_validation_context_trust(
            &mut object_446,
            var_445,
        )?;
        object_446.finish();
    }
    if let Some(var_447) = &input.subject_alternative_names {
        #[allow(unused_mut)]
        let mut object_448 = object.key("subjectAlternativeNames").start_object();
        crate::json_ser::serialize_structure_crate_model_subject_alternative_names(
            &mut object_448,
            var_447,
        )?;
        object_448.finish();
    }
    Ok(())
}

pub fn serialize_union_crate_model_virtual_gateway_listener_tls_validation_context_trust(
    object_403: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayListenerTlsValidationContextTrust,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    match input {
        crate::model::VirtualGatewayListenerTlsValidationContextTrust::File(inner) => {
            #[allow(unused_mut)]
            let mut object_449 = object_403.key("file").start_object();
            crate::json_ser::serialize_structure_crate_model_virtual_gateway_tls_validation_context_file_trust(&mut object_449, inner)?;
            object_449.finish();
        }
        crate::model::VirtualGatewayListenerTlsValidationContextTrust::Sds(inner) => {
            #[allow(unused_mut)]
            let mut object_450 = object_403.key("sds").start_object();
            crate::json_ser::serialize_structure_crate_model_virtual_gateway_tls_validation_context_sds_trust(&mut object_450, inner)?;
            object_450.finish();
        }
        crate::model::VirtualGatewayListenerTlsValidationContextTrust::Unknown => {
            return Err(
                aws_smithy_http::operation::error::SerializationError::unknown_variant(
                    "VirtualGatewayListenerTlsValidationContextTrust",
                ),
            )
        }
    }
    Ok(())
}

pub fn serialize_structure_crate_model_subject_alternative_names(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::SubjectAlternativeNames,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_451) = &input.r#match {
        #[allow(unused_mut)]
        let mut object_452 = object.key("match").start_object();
        crate::json_ser::serialize_structure_crate_model_subject_alternative_name_matchers(
            &mut object_452,
            var_451,
        )?;
        object_452.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_gateway_listener_tls_acm_certificate(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayListenerTlsAcmCertificate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_453) = &input.certificate_arn {
        object.key("certificateArn").string(var_453.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_gateway_listener_tls_file_certificate(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayListenerTlsFileCertificate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_454) = &input.certificate_chain {
        object.key("certificateChain").string(var_454.as_str());
    }
    if let Some(var_455) = &input.private_key {
        object.key("privateKey").string(var_455.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_gateway_listener_tls_sds_certificate(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayListenerTlsSdsCertificate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_456) = &input.secret_name {
        object.key("secretName").string(var_456.as_str());
    }
    Ok(())
}

pub fn serialize_union_crate_model_logging_format(
    object_412: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::LoggingFormat,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    match input {
        crate::model::LoggingFormat::Text(inner) => {
            object_412.key("text").string(inner.as_str());
        }
        crate::model::LoggingFormat::Json(inner) => {
            let mut array_457 = object_412.key("json").start_array();
            for item_458 in inner {
                {
                    #[allow(unused_mut)]
                    let mut object_459 = array_457.value().start_object();
                    crate::json_ser::serialize_structure_crate_model_json_format_ref(
                        &mut object_459,
                        item_458,
                    )?;
                    object_459.finish();
                }
            }
            array_457.finish();
        }
        crate::model::LoggingFormat::Unknown => {
            return Err(
                aws_smithy_http::operation::error::SerializationError::unknown_variant(
                    "LoggingFormat",
                ),
            )
        }
    }
    Ok(())
}

pub fn serialize_structure_crate_model_listener_tls_acm_certificate(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ListenerTlsAcmCertificate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_460) = &input.certificate_arn {
        object.key("certificateArn").string(var_460.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_listener_tls_file_certificate(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ListenerTlsFileCertificate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_461) = &input.certificate_chain {
        object.key("certificateChain").string(var_461.as_str());
    }
    if let Some(var_462) = &input.private_key {
        object.key("privateKey").string(var_462.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_listener_tls_sds_certificate(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ListenerTlsSdsCertificate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_463) = &input.secret_name {
        object.key("secretName").string(var_463.as_str());
    }
    Ok(())
}

pub fn serialize_union_crate_model_listener_tls_validation_context_trust(
    object_419: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ListenerTlsValidationContextTrust,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    match input {
        crate::model::ListenerTlsValidationContextTrust::File(inner) => {
            #[allow(unused_mut)]
            let mut object_464 = object_419.key("file").start_object();
            crate::json_ser::serialize_structure_crate_model_tls_validation_context_file_trust(
                &mut object_464,
                inner,
            )?;
            object_464.finish();
        }
        crate::model::ListenerTlsValidationContextTrust::Sds(inner) => {
            #[allow(unused_mut)]
            let mut object_465 = object_419.key("sds").start_object();
            crate::json_ser::serialize_structure_crate_model_tls_validation_context_sds_trust(
                &mut object_465,
                inner,
            )?;
            object_465.finish();
        }
        crate::model::ListenerTlsValidationContextTrust::Unknown => {
            return Err(
                aws_smithy_http::operation::error::SerializationError::unknown_variant(
                    "ListenerTlsValidationContextTrust",
                ),
            )
        }
    }
    Ok(())
}

pub fn serialize_union_crate_model_client_tls_certificate(
    object_428: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ClientTlsCertificate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    match input {
        crate::model::ClientTlsCertificate::File(inner) => {
            #[allow(unused_mut)]
            let mut object_466 = object_428.key("file").start_object();
            crate::json_ser::serialize_structure_crate_model_listener_tls_file_certificate(
                &mut object_466,
                inner,
            )?;
            object_466.finish();
        }
        crate::model::ClientTlsCertificate::Sds(inner) => {
            #[allow(unused_mut)]
            let mut object_467 = object_428.key("sds").start_object();
            crate::json_ser::serialize_structure_crate_model_listener_tls_sds_certificate(
                &mut object_467,
                inner,
            )?;
            object_467.finish();
        }
        crate::model::ClientTlsCertificate::Unknown => {
            return Err(
                aws_smithy_http::operation::error::SerializationError::unknown_variant(
                    "ClientTlsCertificate",
                ),
            )
        }
    }
    Ok(())
}

pub fn serialize_structure_crate_model_tls_validation_context(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TlsValidationContext,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_468) = &input.trust {
        #[allow(unused_mut)]
        let mut object_469 = object.key("trust").start_object();
        crate::json_ser::serialize_union_crate_model_tls_validation_context_trust(
            &mut object_469,
            var_468,
        )?;
        object_469.finish();
    }
    if let Some(var_470) = &input.subject_alternative_names {
        #[allow(unused_mut)]
        let mut object_471 = object.key("subjectAlternativeNames").start_object();
        crate::json_ser::serialize_structure_crate_model_subject_alternative_names(
            &mut object_471,
            var_470,
        )?;
        object_471.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_match_range(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MatchRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_472) = &input.start {
        object.key("start").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_472).into()),
        );
    }
    if let Some(var_473) = &input.end {
        object.key("end").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_473).into()),
        );
    }
    Ok(())
}

pub fn serialize_union_crate_model_virtual_gateway_tls_validation_context_trust(
    object_446: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayTlsValidationContextTrust,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    match input {
        crate::model::VirtualGatewayTlsValidationContextTrust::Acm(inner) => {
            #[allow(unused_mut)]
            let mut object_474 = object_446.key("acm").start_object();
            crate::json_ser::serialize_structure_crate_model_virtual_gateway_tls_validation_context_acm_trust(&mut object_474, inner)?;
            object_474.finish();
        }
        crate::model::VirtualGatewayTlsValidationContextTrust::File(inner) => {
            #[allow(unused_mut)]
            let mut object_475 = object_446.key("file").start_object();
            crate::json_ser::serialize_structure_crate_model_virtual_gateway_tls_validation_context_file_trust(&mut object_475, inner)?;
            object_475.finish();
        }
        crate::model::VirtualGatewayTlsValidationContextTrust::Sds(inner) => {
            #[allow(unused_mut)]
            let mut object_476 = object_446.key("sds").start_object();
            crate::json_ser::serialize_structure_crate_model_virtual_gateway_tls_validation_context_sds_trust(&mut object_476, inner)?;
            object_476.finish();
        }
        crate::model::VirtualGatewayTlsValidationContextTrust::Unknown => {
            return Err(
                aws_smithy_http::operation::error::SerializationError::unknown_variant(
                    "VirtualGatewayTlsValidationContextTrust",
                ),
            )
        }
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_gateway_tls_validation_context_file_trust(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayTlsValidationContextFileTrust,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_477) = &input.certificate_chain {
        object.key("certificateChain").string(var_477.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_gateway_tls_validation_context_sds_trust(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayTlsValidationContextSdsTrust,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_478) = &input.secret_name {
        object.key("secretName").string(var_478.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_subject_alternative_name_matchers(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::SubjectAlternativeNameMatchers,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_479) = &input.exact {
        let mut array_480 = object.key("exact").start_array();
        for item_481 in var_479 {
            {
                array_480.value().string(item_481.as_str());
            }
        }
        array_480.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_json_format_ref(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::JsonFormatRef,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_482) = &input.key {
        object.key("key").string(var_482.as_str());
    }
    if let Some(var_483) = &input.value {
        object.key("value").string(var_483.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_tls_validation_context_file_trust(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TlsValidationContextFileTrust,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_484) = &input.certificate_chain {
        object.key("certificateChain").string(var_484.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_tls_validation_context_sds_trust(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TlsValidationContextSdsTrust,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_485) = &input.secret_name {
        object.key("secretName").string(var_485.as_str());
    }
    Ok(())
}

pub fn serialize_union_crate_model_tls_validation_context_trust(
    object_469: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TlsValidationContextTrust,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    match input {
        crate::model::TlsValidationContextTrust::Acm(inner) => {
            #[allow(unused_mut)]
            let mut object_486 = object_469.key("acm").start_object();
            crate::json_ser::serialize_structure_crate_model_tls_validation_context_acm_trust(
                &mut object_486,
                inner,
            )?;
            object_486.finish();
        }
        crate::model::TlsValidationContextTrust::File(inner) => {
            #[allow(unused_mut)]
            let mut object_487 = object_469.key("file").start_object();
            crate::json_ser::serialize_structure_crate_model_tls_validation_context_file_trust(
                &mut object_487,
                inner,
            )?;
            object_487.finish();
        }
        crate::model::TlsValidationContextTrust::Sds(inner) => {
            #[allow(unused_mut)]
            let mut object_488 = object_469.key("sds").start_object();
            crate::json_ser::serialize_structure_crate_model_tls_validation_context_sds_trust(
                &mut object_488,
                inner,
            )?;
            object_488.finish();
        }
        crate::model::TlsValidationContextTrust::Unknown => {
            return Err(
                aws_smithy_http::operation::error::SerializationError::unknown_variant(
                    "TlsValidationContextTrust",
                ),
            )
        }
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_gateway_tls_validation_context_acm_trust(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayTlsValidationContextAcmTrust,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_489) = &input.certificate_authority_arns {
        let mut array_490 = object.key("certificateAuthorityArns").start_array();
        for item_491 in var_489 {
            {
                array_490.value().string(item_491.as_str());
            }
        }
        array_490.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_tls_validation_context_acm_trust(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TlsValidationContextAcmTrust,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_492) = &input.certificate_authority_arns {
        let mut array_493 = object.key("certificateAuthorityArns").start_array();
        for item_494 in var_492 {
            {
                array_493.value().string(item_494.as_str());
            }
        }
        array_493.finish();
    }
    Ok(())
}