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(())
}