#[allow(unused_mut)]
pub fn serialize_structure_crate_model_certificate(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Certificate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_1 = writer.prefix("CertificateArn");
if let Some(var_2) = &input.certificate_arn {
scope_1.string(var_2);
}
#[allow(unused_mut)]
let mut scope_3 = writer.prefix("IsDefault");
if let Some(var_4) = &input.is_default {
scope_3.boolean(*var_4);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_tag(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_5 = writer.prefix("Key");
if let Some(var_6) = &input.key {
scope_5.string(var_6);
}
#[allow(unused_mut)]
let mut scope_7 = writer.prefix("Value");
if let Some(var_8) = &input.value {
scope_7.string(var_8);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_action(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Action,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_9 = writer.prefix("Type");
if let Some(var_10) = &input.r#type {
scope_9.string(var_10.as_str());
}
#[allow(unused_mut)]
let mut scope_11 = writer.prefix("TargetGroupArn");
if let Some(var_12) = &input.target_group_arn {
scope_11.string(var_12);
}
#[allow(unused_mut)]
let mut scope_13 = writer.prefix("AuthenticateOidcConfig");
if let Some(var_14) = &input.authenticate_oidc_config {
crate::query_ser::serialize_structure_crate_model_authenticate_oidc_action_config(
scope_13, var_14,
)?;
}
#[allow(unused_mut)]
let mut scope_15 = writer.prefix("AuthenticateCognitoConfig");
if let Some(var_16) = &input.authenticate_cognito_config {
crate::query_ser::serialize_structure_crate_model_authenticate_cognito_action_config(
scope_15, var_16,
)?;
}
#[allow(unused_mut)]
let mut scope_17 = writer.prefix("Order");
if let Some(var_18) = &input.order {
scope_17.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_18).into()),
);
}
#[allow(unused_mut)]
let mut scope_19 = writer.prefix("RedirectConfig");
if let Some(var_20) = &input.redirect_config {
crate::query_ser::serialize_structure_crate_model_redirect_action_config(scope_19, var_20)?;
}
#[allow(unused_mut)]
let mut scope_21 = writer.prefix("FixedResponseConfig");
if let Some(var_22) = &input.fixed_response_config {
crate::query_ser::serialize_structure_crate_model_fixed_response_action_config(
scope_21, var_22,
)?;
}
#[allow(unused_mut)]
let mut scope_23 = writer.prefix("ForwardConfig");
if let Some(var_24) = &input.forward_config {
crate::query_ser::serialize_structure_crate_model_forward_action_config(scope_23, var_24)?;
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_subnet_mapping(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::SubnetMapping,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_25 = writer.prefix("SubnetId");
if let Some(var_26) = &input.subnet_id {
scope_25.string(var_26);
}
#[allow(unused_mut)]
let mut scope_27 = writer.prefix("AllocationId");
if let Some(var_28) = &input.allocation_id {
scope_27.string(var_28);
}
#[allow(unused_mut)]
let mut scope_29 = writer.prefix("PrivateIPv4Address");
if let Some(var_30) = &input.private_i_pv4_address {
scope_29.string(var_30);
}
#[allow(unused_mut)]
let mut scope_31 = writer.prefix("IPv6Address");
if let Some(var_32) = &input.i_pv6_address {
scope_31.string(var_32);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_rule_condition(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::RuleCondition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_33 = writer.prefix("Field");
if let Some(var_34) = &input.field {
scope_33.string(var_34);
}
#[allow(unused_mut)]
let mut scope_35 = writer.prefix("Values");
if let Some(var_36) = &input.values {
let mut list_38 = scope_35.start_list(false, None);
for item_37 in var_36 {
#[allow(unused_mut)]
let mut entry_39 = list_38.entry();
entry_39.string(item_37);
}
list_38.finish();
}
#[allow(unused_mut)]
let mut scope_40 = writer.prefix("HostHeaderConfig");
if let Some(var_41) = &input.host_header_config {
crate::query_ser::serialize_structure_crate_model_host_header_condition_config(
scope_40, var_41,
)?;
}
#[allow(unused_mut)]
let mut scope_42 = writer.prefix("PathPatternConfig");
if let Some(var_43) = &input.path_pattern_config {
crate::query_ser::serialize_structure_crate_model_path_pattern_condition_config(
scope_42, var_43,
)?;
}
#[allow(unused_mut)]
let mut scope_44 = writer.prefix("HttpHeaderConfig");
if let Some(var_45) = &input.http_header_config {
crate::query_ser::serialize_structure_crate_model_http_header_condition_config(
scope_44, var_45,
)?;
}
#[allow(unused_mut)]
let mut scope_46 = writer.prefix("QueryStringConfig");
if let Some(var_47) = &input.query_string_config {
crate::query_ser::serialize_structure_crate_model_query_string_condition_config(
scope_46, var_47,
)?;
}
#[allow(unused_mut)]
let mut scope_48 = writer.prefix("HttpRequestMethodConfig");
if let Some(var_49) = &input.http_request_method_config {
crate::query_ser::serialize_structure_crate_model_http_request_method_condition_config(
scope_48, var_49,
)?;
}
#[allow(unused_mut)]
let mut scope_50 = writer.prefix("SourceIpConfig");
if let Some(var_51) = &input.source_ip_config {
crate::query_ser::serialize_structure_crate_model_source_ip_condition_config(
scope_50, var_51,
)?;
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_matcher(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::Matcher,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_52 = writer.prefix("HttpCode");
if let Some(var_53) = &input.http_code {
scope_52.string(var_53);
}
#[allow(unused_mut)]
let mut scope_54 = writer.prefix("GrpcCode");
if let Some(var_55) = &input.grpc_code {
scope_54.string(var_55);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_target_description(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::TargetDescription,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_56 = writer.prefix("Id");
if let Some(var_57) = &input.id {
scope_56.string(var_57);
}
#[allow(unused_mut)]
let mut scope_58 = writer.prefix("Port");
if let Some(var_59) = &input.port {
scope_58.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_59).into()),
);
}
#[allow(unused_mut)]
let mut scope_60 = writer.prefix("AvailabilityZone");
if let Some(var_61) = &input.availability_zone {
scope_60.string(var_61);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_load_balancer_attribute(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::LoadBalancerAttribute,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_62 = writer.prefix("Key");
if let Some(var_63) = &input.key {
scope_62.string(var_63);
}
#[allow(unused_mut)]
let mut scope_64 = writer.prefix("Value");
if let Some(var_65) = &input.value {
scope_64.string(var_65);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_target_group_attribute(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::TargetGroupAttribute,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_66 = writer.prefix("Key");
if let Some(var_67) = &input.key {
scope_66.string(var_67);
}
#[allow(unused_mut)]
let mut scope_68 = writer.prefix("Value");
if let Some(var_69) = &input.value {
scope_68.string(var_69);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_rule_priority_pair(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::RulePriorityPair,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_70 = writer.prefix("RuleArn");
if let Some(var_71) = &input.rule_arn {
scope_70.string(var_71);
}
#[allow(unused_mut)]
let mut scope_72 = writer.prefix("Priority");
if let Some(var_73) = &input.priority {
scope_72.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_73).into()),
);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_authenticate_oidc_action_config(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::AuthenticateOidcActionConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_74 = writer.prefix("Issuer");
if let Some(var_75) = &input.issuer {
scope_74.string(var_75);
}
#[allow(unused_mut)]
let mut scope_76 = writer.prefix("AuthorizationEndpoint");
if let Some(var_77) = &input.authorization_endpoint {
scope_76.string(var_77);
}
#[allow(unused_mut)]
let mut scope_78 = writer.prefix("TokenEndpoint");
if let Some(var_79) = &input.token_endpoint {
scope_78.string(var_79);
}
#[allow(unused_mut)]
let mut scope_80 = writer.prefix("UserInfoEndpoint");
if let Some(var_81) = &input.user_info_endpoint {
scope_80.string(var_81);
}
#[allow(unused_mut)]
let mut scope_82 = writer.prefix("ClientId");
if let Some(var_83) = &input.client_id {
scope_82.string(var_83);
}
#[allow(unused_mut)]
let mut scope_84 = writer.prefix("ClientSecret");
if let Some(var_85) = &input.client_secret {
scope_84.string(var_85);
}
#[allow(unused_mut)]
let mut scope_86 = writer.prefix("SessionCookieName");
if let Some(var_87) = &input.session_cookie_name {
scope_86.string(var_87);
}
#[allow(unused_mut)]
let mut scope_88 = writer.prefix("Scope");
if let Some(var_89) = &input.scope {
scope_88.string(var_89);
}
#[allow(unused_mut)]
let mut scope_90 = writer.prefix("SessionTimeout");
if let Some(var_91) = &input.session_timeout {
scope_90.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_91).into()),
);
}
#[allow(unused_mut)]
let mut scope_92 = writer.prefix("AuthenticationRequestExtraParams");
if let Some(var_93) = &input.authentication_request_extra_params {
let mut map_94 = scope_92.start_map(false, "key", "value");
for (key_95, value_96) in var_93 {
#[allow(unused_mut)]
let mut entry_97 = map_94.entry(key_95);
{
entry_97.string(value_96);
}
}
map_94.finish();
}
#[allow(unused_mut)]
let mut scope_98 = writer.prefix("OnUnauthenticatedRequest");
if let Some(var_99) = &input.on_unauthenticated_request {
scope_98.string(var_99.as_str());
}
#[allow(unused_mut)]
let mut scope_100 = writer.prefix("UseExistingClientSecret");
if let Some(var_101) = &input.use_existing_client_secret {
scope_100.boolean(*var_101);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_authenticate_cognito_action_config(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::AuthenticateCognitoActionConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_102 = writer.prefix("UserPoolArn");
if let Some(var_103) = &input.user_pool_arn {
scope_102.string(var_103);
}
#[allow(unused_mut)]
let mut scope_104 = writer.prefix("UserPoolClientId");
if let Some(var_105) = &input.user_pool_client_id {
scope_104.string(var_105);
}
#[allow(unused_mut)]
let mut scope_106 = writer.prefix("UserPoolDomain");
if let Some(var_107) = &input.user_pool_domain {
scope_106.string(var_107);
}
#[allow(unused_mut)]
let mut scope_108 = writer.prefix("SessionCookieName");
if let Some(var_109) = &input.session_cookie_name {
scope_108.string(var_109);
}
#[allow(unused_mut)]
let mut scope_110 = writer.prefix("Scope");
if let Some(var_111) = &input.scope {
scope_110.string(var_111);
}
#[allow(unused_mut)]
let mut scope_112 = writer.prefix("SessionTimeout");
if let Some(var_113) = &input.session_timeout {
scope_112.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_113).into()),
);
}
#[allow(unused_mut)]
let mut scope_114 = writer.prefix("AuthenticationRequestExtraParams");
if let Some(var_115) = &input.authentication_request_extra_params {
let mut map_116 = scope_114.start_map(false, "key", "value");
for (key_117, value_118) in var_115 {
#[allow(unused_mut)]
let mut entry_119 = map_116.entry(key_117);
{
entry_119.string(value_118);
}
}
map_116.finish();
}
#[allow(unused_mut)]
let mut scope_120 = writer.prefix("OnUnauthenticatedRequest");
if let Some(var_121) = &input.on_unauthenticated_request {
scope_120.string(var_121.as_str());
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_redirect_action_config(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::RedirectActionConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_122 = writer.prefix("Protocol");
if let Some(var_123) = &input.protocol {
scope_122.string(var_123);
}
#[allow(unused_mut)]
let mut scope_124 = writer.prefix("Port");
if let Some(var_125) = &input.port {
scope_124.string(var_125);
}
#[allow(unused_mut)]
let mut scope_126 = writer.prefix("Host");
if let Some(var_127) = &input.host {
scope_126.string(var_127);
}
#[allow(unused_mut)]
let mut scope_128 = writer.prefix("Path");
if let Some(var_129) = &input.path {
scope_128.string(var_129);
}
#[allow(unused_mut)]
let mut scope_130 = writer.prefix("Query");
if let Some(var_131) = &input.query {
scope_130.string(var_131);
}
#[allow(unused_mut)]
let mut scope_132 = writer.prefix("StatusCode");
if let Some(var_133) = &input.status_code {
scope_132.string(var_133.as_str());
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_fixed_response_action_config(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::FixedResponseActionConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_134 = writer.prefix("MessageBody");
if let Some(var_135) = &input.message_body {
scope_134.string(var_135);
}
#[allow(unused_mut)]
let mut scope_136 = writer.prefix("StatusCode");
if let Some(var_137) = &input.status_code {
scope_136.string(var_137);
}
#[allow(unused_mut)]
let mut scope_138 = writer.prefix("ContentType");
if let Some(var_139) = &input.content_type {
scope_138.string(var_139);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_forward_action_config(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::ForwardActionConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_140 = writer.prefix("TargetGroups");
if let Some(var_141) = &input.target_groups {
let mut list_143 = scope_140.start_list(false, None);
for item_142 in var_141 {
#[allow(unused_mut)]
let mut entry_144 = list_143.entry();
crate::query_ser::serialize_structure_crate_model_target_group_tuple(
entry_144, item_142,
)?;
}
list_143.finish();
}
#[allow(unused_mut)]
let mut scope_145 = writer.prefix("TargetGroupStickinessConfig");
if let Some(var_146) = &input.target_group_stickiness_config {
crate::query_ser::serialize_structure_crate_model_target_group_stickiness_config(
scope_145, var_146,
)?;
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_host_header_condition_config(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::HostHeaderConditionConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_147 = writer.prefix("Values");
if let Some(var_148) = &input.values {
let mut list_150 = scope_147.start_list(false, None);
for item_149 in var_148 {
#[allow(unused_mut)]
let mut entry_151 = list_150.entry();
entry_151.string(item_149);
}
list_150.finish();
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_path_pattern_condition_config(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::PathPatternConditionConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_152 = writer.prefix("Values");
if let Some(var_153) = &input.values {
let mut list_155 = scope_152.start_list(false, None);
for item_154 in var_153 {
#[allow(unused_mut)]
let mut entry_156 = list_155.entry();
entry_156.string(item_154);
}
list_155.finish();
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_http_header_condition_config(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::HttpHeaderConditionConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_157 = writer.prefix("HttpHeaderName");
if let Some(var_158) = &input.http_header_name {
scope_157.string(var_158);
}
#[allow(unused_mut)]
let mut scope_159 = writer.prefix("Values");
if let Some(var_160) = &input.values {
let mut list_162 = scope_159.start_list(false, None);
for item_161 in var_160 {
#[allow(unused_mut)]
let mut entry_163 = list_162.entry();
entry_163.string(item_161);
}
list_162.finish();
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_query_string_condition_config(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::QueryStringConditionConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_164 = writer.prefix("Values");
if let Some(var_165) = &input.values {
let mut list_167 = scope_164.start_list(false, None);
for item_166 in var_165 {
#[allow(unused_mut)]
let mut entry_168 = list_167.entry();
crate::query_ser::serialize_structure_crate_model_query_string_key_value_pair(
entry_168, item_166,
)?;
}
list_167.finish();
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_http_request_method_condition_config(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::HttpRequestMethodConditionConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_169 = writer.prefix("Values");
if let Some(var_170) = &input.values {
let mut list_172 = scope_169.start_list(false, None);
for item_171 in var_170 {
#[allow(unused_mut)]
let mut entry_173 = list_172.entry();
entry_173.string(item_171);
}
list_172.finish();
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_source_ip_condition_config(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::SourceIpConditionConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_174 = writer.prefix("Values");
if let Some(var_175) = &input.values {
let mut list_177 = scope_174.start_list(false, None);
for item_176 in var_175 {
#[allow(unused_mut)]
let mut entry_178 = list_177.entry();
entry_178.string(item_176);
}
list_177.finish();
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_target_group_tuple(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::TargetGroupTuple,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_179 = writer.prefix("TargetGroupArn");
if let Some(var_180) = &input.target_group_arn {
scope_179.string(var_180);
}
#[allow(unused_mut)]
let mut scope_181 = writer.prefix("Weight");
if let Some(var_182) = &input.weight {
scope_181.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_182).into()),
);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_target_group_stickiness_config(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::TargetGroupStickinessConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_183 = writer.prefix("Enabled");
if let Some(var_184) = &input.enabled {
scope_183.boolean(*var_184);
}
#[allow(unused_mut)]
let mut scope_185 = writer.prefix("DurationSeconds");
if let Some(var_186) = &input.duration_seconds {
scope_185.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_186).into()),
);
}
Ok(())
}
#[allow(unused_mut)]
pub fn serialize_structure_crate_model_query_string_key_value_pair(
mut writer: aws_smithy_query::QueryValueWriter,
input: &crate::model::QueryStringKeyValuePair,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
#[allow(unused_mut)]
let mut scope_187 = writer.prefix("Key");
if let Some(var_188) = &input.key {
scope_187.string(var_188);
}
#[allow(unused_mut)]
let mut scope_189 = writer.prefix("Value");
if let Some(var_190) = &input.value {
scope_189.string(var_190);
}
Ok(())
}