aws-sdk-elasticloadbalancingv2 0.24.0

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
pub fn parse_http_generic_error(
    response: &http::Response<bytes::Bytes>,
) -> Result<aws_smithy_types::Error, aws_smithy_xml::decode::XmlDecodeError> {
    crate::rest_xml_wrapped_errors::parse_generic_error(response.body().as_ref())
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_certificate_not_found_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::certificate_not_found_exception::Builder,
) -> Result<
    crate::error::certificate_not_found_exception::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#CertificateNotFoundException$Message */ =>  {
                let var_1 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_1);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_listener_not_found_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::listener_not_found_exception::Builder,
) -> Result<
    crate::error::listener_not_found_exception::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#ListenerNotFoundException$Message */ =>  {
                let var_2 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_2);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_too_many_certificates_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::too_many_certificates_exception::Builder,
) -> Result<
    crate::error::too_many_certificates_exception::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#TooManyCertificatesException$Message */ =>  {
                let var_3 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_3);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_operation_crate_operation_add_listener_certificates(
    inp: &[u8],
    mut builder: crate::output::add_listener_certificates_output::Builder,
) -> Result<
    crate::output::add_listener_certificates_output::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    let mut doc = aws_smithy_xml::decode::Document::try_from(inp)?;

    #[allow(unused_mut)]
    let mut decoder = doc.root_element()?;
    #[allow(unused_variables)]
    let start_el = decoder.start_el();
    if !(start_el.matches("AddListenerCertificatesResponse")) {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
            "invalid root, expected AddListenerCertificatesResponse got {:?}",
            start_el
        )));
    }
    if let Some(mut result_tag) = decoder.next_tag() {
        let start_el = result_tag.start_el();
        if !(start_el.matches("AddListenerCertificatesResult")) {
            return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
                "invalid result, expected AddListenerCertificatesResult got {:?}",
                start_el
            )));
        }
        while let Some(mut tag) = result_tag.next_tag() {
            match tag.start_el() {
            s if s.matches("Certificates") /* Certificates com.amazonaws.elasticloadbalancingv2.synthetic#AddListenerCertificatesOutput$Certificates */ =>  {
                let var_4 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_certificate_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_certificates(var_4);
            }
            ,
            _ => {}
        }
        }
    } else {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(
            "expected AddListenerCertificatesResult tag",
        ));
    };
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_duplicate_tag_keys_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::duplicate_tag_keys_exception::Builder,
) -> Result<
    crate::error::duplicate_tag_keys_exception::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#DuplicateTagKeysException$Message */ =>  {
                let var_5 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_5);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_load_balancer_not_found_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::load_balancer_not_found_exception::Builder,
) -> Result<
    crate::error::load_balancer_not_found_exception::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#LoadBalancerNotFoundException$Message */ =>  {
                let var_6 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_6);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_rule_not_found_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::rule_not_found_exception::Builder,
) -> Result<crate::error::rule_not_found_exception::Builder, aws_smithy_xml::decode::XmlDecodeError>
{
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#RuleNotFoundException$Message */ =>  {
                let var_7 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_7);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_target_group_not_found_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::target_group_not_found_exception::Builder,
) -> Result<
    crate::error::target_group_not_found_exception::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#TargetGroupNotFoundException$Message */ =>  {
                let var_8 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_8);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_too_many_tags_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::too_many_tags_exception::Builder,
) -> Result<crate::error::too_many_tags_exception::Builder, aws_smithy_xml::decode::XmlDecodeError>
{
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#TooManyTagsException$Message */ =>  {
                let var_9 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_9);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_alpn_policy_not_supported_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::alpn_policy_not_supported_exception::Builder,
) -> Result<
    crate::error::alpn_policy_not_supported_exception::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#ALPNPolicyNotSupportedException$Message */ =>  {
                let var_10 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_10);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_duplicate_listener_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::duplicate_listener_exception::Builder,
) -> Result<
    crate::error::duplicate_listener_exception::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#DuplicateListenerException$Message */ =>  {
                let var_11 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_11);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_incompatible_protocols_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::incompatible_protocols_exception::Builder,
) -> Result<
    crate::error::incompatible_protocols_exception::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#IncompatibleProtocolsException$Message */ =>  {
                let var_12 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_12);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_invalid_configuration_request_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::invalid_configuration_request_exception::Builder,
) -> Result<
    crate::error::invalid_configuration_request_exception::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#InvalidConfigurationRequestException$Message */ =>  {
                let var_13 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_13);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_invalid_load_balancer_action_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::invalid_load_balancer_action_exception::Builder,
) -> Result<
    crate::error::invalid_load_balancer_action_exception::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#InvalidLoadBalancerActionException$Message */ =>  {
                let var_14 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_14);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_ssl_policy_not_found_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::ssl_policy_not_found_exception::Builder,
) -> Result<
    crate::error::ssl_policy_not_found_exception::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#SSLPolicyNotFoundException$Message */ =>  {
                let var_15 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_15);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_target_group_association_limit_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::target_group_association_limit_exception::Builder,
) -> Result<
    crate::error::target_group_association_limit_exception::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#TargetGroupAssociationLimitException$Message */ =>  {
                let var_16 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_16);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_too_many_actions_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::too_many_actions_exception::Builder,
) -> Result<crate::error::too_many_actions_exception::Builder, aws_smithy_xml::decode::XmlDecodeError>
{
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#TooManyActionsException$Message */ =>  {
                let var_17 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_17);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_too_many_listeners_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::too_many_listeners_exception::Builder,
) -> Result<
    crate::error::too_many_listeners_exception::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#TooManyListenersException$Message */ =>  {
                let var_18 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_18);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_too_many_registrations_for_target_id_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::too_many_registrations_for_target_id_exception::Builder,
) -> Result<
    crate::error::too_many_registrations_for_target_id_exception::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#TooManyRegistrationsForTargetIdException$Message */ =>  {
                let var_19 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_19);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_too_many_targets_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::too_many_targets_exception::Builder,
) -> Result<crate::error::too_many_targets_exception::Builder, aws_smithy_xml::decode::XmlDecodeError>
{
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#TooManyTargetsException$Message */ =>  {
                let var_20 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_20);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_too_many_unique_target_groups_per_load_balancer_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::too_many_unique_target_groups_per_load_balancer_exception::Builder,
) -> Result<
    crate::error::too_many_unique_target_groups_per_load_balancer_exception::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#TooManyUniqueTargetGroupsPerLoadBalancerException$Message */ =>  {
                let var_21 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_21);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_unsupported_protocol_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::unsupported_protocol_exception::Builder,
) -> Result<
    crate::error::unsupported_protocol_exception::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#UnsupportedProtocolException$Message */ =>  {
                let var_22 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_22);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_operation_crate_operation_create_listener(
    inp: &[u8],
    mut builder: crate::output::create_listener_output::Builder,
) -> Result<crate::output::create_listener_output::Builder, aws_smithy_xml::decode::XmlDecodeError>
{
    let mut doc = aws_smithy_xml::decode::Document::try_from(inp)?;

    #[allow(unused_mut)]
    let mut decoder = doc.root_element()?;
    #[allow(unused_variables)]
    let start_el = decoder.start_el();
    if !(start_el.matches("CreateListenerResponse")) {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
            "invalid root, expected CreateListenerResponse got {:?}",
            start_el
        )));
    }
    if let Some(mut result_tag) = decoder.next_tag() {
        let start_el = result_tag.start_el();
        if !(start_el.matches("CreateListenerResult")) {
            return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
                "invalid result, expected CreateListenerResult got {:?}",
                start_el
            )));
        }
        while let Some(mut tag) = result_tag.next_tag() {
            match tag.start_el() {
            s if s.matches("Listeners") /* Listeners com.amazonaws.elasticloadbalancingv2.synthetic#CreateListenerOutput$Listeners */ =>  {
                let var_23 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_listeners(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_listeners(var_23);
            }
            ,
            _ => {}
        }
        }
    } else {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(
            "expected CreateListenerResult tag",
        ));
    };
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_allocation_id_not_found_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::allocation_id_not_found_exception::Builder,
) -> Result<
    crate::error::allocation_id_not_found_exception::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#AllocationIdNotFoundException$Message */ =>  {
                let var_24 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_24);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_availability_zone_not_supported_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::availability_zone_not_supported_exception::Builder,
) -> Result<
    crate::error::availability_zone_not_supported_exception::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#AvailabilityZoneNotSupportedException$Message */ =>  {
                let var_25 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_25);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_duplicate_load_balancer_name_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::duplicate_load_balancer_name_exception::Builder,
) -> Result<
    crate::error::duplicate_load_balancer_name_exception::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#DuplicateLoadBalancerNameException$Message */ =>  {
                let var_26 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_26);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_invalid_scheme_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::invalid_scheme_exception::Builder,
) -> Result<crate::error::invalid_scheme_exception::Builder, aws_smithy_xml::decode::XmlDecodeError>
{
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#InvalidSchemeException$Message */ =>  {
                let var_27 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_27);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_invalid_security_group_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::invalid_security_group_exception::Builder,
) -> Result<
    crate::error::invalid_security_group_exception::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#InvalidSecurityGroupException$Message */ =>  {
                let var_28 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_28);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_invalid_subnet_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::invalid_subnet_exception::Builder,
) -> Result<crate::error::invalid_subnet_exception::Builder, aws_smithy_xml::decode::XmlDecodeError>
{
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#InvalidSubnetException$Message */ =>  {
                let var_29 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_29);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_operation_not_permitted_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::operation_not_permitted_exception::Builder,
) -> Result<
    crate::error::operation_not_permitted_exception::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#OperationNotPermittedException$Message */ =>  {
                let var_30 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_30);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_resource_in_use_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::resource_in_use_exception::Builder,
) -> Result<crate::error::resource_in_use_exception::Builder, aws_smithy_xml::decode::XmlDecodeError>
{
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#ResourceInUseException$Message */ =>  {
                let var_31 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_31);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_subnet_not_found_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::subnet_not_found_exception::Builder,
) -> Result<crate::error::subnet_not_found_exception::Builder, aws_smithy_xml::decode::XmlDecodeError>
{
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#SubnetNotFoundException$Message */ =>  {
                let var_32 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_32);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_too_many_load_balancers_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::too_many_load_balancers_exception::Builder,
) -> Result<
    crate::error::too_many_load_balancers_exception::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#TooManyLoadBalancersException$Message */ =>  {
                let var_33 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_33);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_operation_crate_operation_create_load_balancer(
    inp: &[u8],
    mut builder: crate::output::create_load_balancer_output::Builder,
) -> Result<
    crate::output::create_load_balancer_output::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    let mut doc = aws_smithy_xml::decode::Document::try_from(inp)?;

    #[allow(unused_mut)]
    let mut decoder = doc.root_element()?;
    #[allow(unused_variables)]
    let start_el = decoder.start_el();
    if !(start_el.matches("CreateLoadBalancerResponse")) {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
            "invalid root, expected CreateLoadBalancerResponse got {:?}",
            start_el
        )));
    }
    if let Some(mut result_tag) = decoder.next_tag() {
        let start_el = result_tag.start_el();
        if !(start_el.matches("CreateLoadBalancerResult")) {
            return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
                "invalid result, expected CreateLoadBalancerResult got {:?}",
                start_el
            )));
        }
        while let Some(mut tag) = result_tag.next_tag() {
            match tag.start_el() {
            s if s.matches("LoadBalancers") /* LoadBalancers com.amazonaws.elasticloadbalancingv2.synthetic#CreateLoadBalancerOutput$LoadBalancers */ =>  {
                let var_34 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_load_balancers(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_load_balancers(var_34);
            }
            ,
            _ => {}
        }
        }
    } else {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(
            "expected CreateLoadBalancerResult tag",
        ));
    };
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_priority_in_use_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::priority_in_use_exception::Builder,
) -> Result<crate::error::priority_in_use_exception::Builder, aws_smithy_xml::decode::XmlDecodeError>
{
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#PriorityInUseException$Message */ =>  {
                let var_35 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_35);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_too_many_rules_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::too_many_rules_exception::Builder,
) -> Result<crate::error::too_many_rules_exception::Builder, aws_smithy_xml::decode::XmlDecodeError>
{
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#TooManyRulesException$Message */ =>  {
                let var_36 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_36);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_too_many_target_groups_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::too_many_target_groups_exception::Builder,
) -> Result<
    crate::error::too_many_target_groups_exception::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#TooManyTargetGroupsException$Message */ =>  {
                let var_37 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_37);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_operation_crate_operation_create_rule(
    inp: &[u8],
    mut builder: crate::output::create_rule_output::Builder,
) -> Result<crate::output::create_rule_output::Builder, aws_smithy_xml::decode::XmlDecodeError> {
    let mut doc = aws_smithy_xml::decode::Document::try_from(inp)?;

    #[allow(unused_mut)]
    let mut decoder = doc.root_element()?;
    #[allow(unused_variables)]
    let start_el = decoder.start_el();
    if !(start_el.matches("CreateRuleResponse")) {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
            "invalid root, expected CreateRuleResponse got {:?}",
            start_el
        )));
    }
    if let Some(mut result_tag) = decoder.next_tag() {
        let start_el = result_tag.start_el();
        if !(start_el.matches("CreateRuleResult")) {
            return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
                "invalid result, expected CreateRuleResult got {:?}",
                start_el
            )));
        }
        while let Some(mut tag) = result_tag.next_tag() {
            match tag.start_el() {
            s if s.matches("Rules") /* Rules com.amazonaws.elasticloadbalancingv2.synthetic#CreateRuleOutput$Rules */ =>  {
                let var_38 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_rules(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_rules(var_38);
            }
            ,
            _ => {}
        }
        }
    } else {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(
            "expected CreateRuleResult tag",
        ));
    };
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_duplicate_target_group_name_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::duplicate_target_group_name_exception::Builder,
) -> Result<
    crate::error::duplicate_target_group_name_exception::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#DuplicateTargetGroupNameException$Message */ =>  {
                let var_39 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_39);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_operation_crate_operation_create_target_group(
    inp: &[u8],
    mut builder: crate::output::create_target_group_output::Builder,
) -> Result<
    crate::output::create_target_group_output::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    let mut doc = aws_smithy_xml::decode::Document::try_from(inp)?;

    #[allow(unused_mut)]
    let mut decoder = doc.root_element()?;
    #[allow(unused_variables)]
    let start_el = decoder.start_el();
    if !(start_el.matches("CreateTargetGroupResponse")) {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
            "invalid root, expected CreateTargetGroupResponse got {:?}",
            start_el
        )));
    }
    if let Some(mut result_tag) = decoder.next_tag() {
        let start_el = result_tag.start_el();
        if !(start_el.matches("CreateTargetGroupResult")) {
            return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
                "invalid result, expected CreateTargetGroupResult got {:?}",
                start_el
            )));
        }
        while let Some(mut tag) = result_tag.next_tag() {
            match tag.start_el() {
            s if s.matches("TargetGroups") /* TargetGroups com.amazonaws.elasticloadbalancingv2.synthetic#CreateTargetGroupOutput$TargetGroups */ =>  {
                let var_40 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_target_groups(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_target_groups(var_40);
            }
            ,
            _ => {}
        }
        }
    } else {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(
            "expected CreateTargetGroupResult tag",
        ));
    };
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_invalid_target_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::invalid_target_exception::Builder,
) -> Result<crate::error::invalid_target_exception::Builder, aws_smithy_xml::decode::XmlDecodeError>
{
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#InvalidTargetException$Message */ =>  {
                let var_41 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_41);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_operation_crate_operation_describe_account_limits(
    inp: &[u8],
    mut builder: crate::output::describe_account_limits_output::Builder,
) -> Result<
    crate::output::describe_account_limits_output::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    let mut doc = aws_smithy_xml::decode::Document::try_from(inp)?;

    #[allow(unused_mut)]
    let mut decoder = doc.root_element()?;
    #[allow(unused_variables)]
    let start_el = decoder.start_el();
    if !(start_el.matches("DescribeAccountLimitsResponse")) {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
            "invalid root, expected DescribeAccountLimitsResponse got {:?}",
            start_el
        )));
    }
    if let Some(mut result_tag) = decoder.next_tag() {
        let start_el = result_tag.start_el();
        if !(start_el.matches("DescribeAccountLimitsResult")) {
            return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
                "invalid result, expected DescribeAccountLimitsResult got {:?}",
                start_el
            )));
        }
        while let Some(mut tag) = result_tag.next_tag() {
            match tag.start_el() {
            s if s.matches("Limits") /* Limits com.amazonaws.elasticloadbalancingv2.synthetic#DescribeAccountLimitsOutput$Limits */ =>  {
                let var_42 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_limits(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_limits(var_42);
            }
            ,
            s if s.matches("NextMarker") /* NextMarker com.amazonaws.elasticloadbalancingv2.synthetic#DescribeAccountLimitsOutput$NextMarker */ =>  {
                let var_43 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_next_marker(var_43);
            }
            ,
            _ => {}
        }
        }
    } else {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(
            "expected DescribeAccountLimitsResult tag",
        ));
    };
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_operation_crate_operation_describe_listener_certificates(
    inp: &[u8],
    mut builder: crate::output::describe_listener_certificates_output::Builder,
) -> Result<
    crate::output::describe_listener_certificates_output::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    let mut doc = aws_smithy_xml::decode::Document::try_from(inp)?;

    #[allow(unused_mut)]
    let mut decoder = doc.root_element()?;
    #[allow(unused_variables)]
    let start_el = decoder.start_el();
    if !(start_el.matches("DescribeListenerCertificatesResponse")) {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
            "invalid root, expected DescribeListenerCertificatesResponse got {:?}",
            start_el
        )));
    }
    if let Some(mut result_tag) = decoder.next_tag() {
        let start_el = result_tag.start_el();
        if !(start_el.matches("DescribeListenerCertificatesResult")) {
            return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
                "invalid result, expected DescribeListenerCertificatesResult got {:?}",
                start_el
            )));
        }
        while let Some(mut tag) = result_tag.next_tag() {
            match tag.start_el() {
            s if s.matches("Certificates") /* Certificates com.amazonaws.elasticloadbalancingv2.synthetic#DescribeListenerCertificatesOutput$Certificates */ =>  {
                let var_44 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_certificate_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_certificates(var_44);
            }
            ,
            s if s.matches("NextMarker") /* NextMarker com.amazonaws.elasticloadbalancingv2.synthetic#DescribeListenerCertificatesOutput$NextMarker */ =>  {
                let var_45 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_next_marker(var_45);
            }
            ,
            _ => {}
        }
        }
    } else {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(
            "expected DescribeListenerCertificatesResult tag",
        ));
    };
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_operation_crate_operation_describe_listeners(
    inp: &[u8],
    mut builder: crate::output::describe_listeners_output::Builder,
) -> Result<crate::output::describe_listeners_output::Builder, aws_smithy_xml::decode::XmlDecodeError>
{
    let mut doc = aws_smithy_xml::decode::Document::try_from(inp)?;

    #[allow(unused_mut)]
    let mut decoder = doc.root_element()?;
    #[allow(unused_variables)]
    let start_el = decoder.start_el();
    if !(start_el.matches("DescribeListenersResponse")) {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
            "invalid root, expected DescribeListenersResponse got {:?}",
            start_el
        )));
    }
    if let Some(mut result_tag) = decoder.next_tag() {
        let start_el = result_tag.start_el();
        if !(start_el.matches("DescribeListenersResult")) {
            return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
                "invalid result, expected DescribeListenersResult got {:?}",
                start_el
            )));
        }
        while let Some(mut tag) = result_tag.next_tag() {
            match tag.start_el() {
            s if s.matches("Listeners") /* Listeners com.amazonaws.elasticloadbalancingv2.synthetic#DescribeListenersOutput$Listeners */ =>  {
                let var_46 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_listeners(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_listeners(var_46);
            }
            ,
            s if s.matches("NextMarker") /* NextMarker com.amazonaws.elasticloadbalancingv2.synthetic#DescribeListenersOutput$NextMarker */ =>  {
                let var_47 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_next_marker(var_47);
            }
            ,
            _ => {}
        }
        }
    } else {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(
            "expected DescribeListenersResult tag",
        ));
    };
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_operation_crate_operation_describe_load_balancer_attributes(
    inp: &[u8],
    mut builder: crate::output::describe_load_balancer_attributes_output::Builder,
) -> Result<
    crate::output::describe_load_balancer_attributes_output::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    let mut doc = aws_smithy_xml::decode::Document::try_from(inp)?;

    #[allow(unused_mut)]
    let mut decoder = doc.root_element()?;
    #[allow(unused_variables)]
    let start_el = decoder.start_el();
    if !(start_el.matches("DescribeLoadBalancerAttributesResponse")) {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
            "invalid root, expected DescribeLoadBalancerAttributesResponse got {:?}",
            start_el
        )));
    }
    if let Some(mut result_tag) = decoder.next_tag() {
        let start_el = result_tag.start_el();
        if !(start_el.matches("DescribeLoadBalancerAttributesResult")) {
            return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
                "invalid result, expected DescribeLoadBalancerAttributesResult got {:?}",
                start_el
            )));
        }
        while let Some(mut tag) = result_tag.next_tag() {
            match tag.start_el() {
            s if s.matches("Attributes") /* Attributes com.amazonaws.elasticloadbalancingv2.synthetic#DescribeLoadBalancerAttributesOutput$Attributes */ =>  {
                let var_48 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_load_balancer_attributes(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_attributes(var_48);
            }
            ,
            _ => {}
        }
        }
    } else {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(
            "expected DescribeLoadBalancerAttributesResult tag",
        ));
    };
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_operation_crate_operation_describe_load_balancers(
    inp: &[u8],
    mut builder: crate::output::describe_load_balancers_output::Builder,
) -> Result<
    crate::output::describe_load_balancers_output::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    let mut doc = aws_smithy_xml::decode::Document::try_from(inp)?;

    #[allow(unused_mut)]
    let mut decoder = doc.root_element()?;
    #[allow(unused_variables)]
    let start_el = decoder.start_el();
    if !(start_el.matches("DescribeLoadBalancersResponse")) {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
            "invalid root, expected DescribeLoadBalancersResponse got {:?}",
            start_el
        )));
    }
    if let Some(mut result_tag) = decoder.next_tag() {
        let start_el = result_tag.start_el();
        if !(start_el.matches("DescribeLoadBalancersResult")) {
            return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
                "invalid result, expected DescribeLoadBalancersResult got {:?}",
                start_el
            )));
        }
        while let Some(mut tag) = result_tag.next_tag() {
            match tag.start_el() {
            s if s.matches("LoadBalancers") /* LoadBalancers com.amazonaws.elasticloadbalancingv2.synthetic#DescribeLoadBalancersOutput$LoadBalancers */ =>  {
                let var_49 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_load_balancers(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_load_balancers(var_49);
            }
            ,
            s if s.matches("NextMarker") /* NextMarker com.amazonaws.elasticloadbalancingv2.synthetic#DescribeLoadBalancersOutput$NextMarker */ =>  {
                let var_50 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_next_marker(var_50);
            }
            ,
            _ => {}
        }
        }
    } else {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(
            "expected DescribeLoadBalancersResult tag",
        ));
    };
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_operation_crate_operation_describe_rules(
    inp: &[u8],
    mut builder: crate::output::describe_rules_output::Builder,
) -> Result<crate::output::describe_rules_output::Builder, aws_smithy_xml::decode::XmlDecodeError> {
    let mut doc = aws_smithy_xml::decode::Document::try_from(inp)?;

    #[allow(unused_mut)]
    let mut decoder = doc.root_element()?;
    #[allow(unused_variables)]
    let start_el = decoder.start_el();
    if !(start_el.matches("DescribeRulesResponse")) {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
            "invalid root, expected DescribeRulesResponse got {:?}",
            start_el
        )));
    }
    if let Some(mut result_tag) = decoder.next_tag() {
        let start_el = result_tag.start_el();
        if !(start_el.matches("DescribeRulesResult")) {
            return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
                "invalid result, expected DescribeRulesResult got {:?}",
                start_el
            )));
        }
        while let Some(mut tag) = result_tag.next_tag() {
            match tag.start_el() {
            s if s.matches("Rules") /* Rules com.amazonaws.elasticloadbalancingv2.synthetic#DescribeRulesOutput$Rules */ =>  {
                let var_51 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_rules(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_rules(var_51);
            }
            ,
            s if s.matches("NextMarker") /* NextMarker com.amazonaws.elasticloadbalancingv2.synthetic#DescribeRulesOutput$NextMarker */ =>  {
                let var_52 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_next_marker(var_52);
            }
            ,
            _ => {}
        }
        }
    } else {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(
            "expected DescribeRulesResult tag",
        ));
    };
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_operation_crate_operation_describe_ssl_policies(
    inp: &[u8],
    mut builder: crate::output::describe_ssl_policies_output::Builder,
) -> Result<
    crate::output::describe_ssl_policies_output::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    let mut doc = aws_smithy_xml::decode::Document::try_from(inp)?;

    #[allow(unused_mut)]
    let mut decoder = doc.root_element()?;
    #[allow(unused_variables)]
    let start_el = decoder.start_el();
    if !(start_el.matches("DescribeSSLPoliciesResponse")) {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
            "invalid root, expected DescribeSSLPoliciesResponse got {:?}",
            start_el
        )));
    }
    if let Some(mut result_tag) = decoder.next_tag() {
        let start_el = result_tag.start_el();
        if !(start_el.matches("DescribeSSLPoliciesResult")) {
            return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
                "invalid result, expected DescribeSSLPoliciesResult got {:?}",
                start_el
            )));
        }
        while let Some(mut tag) = result_tag.next_tag() {
            match tag.start_el() {
            s if s.matches("SslPolicies") /* SslPolicies com.amazonaws.elasticloadbalancingv2.synthetic#DescribeSSLPoliciesOutput$SslPolicies */ =>  {
                let var_53 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_ssl_policies(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_ssl_policies(var_53);
            }
            ,
            s if s.matches("NextMarker") /* NextMarker com.amazonaws.elasticloadbalancingv2.synthetic#DescribeSSLPoliciesOutput$NextMarker */ =>  {
                let var_54 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_next_marker(var_54);
            }
            ,
            _ => {}
        }
        }
    } else {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(
            "expected DescribeSSLPoliciesResult tag",
        ));
    };
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_operation_crate_operation_describe_tags(
    inp: &[u8],
    mut builder: crate::output::describe_tags_output::Builder,
) -> Result<crate::output::describe_tags_output::Builder, aws_smithy_xml::decode::XmlDecodeError> {
    let mut doc = aws_smithy_xml::decode::Document::try_from(inp)?;

    #[allow(unused_mut)]
    let mut decoder = doc.root_element()?;
    #[allow(unused_variables)]
    let start_el = decoder.start_el();
    if !(start_el.matches("DescribeTagsResponse")) {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
            "invalid root, expected DescribeTagsResponse got {:?}",
            start_el
        )));
    }
    if let Some(mut result_tag) = decoder.next_tag() {
        let start_el = result_tag.start_el();
        if !(start_el.matches("DescribeTagsResult")) {
            return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
                "invalid result, expected DescribeTagsResult got {:?}",
                start_el
            )));
        }
        while let Some(mut tag) = result_tag.next_tag() {
            match tag.start_el() {
            s if s.matches("TagDescriptions") /* TagDescriptions com.amazonaws.elasticloadbalancingv2.synthetic#DescribeTagsOutput$TagDescriptions */ =>  {
                let var_55 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_tag_descriptions(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_tag_descriptions(var_55);
            }
            ,
            _ => {}
        }
        }
    } else {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(
            "expected DescribeTagsResult tag",
        ));
    };
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_operation_crate_operation_describe_target_group_attributes(
    inp: &[u8],
    mut builder: crate::output::describe_target_group_attributes_output::Builder,
) -> Result<
    crate::output::describe_target_group_attributes_output::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    let mut doc = aws_smithy_xml::decode::Document::try_from(inp)?;

    #[allow(unused_mut)]
    let mut decoder = doc.root_element()?;
    #[allow(unused_variables)]
    let start_el = decoder.start_el();
    if !(start_el.matches("DescribeTargetGroupAttributesResponse")) {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
            "invalid root, expected DescribeTargetGroupAttributesResponse got {:?}",
            start_el
        )));
    }
    if let Some(mut result_tag) = decoder.next_tag() {
        let start_el = result_tag.start_el();
        if !(start_el.matches("DescribeTargetGroupAttributesResult")) {
            return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
                "invalid result, expected DescribeTargetGroupAttributesResult got {:?}",
                start_el
            )));
        }
        while let Some(mut tag) = result_tag.next_tag() {
            match tag.start_el() {
            s if s.matches("Attributes") /* Attributes com.amazonaws.elasticloadbalancingv2.synthetic#DescribeTargetGroupAttributesOutput$Attributes */ =>  {
                let var_56 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_target_group_attributes(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_attributes(var_56);
            }
            ,
            _ => {}
        }
        }
    } else {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(
            "expected DescribeTargetGroupAttributesResult tag",
        ));
    };
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_operation_crate_operation_describe_target_groups(
    inp: &[u8],
    mut builder: crate::output::describe_target_groups_output::Builder,
) -> Result<
    crate::output::describe_target_groups_output::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    let mut doc = aws_smithy_xml::decode::Document::try_from(inp)?;

    #[allow(unused_mut)]
    let mut decoder = doc.root_element()?;
    #[allow(unused_variables)]
    let start_el = decoder.start_el();
    if !(start_el.matches("DescribeTargetGroupsResponse")) {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
            "invalid root, expected DescribeTargetGroupsResponse got {:?}",
            start_el
        )));
    }
    if let Some(mut result_tag) = decoder.next_tag() {
        let start_el = result_tag.start_el();
        if !(start_el.matches("DescribeTargetGroupsResult")) {
            return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
                "invalid result, expected DescribeTargetGroupsResult got {:?}",
                start_el
            )));
        }
        while let Some(mut tag) = result_tag.next_tag() {
            match tag.start_el() {
            s if s.matches("TargetGroups") /* TargetGroups com.amazonaws.elasticloadbalancingv2.synthetic#DescribeTargetGroupsOutput$TargetGroups */ =>  {
                let var_57 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_target_groups(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_target_groups(var_57);
            }
            ,
            s if s.matches("NextMarker") /* NextMarker com.amazonaws.elasticloadbalancingv2.synthetic#DescribeTargetGroupsOutput$NextMarker */ =>  {
                let var_58 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_next_marker(var_58);
            }
            ,
            _ => {}
        }
        }
    } else {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(
            "expected DescribeTargetGroupsResult tag",
        ));
    };
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_structure_crate_error_health_unavailable_exception_xml_err(
    inp: &[u8],
    mut builder: crate::error::health_unavailable_exception::Builder,
) -> Result<
    crate::error::health_unavailable_exception::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    if inp.is_empty() {
        return Ok(builder);
    }
    let mut document = aws_smithy_xml::decode::Document::try_from(inp)?;
    #[allow(unused_mut)]
    let mut error_decoder = crate::rest_xml_wrapped_errors::error_scope(&mut document)?;
    while let Some(mut tag) = error_decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Message") /* Message com.amazonaws.elasticloadbalancingv2#HealthUnavailableException$Message */ =>  {
                let var_59 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message(var_59);
            }
            ,
            _ => {}
        }
    }
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_operation_crate_operation_describe_target_health(
    inp: &[u8],
    mut builder: crate::output::describe_target_health_output::Builder,
) -> Result<
    crate::output::describe_target_health_output::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    let mut doc = aws_smithy_xml::decode::Document::try_from(inp)?;

    #[allow(unused_mut)]
    let mut decoder = doc.root_element()?;
    #[allow(unused_variables)]
    let start_el = decoder.start_el();
    if !(start_el.matches("DescribeTargetHealthResponse")) {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
            "invalid root, expected DescribeTargetHealthResponse got {:?}",
            start_el
        )));
    }
    if let Some(mut result_tag) = decoder.next_tag() {
        let start_el = result_tag.start_el();
        if !(start_el.matches("DescribeTargetHealthResult")) {
            return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
                "invalid result, expected DescribeTargetHealthResult got {:?}",
                start_el
            )));
        }
        while let Some(mut tag) = result_tag.next_tag() {
            match tag.start_el() {
            s if s.matches("TargetHealthDescriptions") /* TargetHealthDescriptions com.amazonaws.elasticloadbalancingv2.synthetic#DescribeTargetHealthOutput$TargetHealthDescriptions */ =>  {
                let var_60 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_target_health_descriptions(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_target_health_descriptions(var_60);
            }
            ,
            _ => {}
        }
        }
    } else {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(
            "expected DescribeTargetHealthResult tag",
        ));
    };
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_operation_crate_operation_modify_listener(
    inp: &[u8],
    mut builder: crate::output::modify_listener_output::Builder,
) -> Result<crate::output::modify_listener_output::Builder, aws_smithy_xml::decode::XmlDecodeError>
{
    let mut doc = aws_smithy_xml::decode::Document::try_from(inp)?;

    #[allow(unused_mut)]
    let mut decoder = doc.root_element()?;
    #[allow(unused_variables)]
    let start_el = decoder.start_el();
    if !(start_el.matches("ModifyListenerResponse")) {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
            "invalid root, expected ModifyListenerResponse got {:?}",
            start_el
        )));
    }
    if let Some(mut result_tag) = decoder.next_tag() {
        let start_el = result_tag.start_el();
        if !(start_el.matches("ModifyListenerResult")) {
            return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
                "invalid result, expected ModifyListenerResult got {:?}",
                start_el
            )));
        }
        while let Some(mut tag) = result_tag.next_tag() {
            match tag.start_el() {
            s if s.matches("Listeners") /* Listeners com.amazonaws.elasticloadbalancingv2.synthetic#ModifyListenerOutput$Listeners */ =>  {
                let var_61 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_listeners(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_listeners(var_61);
            }
            ,
            _ => {}
        }
        }
    } else {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(
            "expected ModifyListenerResult tag",
        ));
    };
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_operation_crate_operation_modify_load_balancer_attributes(
    inp: &[u8],
    mut builder: crate::output::modify_load_balancer_attributes_output::Builder,
) -> Result<
    crate::output::modify_load_balancer_attributes_output::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    let mut doc = aws_smithy_xml::decode::Document::try_from(inp)?;

    #[allow(unused_mut)]
    let mut decoder = doc.root_element()?;
    #[allow(unused_variables)]
    let start_el = decoder.start_el();
    if !(start_el.matches("ModifyLoadBalancerAttributesResponse")) {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
            "invalid root, expected ModifyLoadBalancerAttributesResponse got {:?}",
            start_el
        )));
    }
    if let Some(mut result_tag) = decoder.next_tag() {
        let start_el = result_tag.start_el();
        if !(start_el.matches("ModifyLoadBalancerAttributesResult")) {
            return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
                "invalid result, expected ModifyLoadBalancerAttributesResult got {:?}",
                start_el
            )));
        }
        while let Some(mut tag) = result_tag.next_tag() {
            match tag.start_el() {
            s if s.matches("Attributes") /* Attributes com.amazonaws.elasticloadbalancingv2.synthetic#ModifyLoadBalancerAttributesOutput$Attributes */ =>  {
                let var_62 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_load_balancer_attributes(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_attributes(var_62);
            }
            ,
            _ => {}
        }
        }
    } else {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(
            "expected ModifyLoadBalancerAttributesResult tag",
        ));
    };
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_operation_crate_operation_modify_rule(
    inp: &[u8],
    mut builder: crate::output::modify_rule_output::Builder,
) -> Result<crate::output::modify_rule_output::Builder, aws_smithy_xml::decode::XmlDecodeError> {
    let mut doc = aws_smithy_xml::decode::Document::try_from(inp)?;

    #[allow(unused_mut)]
    let mut decoder = doc.root_element()?;
    #[allow(unused_variables)]
    let start_el = decoder.start_el();
    if !(start_el.matches("ModifyRuleResponse")) {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
            "invalid root, expected ModifyRuleResponse got {:?}",
            start_el
        )));
    }
    if let Some(mut result_tag) = decoder.next_tag() {
        let start_el = result_tag.start_el();
        if !(start_el.matches("ModifyRuleResult")) {
            return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
                "invalid result, expected ModifyRuleResult got {:?}",
                start_el
            )));
        }
        while let Some(mut tag) = result_tag.next_tag() {
            match tag.start_el() {
            s if s.matches("Rules") /* Rules com.amazonaws.elasticloadbalancingv2.synthetic#ModifyRuleOutput$Rules */ =>  {
                let var_63 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_rules(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_rules(var_63);
            }
            ,
            _ => {}
        }
        }
    } else {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(
            "expected ModifyRuleResult tag",
        ));
    };
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_operation_crate_operation_modify_target_group(
    inp: &[u8],
    mut builder: crate::output::modify_target_group_output::Builder,
) -> Result<
    crate::output::modify_target_group_output::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    let mut doc = aws_smithy_xml::decode::Document::try_from(inp)?;

    #[allow(unused_mut)]
    let mut decoder = doc.root_element()?;
    #[allow(unused_variables)]
    let start_el = decoder.start_el();
    if !(start_el.matches("ModifyTargetGroupResponse")) {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
            "invalid root, expected ModifyTargetGroupResponse got {:?}",
            start_el
        )));
    }
    if let Some(mut result_tag) = decoder.next_tag() {
        let start_el = result_tag.start_el();
        if !(start_el.matches("ModifyTargetGroupResult")) {
            return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
                "invalid result, expected ModifyTargetGroupResult got {:?}",
                start_el
            )));
        }
        while let Some(mut tag) = result_tag.next_tag() {
            match tag.start_el() {
            s if s.matches("TargetGroups") /* TargetGroups com.amazonaws.elasticloadbalancingv2.synthetic#ModifyTargetGroupOutput$TargetGroups */ =>  {
                let var_64 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_target_groups(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_target_groups(var_64);
            }
            ,
            _ => {}
        }
        }
    } else {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(
            "expected ModifyTargetGroupResult tag",
        ));
    };
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_operation_crate_operation_modify_target_group_attributes(
    inp: &[u8],
    mut builder: crate::output::modify_target_group_attributes_output::Builder,
) -> Result<
    crate::output::modify_target_group_attributes_output::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    let mut doc = aws_smithy_xml::decode::Document::try_from(inp)?;

    #[allow(unused_mut)]
    let mut decoder = doc.root_element()?;
    #[allow(unused_variables)]
    let start_el = decoder.start_el();
    if !(start_el.matches("ModifyTargetGroupAttributesResponse")) {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
            "invalid root, expected ModifyTargetGroupAttributesResponse got {:?}",
            start_el
        )));
    }
    if let Some(mut result_tag) = decoder.next_tag() {
        let start_el = result_tag.start_el();
        if !(start_el.matches("ModifyTargetGroupAttributesResult")) {
            return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
                "invalid result, expected ModifyTargetGroupAttributesResult got {:?}",
                start_el
            )));
        }
        while let Some(mut tag) = result_tag.next_tag() {
            match tag.start_el() {
            s if s.matches("Attributes") /* Attributes com.amazonaws.elasticloadbalancingv2.synthetic#ModifyTargetGroupAttributesOutput$Attributes */ =>  {
                let var_65 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_target_group_attributes(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_attributes(var_65);
            }
            ,
            _ => {}
        }
        }
    } else {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(
            "expected ModifyTargetGroupAttributesResult tag",
        ));
    };
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_operation_crate_operation_set_ip_address_type(
    inp: &[u8],
    mut builder: crate::output::set_ip_address_type_output::Builder,
) -> Result<
    crate::output::set_ip_address_type_output::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    let mut doc = aws_smithy_xml::decode::Document::try_from(inp)?;

    #[allow(unused_mut)]
    let mut decoder = doc.root_element()?;
    #[allow(unused_variables)]
    let start_el = decoder.start_el();
    if !(start_el.matches("SetIpAddressTypeResponse")) {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
            "invalid root, expected SetIpAddressTypeResponse got {:?}",
            start_el
        )));
    }
    if let Some(mut result_tag) = decoder.next_tag() {
        let start_el = result_tag.start_el();
        if !(start_el.matches("SetIpAddressTypeResult")) {
            return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
                "invalid result, expected SetIpAddressTypeResult got {:?}",
                start_el
            )));
        }
        while let Some(mut tag) = result_tag.next_tag() {
            match tag.start_el() {
            s if s.matches("IpAddressType") /* IpAddressType com.amazonaws.elasticloadbalancingv2.synthetic#SetIpAddressTypeOutput$IpAddressType */ =>  {
                let var_66 =
                    Some(
                        Result::<crate::model::IpAddressType, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::IpAddressType::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_ip_address_type(var_66);
            }
            ,
            _ => {}
        }
        }
    } else {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(
            "expected SetIpAddressTypeResult tag",
        ));
    };
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_operation_crate_operation_set_rule_priorities(
    inp: &[u8],
    mut builder: crate::output::set_rule_priorities_output::Builder,
) -> Result<
    crate::output::set_rule_priorities_output::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    let mut doc = aws_smithy_xml::decode::Document::try_from(inp)?;

    #[allow(unused_mut)]
    let mut decoder = doc.root_element()?;
    #[allow(unused_variables)]
    let start_el = decoder.start_el();
    if !(start_el.matches("SetRulePrioritiesResponse")) {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
            "invalid root, expected SetRulePrioritiesResponse got {:?}",
            start_el
        )));
    }
    if let Some(mut result_tag) = decoder.next_tag() {
        let start_el = result_tag.start_el();
        if !(start_el.matches("SetRulePrioritiesResult")) {
            return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
                "invalid result, expected SetRulePrioritiesResult got {:?}",
                start_el
            )));
        }
        while let Some(mut tag) = result_tag.next_tag() {
            match tag.start_el() {
            s if s.matches("Rules") /* Rules com.amazonaws.elasticloadbalancingv2.synthetic#SetRulePrioritiesOutput$Rules */ =>  {
                let var_67 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_rules(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_rules(var_67);
            }
            ,
            _ => {}
        }
        }
    } else {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(
            "expected SetRulePrioritiesResult tag",
        ));
    };
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_operation_crate_operation_set_security_groups(
    inp: &[u8],
    mut builder: crate::output::set_security_groups_output::Builder,
) -> Result<
    crate::output::set_security_groups_output::Builder,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    let mut doc = aws_smithy_xml::decode::Document::try_from(inp)?;

    #[allow(unused_mut)]
    let mut decoder = doc.root_element()?;
    #[allow(unused_variables)]
    let start_el = decoder.start_el();
    if !(start_el.matches("SetSecurityGroupsResponse")) {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
            "invalid root, expected SetSecurityGroupsResponse got {:?}",
            start_el
        )));
    }
    if let Some(mut result_tag) = decoder.next_tag() {
        let start_el = result_tag.start_el();
        if !(start_el.matches("SetSecurityGroupsResult")) {
            return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
                "invalid result, expected SetSecurityGroupsResult got {:?}",
                start_el
            )));
        }
        while let Some(mut tag) = result_tag.next_tag() {
            match tag.start_el() {
            s if s.matches("SecurityGroupIds") /* SecurityGroupIds com.amazonaws.elasticloadbalancingv2.synthetic#SetSecurityGroupsOutput$SecurityGroupIds */ =>  {
                let var_68 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_security_groups(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_security_group_ids(var_68);
            }
            ,
            _ => {}
        }
        }
    } else {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(
            "expected SetSecurityGroupsResult tag",
        ));
    };
    Ok(builder)
}

#[allow(unused_mut)]
pub fn deser_operation_crate_operation_set_subnets(
    inp: &[u8],
    mut builder: crate::output::set_subnets_output::Builder,
) -> Result<crate::output::set_subnets_output::Builder, aws_smithy_xml::decode::XmlDecodeError> {
    let mut doc = aws_smithy_xml::decode::Document::try_from(inp)?;

    #[allow(unused_mut)]
    let mut decoder = doc.root_element()?;
    #[allow(unused_variables)]
    let start_el = decoder.start_el();
    if !(start_el.matches("SetSubnetsResponse")) {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
            "invalid root, expected SetSubnetsResponse got {:?}",
            start_el
        )));
    }
    if let Some(mut result_tag) = decoder.next_tag() {
        let start_el = result_tag.start_el();
        if !(start_el.matches("SetSubnetsResult")) {
            return Err(aws_smithy_xml::decode::XmlDecodeError::custom(format!(
                "invalid result, expected SetSubnetsResult got {:?}",
                start_el
            )));
        }
        while let Some(mut tag) = result_tag.next_tag() {
            match tag.start_el() {
            s if s.matches("AvailabilityZones") /* AvailabilityZones com.amazonaws.elasticloadbalancingv2.synthetic#SetSubnetsOutput$AvailabilityZones */ =>  {
                let var_69 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_availability_zones(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_availability_zones(var_69);
            }
            ,
            s if s.matches("IpAddressType") /* IpAddressType com.amazonaws.elasticloadbalancingv2.synthetic#SetSubnetsOutput$IpAddressType */ =>  {
                let var_70 =
                    Some(
                        Result::<crate::model::IpAddressType, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::IpAddressType::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_ip_address_type(var_70);
            }
            ,
            _ => {}
        }
        }
    } else {
        return Err(aws_smithy_xml::decode::XmlDecodeError::custom(
            "expected SetSubnetsResult tag",
        ));
    };
    Ok(builder)
}

pub fn deser_list_com_amazonaws_elasticloadbalancingv2_certificate_list(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<std::vec::Vec<crate::model::Certificate>, aws_smithy_xml::decode::XmlDecodeError> {
    let mut out = std::vec::Vec::new();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("member") /* member com.amazonaws.elasticloadbalancingv2#CertificateList$member */ =>  {
                out.push(
                    crate::xml_deser::deser_structure_crate_model_certificate(&mut tag)
                    ?
                );
            }
            ,
            _ => {}
        }
    }
    Ok(out)
}

pub fn deser_list_com_amazonaws_elasticloadbalancingv2_listeners(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<std::vec::Vec<crate::model::Listener>, aws_smithy_xml::decode::XmlDecodeError> {
    let mut out = std::vec::Vec::new();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("member") /* member com.amazonaws.elasticloadbalancingv2#Listeners$member */ =>  {
                out.push(
                    crate::xml_deser::deser_structure_crate_model_listener(&mut tag)
                    ?
                );
            }
            ,
            _ => {}
        }
    }
    Ok(out)
}

pub fn deser_list_com_amazonaws_elasticloadbalancingv2_load_balancers(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<std::vec::Vec<crate::model::LoadBalancer>, aws_smithy_xml::decode::XmlDecodeError> {
    let mut out = std::vec::Vec::new();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("member") /* member com.amazonaws.elasticloadbalancingv2#LoadBalancers$member */ =>  {
                out.push(
                    crate::xml_deser::deser_structure_crate_model_load_balancer(&mut tag)
                    ?
                );
            }
            ,
            _ => {}
        }
    }
    Ok(out)
}

pub fn deser_list_com_amazonaws_elasticloadbalancingv2_rules(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<std::vec::Vec<crate::model::Rule>, aws_smithy_xml::decode::XmlDecodeError> {
    let mut out = std::vec::Vec::new();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("member") /* member com.amazonaws.elasticloadbalancingv2#Rules$member */ =>  {
                out.push(
                    crate::xml_deser::deser_structure_crate_model_rule(&mut tag)
                    ?
                );
            }
            ,
            _ => {}
        }
    }
    Ok(out)
}

pub fn deser_list_com_amazonaws_elasticloadbalancingv2_target_groups(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<std::vec::Vec<crate::model::TargetGroup>, aws_smithy_xml::decode::XmlDecodeError> {
    let mut out = std::vec::Vec::new();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("member") /* member com.amazonaws.elasticloadbalancingv2#TargetGroups$member */ =>  {
                out.push(
                    crate::xml_deser::deser_structure_crate_model_target_group(&mut tag)
                    ?
                );
            }
            ,
            _ => {}
        }
    }
    Ok(out)
}

pub fn deser_list_com_amazonaws_elasticloadbalancingv2_limits(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<std::vec::Vec<crate::model::Limit>, aws_smithy_xml::decode::XmlDecodeError> {
    let mut out = std::vec::Vec::new();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("member") /* member com.amazonaws.elasticloadbalancingv2#Limits$member */ =>  {
                out.push(
                    crate::xml_deser::deser_structure_crate_model_limit(&mut tag)
                    ?
                );
            }
            ,
            _ => {}
        }
    }
    Ok(out)
}

pub fn deser_list_com_amazonaws_elasticloadbalancingv2_load_balancer_attributes(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<
    std::vec::Vec<crate::model::LoadBalancerAttribute>,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    let mut out = std::vec::Vec::new();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("member") /* member com.amazonaws.elasticloadbalancingv2#LoadBalancerAttributes$member */ =>  {
                out.push(
                    crate::xml_deser::deser_structure_crate_model_load_balancer_attribute(&mut tag)
                    ?
                );
            }
            ,
            _ => {}
        }
    }
    Ok(out)
}

pub fn deser_list_com_amazonaws_elasticloadbalancingv2_ssl_policies(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<std::vec::Vec<crate::model::SslPolicy>, aws_smithy_xml::decode::XmlDecodeError> {
    let mut out = std::vec::Vec::new();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("member") /* member com.amazonaws.elasticloadbalancingv2#SslPolicies$member */ =>  {
                out.push(
                    crate::xml_deser::deser_structure_crate_model_ssl_policy(&mut tag)
                    ?
                );
            }
            ,
            _ => {}
        }
    }
    Ok(out)
}

pub fn deser_list_com_amazonaws_elasticloadbalancingv2_tag_descriptions(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<std::vec::Vec<crate::model::TagDescription>, aws_smithy_xml::decode::XmlDecodeError> {
    let mut out = std::vec::Vec::new();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("member") /* member com.amazonaws.elasticloadbalancingv2#TagDescriptions$member */ =>  {
                out.push(
                    crate::xml_deser::deser_structure_crate_model_tag_description(&mut tag)
                    ?
                );
            }
            ,
            _ => {}
        }
    }
    Ok(out)
}

pub fn deser_list_com_amazonaws_elasticloadbalancingv2_target_group_attributes(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<std::vec::Vec<crate::model::TargetGroupAttribute>, aws_smithy_xml::decode::XmlDecodeError>
{
    let mut out = std::vec::Vec::new();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("member") /* member com.amazonaws.elasticloadbalancingv2#TargetGroupAttributes$member */ =>  {
                out.push(
                    crate::xml_deser::deser_structure_crate_model_target_group_attribute(&mut tag)
                    ?
                );
            }
            ,
            _ => {}
        }
    }
    Ok(out)
}

pub fn deser_list_com_amazonaws_elasticloadbalancingv2_target_health_descriptions(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<
    std::vec::Vec<crate::model::TargetHealthDescription>,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    let mut out = std::vec::Vec::new();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("member") /* member com.amazonaws.elasticloadbalancingv2#TargetHealthDescriptions$member */ =>  {
                out.push(
                    crate::xml_deser::deser_structure_crate_model_target_health_description(&mut tag)
                    ?
                );
            }
            ,
            _ => {}
        }
    }
    Ok(out)
}

pub fn deser_list_com_amazonaws_elasticloadbalancingv2_security_groups(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<std::vec::Vec<std::string::String>, aws_smithy_xml::decode::XmlDecodeError> {
    let mut out = std::vec::Vec::new();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("member") /* member com.amazonaws.elasticloadbalancingv2#SecurityGroups$member */ =>  {
                out.push(
                    Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                        aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                        .into()
                    )
                    ?
                );
            }
            ,
            _ => {}
        }
    }
    Ok(out)
}

pub fn deser_list_com_amazonaws_elasticloadbalancingv2_availability_zones(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<std::vec::Vec<crate::model::AvailabilityZone>, aws_smithy_xml::decode::XmlDecodeError> {
    let mut out = std::vec::Vec::new();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("member") /* member com.amazonaws.elasticloadbalancingv2#AvailabilityZones$member */ =>  {
                out.push(
                    crate::xml_deser::deser_structure_crate_model_availability_zone(&mut tag)
                    ?
                );
            }
            ,
            _ => {}
        }
    }
    Ok(out)
}

pub fn deser_structure_crate_model_certificate(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::Certificate, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::Certificate::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("CertificateArn") /* CertificateArn com.amazonaws.elasticloadbalancingv2#Certificate$CertificateArn */ =>  {
                let var_71 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_certificate_arn(var_71);
            }
            ,
            s if s.matches("IsDefault") /* IsDefault com.amazonaws.elasticloadbalancingv2#Certificate$IsDefault */ =>  {
                let var_72 =
                    Some(
                         {
                            <bool as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (boolean: `com.amazonaws.elasticloadbalancingv2#Default`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_is_default(var_72);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_structure_crate_model_listener(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::Listener, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::Listener::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("ListenerArn") /* ListenerArn com.amazonaws.elasticloadbalancingv2#Listener$ListenerArn */ =>  {
                let var_73 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_listener_arn(var_73);
            }
            ,
            s if s.matches("LoadBalancerArn") /* LoadBalancerArn com.amazonaws.elasticloadbalancingv2#Listener$LoadBalancerArn */ =>  {
                let var_74 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_load_balancer_arn(var_74);
            }
            ,
            s if s.matches("Port") /* Port com.amazonaws.elasticloadbalancingv2#Listener$Port */ =>  {
                let var_75 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.elasticloadbalancingv2#Port`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_port(var_75);
            }
            ,
            s if s.matches("Protocol") /* Protocol com.amazonaws.elasticloadbalancingv2#Listener$Protocol */ =>  {
                let var_76 =
                    Some(
                        Result::<crate::model::ProtocolEnum, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::ProtocolEnum::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_protocol(var_76);
            }
            ,
            s if s.matches("Certificates") /* Certificates com.amazonaws.elasticloadbalancingv2#Listener$Certificates */ =>  {
                let var_77 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_certificate_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_certificates(var_77);
            }
            ,
            s if s.matches("SslPolicy") /* SslPolicy com.amazonaws.elasticloadbalancingv2#Listener$SslPolicy */ =>  {
                let var_78 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_ssl_policy(var_78);
            }
            ,
            s if s.matches("DefaultActions") /* DefaultActions com.amazonaws.elasticloadbalancingv2#Listener$DefaultActions */ =>  {
                let var_79 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_actions(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_default_actions(var_79);
            }
            ,
            s if s.matches("AlpnPolicy") /* AlpnPolicy com.amazonaws.elasticloadbalancingv2#Listener$AlpnPolicy */ =>  {
                let var_80 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_alpn_policy_name(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_alpn_policy(var_80);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_structure_crate_model_load_balancer(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::LoadBalancer, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::LoadBalancer::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("LoadBalancerArn") /* LoadBalancerArn com.amazonaws.elasticloadbalancingv2#LoadBalancer$LoadBalancerArn */ =>  {
                let var_81 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_load_balancer_arn(var_81);
            }
            ,
            s if s.matches("DNSName") /* DNSName com.amazonaws.elasticloadbalancingv2#LoadBalancer$DNSName */ =>  {
                let var_82 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_dns_name(var_82);
            }
            ,
            s if s.matches("CanonicalHostedZoneId") /* CanonicalHostedZoneId com.amazonaws.elasticloadbalancingv2#LoadBalancer$CanonicalHostedZoneId */ =>  {
                let var_83 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_canonical_hosted_zone_id(var_83);
            }
            ,
            s if s.matches("CreatedTime") /* CreatedTime com.amazonaws.elasticloadbalancingv2#LoadBalancer$CreatedTime */ =>  {
                let var_84 =
                    Some(
                        aws_smithy_types::DateTime::from_str(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            , aws_smithy_types::date_time::Format::DateTime
                        )
                        .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (timestamp: `com.amazonaws.elasticloadbalancingv2#CreatedTime`)"))
                        ?
                    )
                ;
                builder = builder.set_created_time(var_84);
            }
            ,
            s if s.matches("LoadBalancerName") /* LoadBalancerName com.amazonaws.elasticloadbalancingv2#LoadBalancer$LoadBalancerName */ =>  {
                let var_85 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_load_balancer_name(var_85);
            }
            ,
            s if s.matches("Scheme") /* Scheme com.amazonaws.elasticloadbalancingv2#LoadBalancer$Scheme */ =>  {
                let var_86 =
                    Some(
                        Result::<crate::model::LoadBalancerSchemeEnum, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::LoadBalancerSchemeEnum::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_scheme(var_86);
            }
            ,
            s if s.matches("VpcId") /* VpcId com.amazonaws.elasticloadbalancingv2#LoadBalancer$VpcId */ =>  {
                let var_87 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_vpc_id(var_87);
            }
            ,
            s if s.matches("State") /* State com.amazonaws.elasticloadbalancingv2#LoadBalancer$State */ =>  {
                let var_88 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_load_balancer_state(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_state(var_88);
            }
            ,
            s if s.matches("Type") /* Type com.amazonaws.elasticloadbalancingv2#LoadBalancer$Type */ =>  {
                let var_89 =
                    Some(
                        Result::<crate::model::LoadBalancerTypeEnum, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::LoadBalancerTypeEnum::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_type(var_89);
            }
            ,
            s if s.matches("AvailabilityZones") /* AvailabilityZones com.amazonaws.elasticloadbalancingv2#LoadBalancer$AvailabilityZones */ =>  {
                let var_90 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_availability_zones(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_availability_zones(var_90);
            }
            ,
            s if s.matches("SecurityGroups") /* SecurityGroups com.amazonaws.elasticloadbalancingv2#LoadBalancer$SecurityGroups */ =>  {
                let var_91 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_security_groups(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_security_groups(var_91);
            }
            ,
            s if s.matches("IpAddressType") /* IpAddressType com.amazonaws.elasticloadbalancingv2#LoadBalancer$IpAddressType */ =>  {
                let var_92 =
                    Some(
                        Result::<crate::model::IpAddressType, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::IpAddressType::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_ip_address_type(var_92);
            }
            ,
            s if s.matches("CustomerOwnedIpv4Pool") /* CustomerOwnedIpv4Pool com.amazonaws.elasticloadbalancingv2#LoadBalancer$CustomerOwnedIpv4Pool */ =>  {
                let var_93 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_customer_owned_ipv4_pool(var_93);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_structure_crate_model_rule(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::Rule, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::Rule::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("RuleArn") /* RuleArn com.amazonaws.elasticloadbalancingv2#Rule$RuleArn */ =>  {
                let var_94 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_rule_arn(var_94);
            }
            ,
            s if s.matches("Priority") /* Priority com.amazonaws.elasticloadbalancingv2#Rule$Priority */ =>  {
                let var_95 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_priority(var_95);
            }
            ,
            s if s.matches("Conditions") /* Conditions com.amazonaws.elasticloadbalancingv2#Rule$Conditions */ =>  {
                let var_96 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_rule_condition_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_conditions(var_96);
            }
            ,
            s if s.matches("Actions") /* Actions com.amazonaws.elasticloadbalancingv2#Rule$Actions */ =>  {
                let var_97 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_actions(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_actions(var_97);
            }
            ,
            s if s.matches("IsDefault") /* IsDefault com.amazonaws.elasticloadbalancingv2#Rule$IsDefault */ =>  {
                let var_98 =
                    Some(
                         {
                            <bool as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (boolean: `com.amazonaws.elasticloadbalancingv2#IsDefault`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_is_default(var_98);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_structure_crate_model_target_group(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::TargetGroup, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::TargetGroup::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("TargetGroupArn") /* TargetGroupArn com.amazonaws.elasticloadbalancingv2#TargetGroup$TargetGroupArn */ =>  {
                let var_99 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_target_group_arn(var_99);
            }
            ,
            s if s.matches("TargetGroupName") /* TargetGroupName com.amazonaws.elasticloadbalancingv2#TargetGroup$TargetGroupName */ =>  {
                let var_100 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_target_group_name(var_100);
            }
            ,
            s if s.matches("Protocol") /* Protocol com.amazonaws.elasticloadbalancingv2#TargetGroup$Protocol */ =>  {
                let var_101 =
                    Some(
                        Result::<crate::model::ProtocolEnum, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::ProtocolEnum::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_protocol(var_101);
            }
            ,
            s if s.matches("Port") /* Port com.amazonaws.elasticloadbalancingv2#TargetGroup$Port */ =>  {
                let var_102 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.elasticloadbalancingv2#Port`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_port(var_102);
            }
            ,
            s if s.matches("VpcId") /* VpcId com.amazonaws.elasticloadbalancingv2#TargetGroup$VpcId */ =>  {
                let var_103 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_vpc_id(var_103);
            }
            ,
            s if s.matches("HealthCheckProtocol") /* HealthCheckProtocol com.amazonaws.elasticloadbalancingv2#TargetGroup$HealthCheckProtocol */ =>  {
                let var_104 =
                    Some(
                        Result::<crate::model::ProtocolEnum, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::ProtocolEnum::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_health_check_protocol(var_104);
            }
            ,
            s if s.matches("HealthCheckPort") /* HealthCheckPort com.amazonaws.elasticloadbalancingv2#TargetGroup$HealthCheckPort */ =>  {
                let var_105 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_health_check_port(var_105);
            }
            ,
            s if s.matches("HealthCheckEnabled") /* HealthCheckEnabled com.amazonaws.elasticloadbalancingv2#TargetGroup$HealthCheckEnabled */ =>  {
                let var_106 =
                    Some(
                         {
                            <bool as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (boolean: `com.amazonaws.elasticloadbalancingv2#HealthCheckEnabled`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_health_check_enabled(var_106);
            }
            ,
            s if s.matches("HealthCheckIntervalSeconds") /* HealthCheckIntervalSeconds com.amazonaws.elasticloadbalancingv2#TargetGroup$HealthCheckIntervalSeconds */ =>  {
                let var_107 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.elasticloadbalancingv2#HealthCheckIntervalSeconds`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_health_check_interval_seconds(var_107);
            }
            ,
            s if s.matches("HealthCheckTimeoutSeconds") /* HealthCheckTimeoutSeconds com.amazonaws.elasticloadbalancingv2#TargetGroup$HealthCheckTimeoutSeconds */ =>  {
                let var_108 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.elasticloadbalancingv2#HealthCheckTimeoutSeconds`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_health_check_timeout_seconds(var_108);
            }
            ,
            s if s.matches("HealthyThresholdCount") /* HealthyThresholdCount com.amazonaws.elasticloadbalancingv2#TargetGroup$HealthyThresholdCount */ =>  {
                let var_109 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.elasticloadbalancingv2#HealthCheckThresholdCount`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_healthy_threshold_count(var_109);
            }
            ,
            s if s.matches("UnhealthyThresholdCount") /* UnhealthyThresholdCount com.amazonaws.elasticloadbalancingv2#TargetGroup$UnhealthyThresholdCount */ =>  {
                let var_110 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.elasticloadbalancingv2#HealthCheckThresholdCount`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_unhealthy_threshold_count(var_110);
            }
            ,
            s if s.matches("HealthCheckPath") /* HealthCheckPath com.amazonaws.elasticloadbalancingv2#TargetGroup$HealthCheckPath */ =>  {
                let var_111 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_health_check_path(var_111);
            }
            ,
            s if s.matches("Matcher") /* Matcher com.amazonaws.elasticloadbalancingv2#TargetGroup$Matcher */ =>  {
                let var_112 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_matcher(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_matcher(var_112);
            }
            ,
            s if s.matches("LoadBalancerArns") /* LoadBalancerArns com.amazonaws.elasticloadbalancingv2#TargetGroup$LoadBalancerArns */ =>  {
                let var_113 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_load_balancer_arns(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_load_balancer_arns(var_113);
            }
            ,
            s if s.matches("TargetType") /* TargetType com.amazonaws.elasticloadbalancingv2#TargetGroup$TargetType */ =>  {
                let var_114 =
                    Some(
                        Result::<crate::model::TargetTypeEnum, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::TargetTypeEnum::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_target_type(var_114);
            }
            ,
            s if s.matches("ProtocolVersion") /* ProtocolVersion com.amazonaws.elasticloadbalancingv2#TargetGroup$ProtocolVersion */ =>  {
                let var_115 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_protocol_version(var_115);
            }
            ,
            s if s.matches("IpAddressType") /* IpAddressType com.amazonaws.elasticloadbalancingv2#TargetGroup$IpAddressType */ =>  {
                let var_116 =
                    Some(
                        Result::<crate::model::TargetGroupIpAddressTypeEnum, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::TargetGroupIpAddressTypeEnum::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_ip_address_type(var_116);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_structure_crate_model_limit(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::Limit, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::Limit::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Name") /* Name com.amazonaws.elasticloadbalancingv2#Limit$Name */ =>  {
                let var_117 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_name(var_117);
            }
            ,
            s if s.matches("Max") /* Max com.amazonaws.elasticloadbalancingv2#Limit$Max */ =>  {
                let var_118 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_max(var_118);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_structure_crate_model_load_balancer_attribute(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::LoadBalancerAttribute, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::LoadBalancerAttribute::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Key") /* Key com.amazonaws.elasticloadbalancingv2#LoadBalancerAttribute$Key */ =>  {
                let var_119 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_key(var_119);
            }
            ,
            s if s.matches("Value") /* Value com.amazonaws.elasticloadbalancingv2#LoadBalancerAttribute$Value */ =>  {
                let var_120 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_value(var_120);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_structure_crate_model_ssl_policy(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::SslPolicy, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::SslPolicy::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("SslProtocols") /* SslProtocols com.amazonaws.elasticloadbalancingv2#SslPolicy$SslProtocols */ =>  {
                let var_121 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_ssl_protocols(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_ssl_protocols(var_121);
            }
            ,
            s if s.matches("Ciphers") /* Ciphers com.amazonaws.elasticloadbalancingv2#SslPolicy$Ciphers */ =>  {
                let var_122 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_ciphers(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_ciphers(var_122);
            }
            ,
            s if s.matches("Name") /* Name com.amazonaws.elasticloadbalancingv2#SslPolicy$Name */ =>  {
                let var_123 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_name(var_123);
            }
            ,
            s if s.matches("SupportedLoadBalancerTypes") /* SupportedLoadBalancerTypes com.amazonaws.elasticloadbalancingv2#SslPolicy$SupportedLoadBalancerTypes */ =>  {
                let var_124 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_list_of_string(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_supported_load_balancer_types(var_124);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_structure_crate_model_tag_description(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::TagDescription, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::TagDescription::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("ResourceArn") /* ResourceArn com.amazonaws.elasticloadbalancingv2#TagDescription$ResourceArn */ =>  {
                let var_125 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_resource_arn(var_125);
            }
            ,
            s if s.matches("Tags") /* Tags com.amazonaws.elasticloadbalancingv2#TagDescription$Tags */ =>  {
                let var_126 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_tag_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_tags(var_126);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_structure_crate_model_target_group_attribute(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::TargetGroupAttribute, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::TargetGroupAttribute::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Key") /* Key com.amazonaws.elasticloadbalancingv2#TargetGroupAttribute$Key */ =>  {
                let var_127 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_key(var_127);
            }
            ,
            s if s.matches("Value") /* Value com.amazonaws.elasticloadbalancingv2#TargetGroupAttribute$Value */ =>  {
                let var_128 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_value(var_128);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_structure_crate_model_target_health_description(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::TargetHealthDescription, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::TargetHealthDescription::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Target") /* Target com.amazonaws.elasticloadbalancingv2#TargetHealthDescription$Target */ =>  {
                let var_129 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_target_description(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_target(var_129);
            }
            ,
            s if s.matches("HealthCheckPort") /* HealthCheckPort com.amazonaws.elasticloadbalancingv2#TargetHealthDescription$HealthCheckPort */ =>  {
                let var_130 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_health_check_port(var_130);
            }
            ,
            s if s.matches("TargetHealth") /* TargetHealth com.amazonaws.elasticloadbalancingv2#TargetHealthDescription$TargetHealth */ =>  {
                let var_131 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_target_health(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_target_health(var_131);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_structure_crate_model_availability_zone(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::AvailabilityZone, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::AvailabilityZone::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("ZoneName") /* ZoneName com.amazonaws.elasticloadbalancingv2#AvailabilityZone$ZoneName */ =>  {
                let var_132 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_zone_name(var_132);
            }
            ,
            s if s.matches("SubnetId") /* SubnetId com.amazonaws.elasticloadbalancingv2#AvailabilityZone$SubnetId */ =>  {
                let var_133 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_subnet_id(var_133);
            }
            ,
            s if s.matches("OutpostId") /* OutpostId com.amazonaws.elasticloadbalancingv2#AvailabilityZone$OutpostId */ =>  {
                let var_134 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_outpost_id(var_134);
            }
            ,
            s if s.matches("LoadBalancerAddresses") /* LoadBalancerAddresses com.amazonaws.elasticloadbalancingv2#AvailabilityZone$LoadBalancerAddresses */ =>  {
                let var_135 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_load_balancer_addresses(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_load_balancer_addresses(var_135);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_list_com_amazonaws_elasticloadbalancingv2_actions(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<std::vec::Vec<crate::model::Action>, aws_smithy_xml::decode::XmlDecodeError> {
    let mut out = std::vec::Vec::new();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("member") /* member com.amazonaws.elasticloadbalancingv2#Actions$member */ =>  {
                out.push(
                    crate::xml_deser::deser_structure_crate_model_action(&mut tag)
                    ?
                );
            }
            ,
            _ => {}
        }
    }
    Ok(out)
}

pub fn deser_list_com_amazonaws_elasticloadbalancingv2_alpn_policy_name(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<std::vec::Vec<std::string::String>, aws_smithy_xml::decode::XmlDecodeError> {
    let mut out = std::vec::Vec::new();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("member") /* member com.amazonaws.elasticloadbalancingv2#AlpnPolicyName$member */ =>  {
                out.push(
                    Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                        aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                        .into()
                    )
                    ?
                );
            }
            ,
            _ => {}
        }
    }
    Ok(out)
}

pub fn deser_structure_crate_model_load_balancer_state(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::LoadBalancerState, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::LoadBalancerState::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Code") /* Code com.amazonaws.elasticloadbalancingv2#LoadBalancerState$Code */ =>  {
                let var_136 =
                    Some(
                        Result::<crate::model::LoadBalancerStateEnum, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::LoadBalancerStateEnum::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_code(var_136);
            }
            ,
            s if s.matches("Reason") /* Reason com.amazonaws.elasticloadbalancingv2#LoadBalancerState$Reason */ =>  {
                let var_137 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_reason(var_137);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_list_com_amazonaws_elasticloadbalancingv2_rule_condition_list(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<std::vec::Vec<crate::model::RuleCondition>, aws_smithy_xml::decode::XmlDecodeError> {
    let mut out = std::vec::Vec::new();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("member") /* member com.amazonaws.elasticloadbalancingv2#RuleConditionList$member */ =>  {
                out.push(
                    crate::xml_deser::deser_structure_crate_model_rule_condition(&mut tag)
                    ?
                );
            }
            ,
            _ => {}
        }
    }
    Ok(out)
}

pub fn deser_structure_crate_model_matcher(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::Matcher, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::Matcher::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("HttpCode") /* HttpCode com.amazonaws.elasticloadbalancingv2#Matcher$HttpCode */ =>  {
                let var_138 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_http_code(var_138);
            }
            ,
            s if s.matches("GrpcCode") /* GrpcCode com.amazonaws.elasticloadbalancingv2#Matcher$GrpcCode */ =>  {
                let var_139 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_grpc_code(var_139);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_list_com_amazonaws_elasticloadbalancingv2_load_balancer_arns(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<std::vec::Vec<std::string::String>, aws_smithy_xml::decode::XmlDecodeError> {
    let mut out = std::vec::Vec::new();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("member") /* member com.amazonaws.elasticloadbalancingv2#LoadBalancerArns$member */ =>  {
                out.push(
                    Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                        aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                        .into()
                    )
                    ?
                );
            }
            ,
            _ => {}
        }
    }
    Ok(out)
}

pub fn deser_list_com_amazonaws_elasticloadbalancingv2_ssl_protocols(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<std::vec::Vec<std::string::String>, aws_smithy_xml::decode::XmlDecodeError> {
    let mut out = std::vec::Vec::new();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("member") /* member com.amazonaws.elasticloadbalancingv2#SslProtocols$member */ =>  {
                out.push(
                    Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                        aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                        .into()
                    )
                    ?
                );
            }
            ,
            _ => {}
        }
    }
    Ok(out)
}

pub fn deser_list_com_amazonaws_elasticloadbalancingv2_ciphers(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<std::vec::Vec<crate::model::Cipher>, aws_smithy_xml::decode::XmlDecodeError> {
    let mut out = std::vec::Vec::new();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("member") /* member com.amazonaws.elasticloadbalancingv2#Ciphers$member */ =>  {
                out.push(
                    crate::xml_deser::deser_structure_crate_model_cipher(&mut tag)
                    ?
                );
            }
            ,
            _ => {}
        }
    }
    Ok(out)
}

pub fn deser_list_com_amazonaws_elasticloadbalancingv2_list_of_string(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<std::vec::Vec<std::string::String>, aws_smithy_xml::decode::XmlDecodeError> {
    let mut out = std::vec::Vec::new();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("member") /* member com.amazonaws.elasticloadbalancingv2#ListOfString$member */ =>  {
                out.push(
                    Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                        aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                        .into()
                    )
                    ?
                );
            }
            ,
            _ => {}
        }
    }
    Ok(out)
}

pub fn deser_list_com_amazonaws_elasticloadbalancingv2_tag_list(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<std::vec::Vec<crate::model::Tag>, aws_smithy_xml::decode::XmlDecodeError> {
    let mut out = std::vec::Vec::new();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("member") /* member com.amazonaws.elasticloadbalancingv2#TagList$member */ =>  {
                out.push(
                    crate::xml_deser::deser_structure_crate_model_tag(&mut tag)
                    ?
                );
            }
            ,
            _ => {}
        }
    }
    Ok(out)
}

pub fn deser_structure_crate_model_target_description(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::TargetDescription, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::TargetDescription::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Id") /* Id com.amazonaws.elasticloadbalancingv2#TargetDescription$Id */ =>  {
                let var_140 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_id(var_140);
            }
            ,
            s if s.matches("Port") /* Port com.amazonaws.elasticloadbalancingv2#TargetDescription$Port */ =>  {
                let var_141 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.elasticloadbalancingv2#Port`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_port(var_141);
            }
            ,
            s if s.matches("AvailabilityZone") /* AvailabilityZone com.amazonaws.elasticloadbalancingv2#TargetDescription$AvailabilityZone */ =>  {
                let var_142 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_availability_zone(var_142);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_structure_crate_model_target_health(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::TargetHealth, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::TargetHealth::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("State") /* State com.amazonaws.elasticloadbalancingv2#TargetHealth$State */ =>  {
                let var_143 =
                    Some(
                        Result::<crate::model::TargetHealthStateEnum, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::TargetHealthStateEnum::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_state(var_143);
            }
            ,
            s if s.matches("Reason") /* Reason com.amazonaws.elasticloadbalancingv2#TargetHealth$Reason */ =>  {
                let var_144 =
                    Some(
                        Result::<crate::model::TargetHealthReasonEnum, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::TargetHealthReasonEnum::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_reason(var_144);
            }
            ,
            s if s.matches("Description") /* Description com.amazonaws.elasticloadbalancingv2#TargetHealth$Description */ =>  {
                let var_145 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_description(var_145);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_list_com_amazonaws_elasticloadbalancingv2_load_balancer_addresses(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<std::vec::Vec<crate::model::LoadBalancerAddress>, aws_smithy_xml::decode::XmlDecodeError>
{
    let mut out = std::vec::Vec::new();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("member") /* member com.amazonaws.elasticloadbalancingv2#LoadBalancerAddresses$member */ =>  {
                out.push(
                    crate::xml_deser::deser_structure_crate_model_load_balancer_address(&mut tag)
                    ?
                );
            }
            ,
            _ => {}
        }
    }
    Ok(out)
}

pub fn deser_structure_crate_model_action(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::Action, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::Action::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Type") /* Type com.amazonaws.elasticloadbalancingv2#Action$Type */ =>  {
                let var_146 =
                    Some(
                        Result::<crate::model::ActionTypeEnum, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::ActionTypeEnum::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_type(var_146);
            }
            ,
            s if s.matches("TargetGroupArn") /* TargetGroupArn com.amazonaws.elasticloadbalancingv2#Action$TargetGroupArn */ =>  {
                let var_147 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_target_group_arn(var_147);
            }
            ,
            s if s.matches("AuthenticateOidcConfig") /* AuthenticateOidcConfig com.amazonaws.elasticloadbalancingv2#Action$AuthenticateOidcConfig */ =>  {
                let var_148 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_authenticate_oidc_action_config(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_authenticate_oidc_config(var_148);
            }
            ,
            s if s.matches("AuthenticateCognitoConfig") /* AuthenticateCognitoConfig com.amazonaws.elasticloadbalancingv2#Action$AuthenticateCognitoConfig */ =>  {
                let var_149 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_authenticate_cognito_action_config(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_authenticate_cognito_config(var_149);
            }
            ,
            s if s.matches("Order") /* Order com.amazonaws.elasticloadbalancingv2#Action$Order */ =>  {
                let var_150 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.elasticloadbalancingv2#ActionOrder`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_order(var_150);
            }
            ,
            s if s.matches("RedirectConfig") /* RedirectConfig com.amazonaws.elasticloadbalancingv2#Action$RedirectConfig */ =>  {
                let var_151 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_redirect_action_config(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_redirect_config(var_151);
            }
            ,
            s if s.matches("FixedResponseConfig") /* FixedResponseConfig com.amazonaws.elasticloadbalancingv2#Action$FixedResponseConfig */ =>  {
                let var_152 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_fixed_response_action_config(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_fixed_response_config(var_152);
            }
            ,
            s if s.matches("ForwardConfig") /* ForwardConfig com.amazonaws.elasticloadbalancingv2#Action$ForwardConfig */ =>  {
                let var_153 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_forward_action_config(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_forward_config(var_153);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_structure_crate_model_rule_condition(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::RuleCondition, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::RuleCondition::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Field") /* Field com.amazonaws.elasticloadbalancingv2#RuleCondition$Field */ =>  {
                let var_154 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_field(var_154);
            }
            ,
            s if s.matches("Values") /* Values com.amazonaws.elasticloadbalancingv2#RuleCondition$Values */ =>  {
                let var_155 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_list_of_string(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_values(var_155);
            }
            ,
            s if s.matches("HostHeaderConfig") /* HostHeaderConfig com.amazonaws.elasticloadbalancingv2#RuleCondition$HostHeaderConfig */ =>  {
                let var_156 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_host_header_condition_config(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_host_header_config(var_156);
            }
            ,
            s if s.matches("PathPatternConfig") /* PathPatternConfig com.amazonaws.elasticloadbalancingv2#RuleCondition$PathPatternConfig */ =>  {
                let var_157 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_path_pattern_condition_config(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_path_pattern_config(var_157);
            }
            ,
            s if s.matches("HttpHeaderConfig") /* HttpHeaderConfig com.amazonaws.elasticloadbalancingv2#RuleCondition$HttpHeaderConfig */ =>  {
                let var_158 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_http_header_condition_config(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_http_header_config(var_158);
            }
            ,
            s if s.matches("QueryStringConfig") /* QueryStringConfig com.amazonaws.elasticloadbalancingv2#RuleCondition$QueryStringConfig */ =>  {
                let var_159 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_query_string_condition_config(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_query_string_config(var_159);
            }
            ,
            s if s.matches("HttpRequestMethodConfig") /* HttpRequestMethodConfig com.amazonaws.elasticloadbalancingv2#RuleCondition$HttpRequestMethodConfig */ =>  {
                let var_160 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_http_request_method_condition_config(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_http_request_method_config(var_160);
            }
            ,
            s if s.matches("SourceIpConfig") /* SourceIpConfig com.amazonaws.elasticloadbalancingv2#RuleCondition$SourceIpConfig */ =>  {
                let var_161 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_source_ip_condition_config(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_source_ip_config(var_161);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_structure_crate_model_cipher(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::Cipher, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::Cipher::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Name") /* Name com.amazonaws.elasticloadbalancingv2#Cipher$Name */ =>  {
                let var_162 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_name(var_162);
            }
            ,
            s if s.matches("Priority") /* Priority com.amazonaws.elasticloadbalancingv2#Cipher$Priority */ =>  {
                let var_163 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.elasticloadbalancingv2#CipherPriority`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_priority(var_163);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_structure_crate_model_tag(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::Tag, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::Tag::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Key") /* Key com.amazonaws.elasticloadbalancingv2#Tag$Key */ =>  {
                let var_164 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_key(var_164);
            }
            ,
            s if s.matches("Value") /* Value com.amazonaws.elasticloadbalancingv2#Tag$Value */ =>  {
                let var_165 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_value(var_165);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_structure_crate_model_load_balancer_address(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::LoadBalancerAddress, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::LoadBalancerAddress::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("IpAddress") /* IpAddress com.amazonaws.elasticloadbalancingv2#LoadBalancerAddress$IpAddress */ =>  {
                let var_166 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_ip_address(var_166);
            }
            ,
            s if s.matches("AllocationId") /* AllocationId com.amazonaws.elasticloadbalancingv2#LoadBalancerAddress$AllocationId */ =>  {
                let var_167 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_allocation_id(var_167);
            }
            ,
            s if s.matches("PrivateIPv4Address") /* PrivateIPv4Address com.amazonaws.elasticloadbalancingv2#LoadBalancerAddress$PrivateIPv4Address */ =>  {
                let var_168 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_private_i_pv4_address(var_168);
            }
            ,
            s if s.matches("IPv6Address") /* IPv6Address com.amazonaws.elasticloadbalancingv2#LoadBalancerAddress$IPv6Address */ =>  {
                let var_169 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_i_pv6_address(var_169);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_structure_crate_model_authenticate_oidc_action_config(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::AuthenticateOidcActionConfig, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::AuthenticateOidcActionConfig::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Issuer") /* Issuer com.amazonaws.elasticloadbalancingv2#AuthenticateOidcActionConfig$Issuer */ =>  {
                let var_170 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_issuer(var_170);
            }
            ,
            s if s.matches("AuthorizationEndpoint") /* AuthorizationEndpoint com.amazonaws.elasticloadbalancingv2#AuthenticateOidcActionConfig$AuthorizationEndpoint */ =>  {
                let var_171 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_authorization_endpoint(var_171);
            }
            ,
            s if s.matches("TokenEndpoint") /* TokenEndpoint com.amazonaws.elasticloadbalancingv2#AuthenticateOidcActionConfig$TokenEndpoint */ =>  {
                let var_172 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_token_endpoint(var_172);
            }
            ,
            s if s.matches("UserInfoEndpoint") /* UserInfoEndpoint com.amazonaws.elasticloadbalancingv2#AuthenticateOidcActionConfig$UserInfoEndpoint */ =>  {
                let var_173 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_user_info_endpoint(var_173);
            }
            ,
            s if s.matches("ClientId") /* ClientId com.amazonaws.elasticloadbalancingv2#AuthenticateOidcActionConfig$ClientId */ =>  {
                let var_174 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_client_id(var_174);
            }
            ,
            s if s.matches("ClientSecret") /* ClientSecret com.amazonaws.elasticloadbalancingv2#AuthenticateOidcActionConfig$ClientSecret */ =>  {
                let var_175 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_client_secret(var_175);
            }
            ,
            s if s.matches("SessionCookieName") /* SessionCookieName com.amazonaws.elasticloadbalancingv2#AuthenticateOidcActionConfig$SessionCookieName */ =>  {
                let var_176 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_session_cookie_name(var_176);
            }
            ,
            s if s.matches("Scope") /* Scope com.amazonaws.elasticloadbalancingv2#AuthenticateOidcActionConfig$Scope */ =>  {
                let var_177 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_scope(var_177);
            }
            ,
            s if s.matches("SessionTimeout") /* SessionTimeout com.amazonaws.elasticloadbalancingv2#AuthenticateOidcActionConfig$SessionTimeout */ =>  {
                let var_178 =
                    Some(
                         {
                            <i64 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (long: `com.amazonaws.elasticloadbalancingv2#AuthenticateOidcActionSessionTimeout`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_session_timeout(var_178);
            }
            ,
            s if s.matches("AuthenticationRequestExtraParams") /* AuthenticationRequestExtraParams com.amazonaws.elasticloadbalancingv2#AuthenticateOidcActionConfig$AuthenticationRequestExtraParams */ =>  {
                let var_179 =
                    Some(
                        crate::xml_deser::deser_map_com_amazonaws_elasticloadbalancingv2_authenticate_oidc_action_authentication_request_extra_params(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_authentication_request_extra_params(var_179);
            }
            ,
            s if s.matches("OnUnauthenticatedRequest") /* OnUnauthenticatedRequest com.amazonaws.elasticloadbalancingv2#AuthenticateOidcActionConfig$OnUnauthenticatedRequest */ =>  {
                let var_180 =
                    Some(
                        Result::<crate::model::AuthenticateOidcActionConditionalBehaviorEnum, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::AuthenticateOidcActionConditionalBehaviorEnum::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_on_unauthenticated_request(var_180);
            }
            ,
            s if s.matches("UseExistingClientSecret") /* UseExistingClientSecret com.amazonaws.elasticloadbalancingv2#AuthenticateOidcActionConfig$UseExistingClientSecret */ =>  {
                let var_181 =
                    Some(
                         {
                            <bool as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (boolean: `com.amazonaws.elasticloadbalancingv2#AuthenticateOidcActionUseExistingClientSecret`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_use_existing_client_secret(var_181);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_structure_crate_model_authenticate_cognito_action_config(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::AuthenticateCognitoActionConfig, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::AuthenticateCognitoActionConfig::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("UserPoolArn") /* UserPoolArn com.amazonaws.elasticloadbalancingv2#AuthenticateCognitoActionConfig$UserPoolArn */ =>  {
                let var_182 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_user_pool_arn(var_182);
            }
            ,
            s if s.matches("UserPoolClientId") /* UserPoolClientId com.amazonaws.elasticloadbalancingv2#AuthenticateCognitoActionConfig$UserPoolClientId */ =>  {
                let var_183 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_user_pool_client_id(var_183);
            }
            ,
            s if s.matches("UserPoolDomain") /* UserPoolDomain com.amazonaws.elasticloadbalancingv2#AuthenticateCognitoActionConfig$UserPoolDomain */ =>  {
                let var_184 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_user_pool_domain(var_184);
            }
            ,
            s if s.matches("SessionCookieName") /* SessionCookieName com.amazonaws.elasticloadbalancingv2#AuthenticateCognitoActionConfig$SessionCookieName */ =>  {
                let var_185 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_session_cookie_name(var_185);
            }
            ,
            s if s.matches("Scope") /* Scope com.amazonaws.elasticloadbalancingv2#AuthenticateCognitoActionConfig$Scope */ =>  {
                let var_186 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_scope(var_186);
            }
            ,
            s if s.matches("SessionTimeout") /* SessionTimeout com.amazonaws.elasticloadbalancingv2#AuthenticateCognitoActionConfig$SessionTimeout */ =>  {
                let var_187 =
                    Some(
                         {
                            <i64 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (long: `com.amazonaws.elasticloadbalancingv2#AuthenticateCognitoActionSessionTimeout`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_session_timeout(var_187);
            }
            ,
            s if s.matches("AuthenticationRequestExtraParams") /* AuthenticationRequestExtraParams com.amazonaws.elasticloadbalancingv2#AuthenticateCognitoActionConfig$AuthenticationRequestExtraParams */ =>  {
                let var_188 =
                    Some(
                        crate::xml_deser::deser_map_com_amazonaws_elasticloadbalancingv2_authenticate_cognito_action_authentication_request_extra_params(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_authentication_request_extra_params(var_188);
            }
            ,
            s if s.matches("OnUnauthenticatedRequest") /* OnUnauthenticatedRequest com.amazonaws.elasticloadbalancingv2#AuthenticateCognitoActionConfig$OnUnauthenticatedRequest */ =>  {
                let var_189 =
                    Some(
                        Result::<crate::model::AuthenticateCognitoActionConditionalBehaviorEnum, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::AuthenticateCognitoActionConditionalBehaviorEnum::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_on_unauthenticated_request(var_189);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_structure_crate_model_redirect_action_config(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::RedirectActionConfig, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::RedirectActionConfig::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Protocol") /* Protocol com.amazonaws.elasticloadbalancingv2#RedirectActionConfig$Protocol */ =>  {
                let var_190 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_protocol(var_190);
            }
            ,
            s if s.matches("Port") /* Port com.amazonaws.elasticloadbalancingv2#RedirectActionConfig$Port */ =>  {
                let var_191 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_port(var_191);
            }
            ,
            s if s.matches("Host") /* Host com.amazonaws.elasticloadbalancingv2#RedirectActionConfig$Host */ =>  {
                let var_192 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_host(var_192);
            }
            ,
            s if s.matches("Path") /* Path com.amazonaws.elasticloadbalancingv2#RedirectActionConfig$Path */ =>  {
                let var_193 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_path(var_193);
            }
            ,
            s if s.matches("Query") /* Query com.amazonaws.elasticloadbalancingv2#RedirectActionConfig$Query */ =>  {
                let var_194 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_query(var_194);
            }
            ,
            s if s.matches("StatusCode") /* StatusCode com.amazonaws.elasticloadbalancingv2#RedirectActionConfig$StatusCode */ =>  {
                let var_195 =
                    Some(
                        Result::<crate::model::RedirectActionStatusCodeEnum, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::RedirectActionStatusCodeEnum::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_status_code(var_195);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_structure_crate_model_fixed_response_action_config(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::FixedResponseActionConfig, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::FixedResponseActionConfig::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("MessageBody") /* MessageBody com.amazonaws.elasticloadbalancingv2#FixedResponseActionConfig$MessageBody */ =>  {
                let var_196 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_message_body(var_196);
            }
            ,
            s if s.matches("StatusCode") /* StatusCode com.amazonaws.elasticloadbalancingv2#FixedResponseActionConfig$StatusCode */ =>  {
                let var_197 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_status_code(var_197);
            }
            ,
            s if s.matches("ContentType") /* ContentType com.amazonaws.elasticloadbalancingv2#FixedResponseActionConfig$ContentType */ =>  {
                let var_198 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_content_type(var_198);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_structure_crate_model_forward_action_config(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::ForwardActionConfig, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::ForwardActionConfig::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("TargetGroups") /* TargetGroups com.amazonaws.elasticloadbalancingv2#ForwardActionConfig$TargetGroups */ =>  {
                let var_199 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_target_group_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_target_groups(var_199);
            }
            ,
            s if s.matches("TargetGroupStickinessConfig") /* TargetGroupStickinessConfig com.amazonaws.elasticloadbalancingv2#ForwardActionConfig$TargetGroupStickinessConfig */ =>  {
                let var_200 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_target_group_stickiness_config(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_target_group_stickiness_config(var_200);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_structure_crate_model_host_header_condition_config(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::HostHeaderConditionConfig, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::HostHeaderConditionConfig::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Values") /* Values com.amazonaws.elasticloadbalancingv2#HostHeaderConditionConfig$Values */ =>  {
                let var_201 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_list_of_string(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_values(var_201);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_structure_crate_model_path_pattern_condition_config(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::PathPatternConditionConfig, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::PathPatternConditionConfig::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Values") /* Values com.amazonaws.elasticloadbalancingv2#PathPatternConditionConfig$Values */ =>  {
                let var_202 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_list_of_string(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_values(var_202);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_structure_crate_model_http_header_condition_config(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::HttpHeaderConditionConfig, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::HttpHeaderConditionConfig::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("HttpHeaderName") /* HttpHeaderName com.amazonaws.elasticloadbalancingv2#HttpHeaderConditionConfig$HttpHeaderName */ =>  {
                let var_203 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_http_header_name(var_203);
            }
            ,
            s if s.matches("Values") /* Values com.amazonaws.elasticloadbalancingv2#HttpHeaderConditionConfig$Values */ =>  {
                let var_204 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_list_of_string(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_values(var_204);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_structure_crate_model_query_string_condition_config(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::QueryStringConditionConfig, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::QueryStringConditionConfig::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Values") /* Values com.amazonaws.elasticloadbalancingv2#QueryStringConditionConfig$Values */ =>  {
                let var_205 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_query_string_key_value_pair_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_values(var_205);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_structure_crate_model_http_request_method_condition_config(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::HttpRequestMethodConditionConfig, aws_smithy_xml::decode::XmlDecodeError>
{
    #[allow(unused_mut)]
    let mut builder = crate::model::HttpRequestMethodConditionConfig::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Values") /* Values com.amazonaws.elasticloadbalancingv2#HttpRequestMethodConditionConfig$Values */ =>  {
                let var_206 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_list_of_string(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_values(var_206);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_structure_crate_model_source_ip_condition_config(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::SourceIpConditionConfig, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::SourceIpConditionConfig::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Values") /* Values com.amazonaws.elasticloadbalancingv2#SourceIpConditionConfig$Values */ =>  {
                let var_207 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticloadbalancingv2_list_of_string(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_values(var_207);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_map_com_amazonaws_elasticloadbalancingv2_authenticate_oidc_action_authentication_request_extra_params(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<
    std::collections::HashMap<std::string::String, std::string::String>,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    let mut out = std::collections::HashMap::new();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("entry") => {
                crate::xml_deser::deser_map_com_amazonaws_elasticloadbalancingv2_authenticate_oidc_action_authentication_request_extra_params_entry(&mut tag, &mut out)?;
            }
            _ => {}
        }
    }
    Ok(out)
}

pub fn deser_map_com_amazonaws_elasticloadbalancingv2_authenticate_cognito_action_authentication_request_extra_params(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<
    std::collections::HashMap<std::string::String, std::string::String>,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    let mut out = std::collections::HashMap::new();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("entry") => {
                crate::xml_deser::deser_map_com_amazonaws_elasticloadbalancingv2_authenticate_cognito_action_authentication_request_extra_params_entry(&mut tag, &mut out)?;
            }
            _ => {}
        }
    }
    Ok(out)
}

pub fn deser_list_com_amazonaws_elasticloadbalancingv2_target_group_list(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<std::vec::Vec<crate::model::TargetGroupTuple>, aws_smithy_xml::decode::XmlDecodeError> {
    let mut out = std::vec::Vec::new();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("member") /* member com.amazonaws.elasticloadbalancingv2#TargetGroupList$member */ =>  {
                out.push(
                    crate::xml_deser::deser_structure_crate_model_target_group_tuple(&mut tag)
                    ?
                );
            }
            ,
            _ => {}
        }
    }
    Ok(out)
}

pub fn deser_structure_crate_model_target_group_stickiness_config(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::TargetGroupStickinessConfig, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::TargetGroupStickinessConfig::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Enabled") /* Enabled com.amazonaws.elasticloadbalancingv2#TargetGroupStickinessConfig$Enabled */ =>  {
                let var_208 =
                    Some(
                         {
                            <bool as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (boolean: `com.amazonaws.elasticloadbalancingv2#TargetGroupStickinessEnabled`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_enabled(var_208);
            }
            ,
            s if s.matches("DurationSeconds") /* DurationSeconds com.amazonaws.elasticloadbalancingv2#TargetGroupStickinessConfig$DurationSeconds */ =>  {
                let var_209 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.elasticloadbalancingv2#TargetGroupStickinessDurationSeconds`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_duration_seconds(var_209);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_list_com_amazonaws_elasticloadbalancingv2_query_string_key_value_pair_list(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<
    std::vec::Vec<crate::model::QueryStringKeyValuePair>,
    aws_smithy_xml::decode::XmlDecodeError,
> {
    let mut out = std::vec::Vec::new();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("member") /* member com.amazonaws.elasticloadbalancingv2#QueryStringKeyValuePairList$member */ =>  {
                out.push(
                    crate::xml_deser::deser_structure_crate_model_query_string_key_value_pair(&mut tag)
                    ?
                );
            }
            ,
            _ => {}
        }
    }
    Ok(out)
}

pub fn deser_map_com_amazonaws_elasticloadbalancingv2_authenticate_oidc_action_authentication_request_extra_params_entry(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
    out: &mut std::collections::HashMap<std::string::String, std::string::String>,
) -> Result<(), aws_smithy_xml::decode::XmlDecodeError> {
    let mut k: Option<std::string::String> = None;
    let mut v: Option<std::string::String> = None;
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("key") /* key com.amazonaws.elasticloadbalancingv2#AuthenticateOidcActionAuthenticationRequestExtraParams$key */ =>  {
                k = Some(
                    Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                        aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                        .into()
                    )
                    ?
                )
            }
            ,
            s if s.matches("value") /* value com.amazonaws.elasticloadbalancingv2#AuthenticateOidcActionAuthenticationRequestExtraParams$value */ =>  {
                v = Some(
                    Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                        aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                        .into()
                    )
                    ?
                )
            }
            ,
            _ => {}
        }
    }
    let k =
        k.ok_or_else(|| aws_smithy_xml::decode::XmlDecodeError::custom("missing key map entry"))?;
    let v =
        v.ok_or_else(|| aws_smithy_xml::decode::XmlDecodeError::custom("missing value map entry"))?;
    out.insert(k, v);
    Ok(())
}

pub fn deser_map_com_amazonaws_elasticloadbalancingv2_authenticate_cognito_action_authentication_request_extra_params_entry(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
    out: &mut std::collections::HashMap<std::string::String, std::string::String>,
) -> Result<(), aws_smithy_xml::decode::XmlDecodeError> {
    let mut k: Option<std::string::String> = None;
    let mut v: Option<std::string::String> = None;
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("key") /* key com.amazonaws.elasticloadbalancingv2#AuthenticateCognitoActionAuthenticationRequestExtraParams$key */ =>  {
                k = Some(
                    Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                        aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                        .into()
                    )
                    ?
                )
            }
            ,
            s if s.matches("value") /* value com.amazonaws.elasticloadbalancingv2#AuthenticateCognitoActionAuthenticationRequestExtraParams$value */ =>  {
                v = Some(
                    Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                        aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                        .into()
                    )
                    ?
                )
            }
            ,
            _ => {}
        }
    }
    let k =
        k.ok_or_else(|| aws_smithy_xml::decode::XmlDecodeError::custom("missing key map entry"))?;
    let v =
        v.ok_or_else(|| aws_smithy_xml::decode::XmlDecodeError::custom("missing value map entry"))?;
    out.insert(k, v);
    Ok(())
}

pub fn deser_structure_crate_model_target_group_tuple(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::TargetGroupTuple, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::TargetGroupTuple::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("TargetGroupArn") /* TargetGroupArn com.amazonaws.elasticloadbalancingv2#TargetGroupTuple$TargetGroupArn */ =>  {
                let var_210 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_target_group_arn(var_210);
            }
            ,
            s if s.matches("Weight") /* Weight com.amazonaws.elasticloadbalancingv2#TargetGroupTuple$Weight */ =>  {
                let var_211 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.elasticloadbalancingv2#TargetGroupWeight`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_weight(var_211);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn deser_structure_crate_model_query_string_key_value_pair(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::QueryStringKeyValuePair, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::QueryStringKeyValuePair::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Key") /* Key com.amazonaws.elasticloadbalancingv2#QueryStringKeyValuePair$Key */ =>  {
                let var_212 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_key(var_212);
            }
            ,
            s if s.matches("Value") /* Value com.amazonaws.elasticloadbalancingv2#QueryStringKeyValuePair$Value */ =>  {
                let var_213 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_value(var_213);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}