aws-sdk-ec2 0.0.22-alpha

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
#[allow(clippy::unnecessary_wraps)]
pub fn parse_accept_reserved_instances_exchange_quote_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AcceptReservedInstancesExchangeQuoteOutput,
    crate::error::AcceptReservedInstancesExchangeQuoteError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AcceptReservedInstancesExchangeQuoteError::unhandled)?;
    Err(crate::error::AcceptReservedInstancesExchangeQuoteError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_accept_reserved_instances_exchange_quote_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AcceptReservedInstancesExchangeQuoteOutput,
    crate::error::AcceptReservedInstancesExchangeQuoteError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::accept_reserved_instances_exchange_quote_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_accept_reserved_instances_exchange_quote(response.body().as_ref(), output).map_err(crate::error::AcceptReservedInstancesExchangeQuoteError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_accept_transit_gateway_multicast_domain_associations_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AcceptTransitGatewayMulticastDomainAssociationsOutput,
    crate::error::AcceptTransitGatewayMulticastDomainAssociationsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AcceptTransitGatewayMulticastDomainAssociationsError::unhandled)?;
    Err(crate::error::AcceptTransitGatewayMulticastDomainAssociationsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_accept_transit_gateway_multicast_domain_associations_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AcceptTransitGatewayMulticastDomainAssociationsOutput,
    crate::error::AcceptTransitGatewayMulticastDomainAssociationsError,
> {
    Ok({
        #[allow(unused_mut)]let mut output = crate::output::accept_transit_gateway_multicast_domain_associations_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_accept_transit_gateway_multicast_domain_associations(response.body().as_ref(), output).map_err(crate::error::AcceptTransitGatewayMulticastDomainAssociationsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_accept_transit_gateway_peering_attachment_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AcceptTransitGatewayPeeringAttachmentOutput,
    crate::error::AcceptTransitGatewayPeeringAttachmentError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AcceptTransitGatewayPeeringAttachmentError::unhandled)?;
    Err(crate::error::AcceptTransitGatewayPeeringAttachmentError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_accept_transit_gateway_peering_attachment_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AcceptTransitGatewayPeeringAttachmentOutput,
    crate::error::AcceptTransitGatewayPeeringAttachmentError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::accept_transit_gateway_peering_attachment_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_accept_transit_gateway_peering_attachment(response.body().as_ref(), output).map_err(crate::error::AcceptTransitGatewayPeeringAttachmentError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_accept_transit_gateway_vpc_attachment_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AcceptTransitGatewayVpcAttachmentOutput,
    crate::error::AcceptTransitGatewayVpcAttachmentError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AcceptTransitGatewayVpcAttachmentError::unhandled)?;
    Err(crate::error::AcceptTransitGatewayVpcAttachmentError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_accept_transit_gateway_vpc_attachment_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AcceptTransitGatewayVpcAttachmentOutput,
    crate::error::AcceptTransitGatewayVpcAttachmentError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::accept_transit_gateway_vpc_attachment_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_accept_transit_gateway_vpc_attachment(response.body().as_ref(), output).map_err(crate::error::AcceptTransitGatewayVpcAttachmentError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_accept_vpc_endpoint_connections_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AcceptVpcEndpointConnectionsOutput,
    crate::error::AcceptVpcEndpointConnectionsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AcceptVpcEndpointConnectionsError::unhandled)?;
    Err(crate::error::AcceptVpcEndpointConnectionsError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_accept_vpc_endpoint_connections_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AcceptVpcEndpointConnectionsOutput,
    crate::error::AcceptVpcEndpointConnectionsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::accept_vpc_endpoint_connections_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_accept_vpc_endpoint_connections(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::AcceptVpcEndpointConnectionsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_accept_vpc_peering_connection_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AcceptVpcPeeringConnectionOutput,
    crate::error::AcceptVpcPeeringConnectionError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AcceptVpcPeeringConnectionError::unhandled)?;
    Err(crate::error::AcceptVpcPeeringConnectionError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_accept_vpc_peering_connection_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AcceptVpcPeeringConnectionOutput,
    crate::error::AcceptVpcPeeringConnectionError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::accept_vpc_peering_connection_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_accept_vpc_peering_connection(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::AcceptVpcPeeringConnectionError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_advertise_byoip_cidr_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AdvertiseByoipCidrOutput,
    crate::error::AdvertiseByoipCidrError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AdvertiseByoipCidrError::unhandled)?;
    Err(crate::error::AdvertiseByoipCidrError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_advertise_byoip_cidr_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AdvertiseByoipCidrOutput,
    crate::error::AdvertiseByoipCidrError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::advertise_byoip_cidr_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_advertise_byoip_cidr(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::AdvertiseByoipCidrError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_allocate_address_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::AllocateAddressOutput, crate::error::AllocateAddressError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AllocateAddressError::unhandled)?;
    Err(crate::error::AllocateAddressError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_allocate_address_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::AllocateAddressOutput, crate::error::AllocateAddressError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::allocate_address_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_allocate_address(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::AllocateAddressError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_allocate_hosts_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::AllocateHostsOutput, crate::error::AllocateHostsError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AllocateHostsError::unhandled)?;
    Err(crate::error::AllocateHostsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_allocate_hosts_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::AllocateHostsOutput, crate::error::AllocateHostsError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::allocate_hosts_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_allocate_hosts(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::AllocateHostsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_apply_security_groups_to_client_vpn_target_network_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ApplySecurityGroupsToClientVpnTargetNetworkOutput,
    crate::error::ApplySecurityGroupsToClientVpnTargetNetworkError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ApplySecurityGroupsToClientVpnTargetNetworkError::unhandled)?;
    Err(crate::error::ApplySecurityGroupsToClientVpnTargetNetworkError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_apply_security_groups_to_client_vpn_target_network_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ApplySecurityGroupsToClientVpnTargetNetworkOutput,
    crate::error::ApplySecurityGroupsToClientVpnTargetNetworkError,
> {
    Ok({
        #[allow(unused_mut)]let mut output = crate::output::apply_security_groups_to_client_vpn_target_network_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_apply_security_groups_to_client_vpn_target_network(response.body().as_ref(), output).map_err(crate::error::ApplySecurityGroupsToClientVpnTargetNetworkError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_assign_ipv6_addresses_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AssignIpv6AddressesOutput,
    crate::error::AssignIpv6AddressesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AssignIpv6AddressesError::unhandled)?;
    Err(crate::error::AssignIpv6AddressesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_assign_ipv6_addresses_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AssignIpv6AddressesOutput,
    crate::error::AssignIpv6AddressesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::assign_ipv6_addresses_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_assign_ipv6_addresses(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::AssignIpv6AddressesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_assign_private_ip_addresses_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AssignPrivateIpAddressesOutput,
    crate::error::AssignPrivateIpAddressesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AssignPrivateIpAddressesError::unhandled)?;
    Err(crate::error::AssignPrivateIpAddressesError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_assign_private_ip_addresses_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AssignPrivateIpAddressesOutput,
    crate::error::AssignPrivateIpAddressesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::assign_private_ip_addresses_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_assign_private_ip_addresses(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::AssignPrivateIpAddressesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_address_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::AssociateAddressOutput, crate::error::AssociateAddressError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AssociateAddressError::unhandled)?;
    Err(crate::error::AssociateAddressError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_address_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::AssociateAddressOutput, crate::error::AssociateAddressError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::associate_address_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_associate_address(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::AssociateAddressError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_client_vpn_target_network_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AssociateClientVpnTargetNetworkOutput,
    crate::error::AssociateClientVpnTargetNetworkError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AssociateClientVpnTargetNetworkError::unhandled)?;
    Err(crate::error::AssociateClientVpnTargetNetworkError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_client_vpn_target_network_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AssociateClientVpnTargetNetworkOutput,
    crate::error::AssociateClientVpnTargetNetworkError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::associate_client_vpn_target_network_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_associate_client_vpn_target_network(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::AssociateClientVpnTargetNetworkError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_dhcp_options_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AssociateDhcpOptionsOutput,
    crate::error::AssociateDhcpOptionsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AssociateDhcpOptionsError::unhandled)?;
    Err(crate::error::AssociateDhcpOptionsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_dhcp_options_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AssociateDhcpOptionsOutput,
    crate::error::AssociateDhcpOptionsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::associate_dhcp_options_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_enclave_certificate_iam_role_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AssociateEnclaveCertificateIamRoleOutput,
    crate::error::AssociateEnclaveCertificateIamRoleError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AssociateEnclaveCertificateIamRoleError::unhandled)?;
    Err(crate::error::AssociateEnclaveCertificateIamRoleError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_enclave_certificate_iam_role_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AssociateEnclaveCertificateIamRoleOutput,
    crate::error::AssociateEnclaveCertificateIamRoleError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::associate_enclave_certificate_iam_role_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_associate_enclave_certificate_iam_role(response.body().as_ref(), output).map_err(crate::error::AssociateEnclaveCertificateIamRoleError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_iam_instance_profile_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AssociateIamInstanceProfileOutput,
    crate::error::AssociateIamInstanceProfileError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AssociateIamInstanceProfileError::unhandled)?;
    Err(crate::error::AssociateIamInstanceProfileError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_iam_instance_profile_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AssociateIamInstanceProfileOutput,
    crate::error::AssociateIamInstanceProfileError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::associate_iam_instance_profile_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_associate_iam_instance_profile(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::AssociateIamInstanceProfileError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_instance_event_window_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AssociateInstanceEventWindowOutput,
    crate::error::AssociateInstanceEventWindowError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AssociateInstanceEventWindowError::unhandled)?;
    Err(crate::error::AssociateInstanceEventWindowError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_instance_event_window_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AssociateInstanceEventWindowOutput,
    crate::error::AssociateInstanceEventWindowError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::associate_instance_event_window_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_associate_instance_event_window(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::AssociateInstanceEventWindowError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_route_table_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AssociateRouteTableOutput,
    crate::error::AssociateRouteTableError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AssociateRouteTableError::unhandled)?;
    Err(crate::error::AssociateRouteTableError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_route_table_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AssociateRouteTableOutput,
    crate::error::AssociateRouteTableError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::associate_route_table_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_associate_route_table(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::AssociateRouteTableError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_subnet_cidr_block_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AssociateSubnetCidrBlockOutput,
    crate::error::AssociateSubnetCidrBlockError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AssociateSubnetCidrBlockError::unhandled)?;
    Err(crate::error::AssociateSubnetCidrBlockError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_subnet_cidr_block_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AssociateSubnetCidrBlockOutput,
    crate::error::AssociateSubnetCidrBlockError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::associate_subnet_cidr_block_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_associate_subnet_cidr_block(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::AssociateSubnetCidrBlockError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_transit_gateway_multicast_domain_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AssociateTransitGatewayMulticastDomainOutput,
    crate::error::AssociateTransitGatewayMulticastDomainError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AssociateTransitGatewayMulticastDomainError::unhandled)?;
    Err(crate::error::AssociateTransitGatewayMulticastDomainError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_transit_gateway_multicast_domain_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AssociateTransitGatewayMulticastDomainOutput,
    crate::error::AssociateTransitGatewayMulticastDomainError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::associate_transit_gateway_multicast_domain_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_associate_transit_gateway_multicast_domain(response.body().as_ref(), output).map_err(crate::error::AssociateTransitGatewayMulticastDomainError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_transit_gateway_route_table_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AssociateTransitGatewayRouteTableOutput,
    crate::error::AssociateTransitGatewayRouteTableError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AssociateTransitGatewayRouteTableError::unhandled)?;
    Err(crate::error::AssociateTransitGatewayRouteTableError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_transit_gateway_route_table_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AssociateTransitGatewayRouteTableOutput,
    crate::error::AssociateTransitGatewayRouteTableError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::associate_transit_gateway_route_table_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_associate_transit_gateway_route_table(response.body().as_ref(), output).map_err(crate::error::AssociateTransitGatewayRouteTableError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_trunk_interface_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AssociateTrunkInterfaceOutput,
    crate::error::AssociateTrunkInterfaceError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AssociateTrunkInterfaceError::unhandled)?;
    Err(crate::error::AssociateTrunkInterfaceError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_trunk_interface_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AssociateTrunkInterfaceOutput,
    crate::error::AssociateTrunkInterfaceError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::associate_trunk_interface_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_associate_trunk_interface(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::AssociateTrunkInterfaceError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_vpc_cidr_block_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AssociateVpcCidrBlockOutput,
    crate::error::AssociateVpcCidrBlockError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AssociateVpcCidrBlockError::unhandled)?;
    Err(crate::error::AssociateVpcCidrBlockError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_associate_vpc_cidr_block_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AssociateVpcCidrBlockOutput,
    crate::error::AssociateVpcCidrBlockError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::associate_vpc_cidr_block_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_associate_vpc_cidr_block(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::AssociateVpcCidrBlockError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_attach_classic_link_vpc_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AttachClassicLinkVpcOutput,
    crate::error::AttachClassicLinkVpcError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AttachClassicLinkVpcError::unhandled)?;
    Err(crate::error::AttachClassicLinkVpcError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_attach_classic_link_vpc_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AttachClassicLinkVpcOutput,
    crate::error::AttachClassicLinkVpcError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::attach_classic_link_vpc_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_attach_classic_link_vpc(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::AttachClassicLinkVpcError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_attach_internet_gateway_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AttachInternetGatewayOutput,
    crate::error::AttachInternetGatewayError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AttachInternetGatewayError::unhandled)?;
    Err(crate::error::AttachInternetGatewayError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_attach_internet_gateway_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AttachInternetGatewayOutput,
    crate::error::AttachInternetGatewayError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::attach_internet_gateway_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_attach_network_interface_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AttachNetworkInterfaceOutput,
    crate::error::AttachNetworkInterfaceError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AttachNetworkInterfaceError::unhandled)?;
    Err(crate::error::AttachNetworkInterfaceError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_attach_network_interface_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AttachNetworkInterfaceOutput,
    crate::error::AttachNetworkInterfaceError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::attach_network_interface_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_attach_network_interface(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::AttachNetworkInterfaceError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_attach_volume_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::AttachVolumeOutput, crate::error::AttachVolumeError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AttachVolumeError::unhandled)?;
    Err(crate::error::AttachVolumeError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_attach_volume_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::AttachVolumeOutput, crate::error::AttachVolumeError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::attach_volume_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_attach_volume(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::AttachVolumeError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_attach_vpn_gateway_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::AttachVpnGatewayOutput, crate::error::AttachVpnGatewayError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AttachVpnGatewayError::unhandled)?;
    Err(crate::error::AttachVpnGatewayError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_attach_vpn_gateway_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::AttachVpnGatewayOutput, crate::error::AttachVpnGatewayError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::attach_vpn_gateway_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_attach_vpn_gateway(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::AttachVpnGatewayError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_authorize_client_vpn_ingress_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AuthorizeClientVpnIngressOutput,
    crate::error::AuthorizeClientVpnIngressError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AuthorizeClientVpnIngressError::unhandled)?;
    Err(crate::error::AuthorizeClientVpnIngressError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_authorize_client_vpn_ingress_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AuthorizeClientVpnIngressOutput,
    crate::error::AuthorizeClientVpnIngressError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::authorize_client_vpn_ingress_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_authorize_client_vpn_ingress(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::AuthorizeClientVpnIngressError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_authorize_security_group_egress_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AuthorizeSecurityGroupEgressOutput,
    crate::error::AuthorizeSecurityGroupEgressError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AuthorizeSecurityGroupEgressError::unhandled)?;
    Err(crate::error::AuthorizeSecurityGroupEgressError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_authorize_security_group_egress_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AuthorizeSecurityGroupEgressOutput,
    crate::error::AuthorizeSecurityGroupEgressError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::authorize_security_group_egress_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_authorize_security_group_egress(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::AuthorizeSecurityGroupEgressError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_authorize_security_group_ingress_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AuthorizeSecurityGroupIngressOutput,
    crate::error::AuthorizeSecurityGroupIngressError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::AuthorizeSecurityGroupIngressError::unhandled)?;
    Err(crate::error::AuthorizeSecurityGroupIngressError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_authorize_security_group_ingress_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AuthorizeSecurityGroupIngressOutput,
    crate::error::AuthorizeSecurityGroupIngressError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::authorize_security_group_ingress_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_authorize_security_group_ingress(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::AuthorizeSecurityGroupIngressError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_bundle_instance_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::BundleInstanceOutput, crate::error::BundleInstanceError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::BundleInstanceError::unhandled)?;
    Err(crate::error::BundleInstanceError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_bundle_instance_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::BundleInstanceOutput, crate::error::BundleInstanceError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::bundle_instance_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_bundle_instance(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::BundleInstanceError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_cancel_bundle_task_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CancelBundleTaskOutput, crate::error::CancelBundleTaskError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CancelBundleTaskError::unhandled)?;
    Err(crate::error::CancelBundleTaskError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_cancel_bundle_task_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CancelBundleTaskOutput, crate::error::CancelBundleTaskError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::cancel_bundle_task_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_cancel_bundle_task(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CancelBundleTaskError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_cancel_capacity_reservation_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CancelCapacityReservationOutput,
    crate::error::CancelCapacityReservationError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CancelCapacityReservationError::unhandled)?;
    Err(crate::error::CancelCapacityReservationError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_cancel_capacity_reservation_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CancelCapacityReservationOutput,
    crate::error::CancelCapacityReservationError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::cancel_capacity_reservation_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_cancel_capacity_reservation(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CancelCapacityReservationError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_cancel_capacity_reservation_fleets_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CancelCapacityReservationFleetsOutput,
    crate::error::CancelCapacityReservationFleetsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CancelCapacityReservationFleetsError::unhandled)?;
    Err(crate::error::CancelCapacityReservationFleetsError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_cancel_capacity_reservation_fleets_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CancelCapacityReservationFleetsOutput,
    crate::error::CancelCapacityReservationFleetsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::cancel_capacity_reservation_fleets_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_cancel_capacity_reservation_fleets(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::CancelCapacityReservationFleetsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_cancel_conversion_task_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CancelConversionTaskOutput,
    crate::error::CancelConversionTaskError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CancelConversionTaskError::unhandled)?;
    Err(crate::error::CancelConversionTaskError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_cancel_conversion_task_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CancelConversionTaskOutput,
    crate::error::CancelConversionTaskError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::cancel_conversion_task_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_cancel_export_task_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CancelExportTaskOutput, crate::error::CancelExportTaskError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CancelExportTaskError::unhandled)?;
    Err(crate::error::CancelExportTaskError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_cancel_export_task_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CancelExportTaskOutput, crate::error::CancelExportTaskError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::cancel_export_task_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_cancel_import_task_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CancelImportTaskOutput, crate::error::CancelImportTaskError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CancelImportTaskError::unhandled)?;
    Err(crate::error::CancelImportTaskError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_cancel_import_task_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CancelImportTaskOutput, crate::error::CancelImportTaskError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::cancel_import_task_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_cancel_import_task(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CancelImportTaskError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_cancel_reserved_instances_listing_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CancelReservedInstancesListingOutput,
    crate::error::CancelReservedInstancesListingError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CancelReservedInstancesListingError::unhandled)?;
    Err(crate::error::CancelReservedInstancesListingError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_cancel_reserved_instances_listing_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CancelReservedInstancesListingOutput,
    crate::error::CancelReservedInstancesListingError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::cancel_reserved_instances_listing_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_cancel_reserved_instances_listing(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::CancelReservedInstancesListingError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_cancel_spot_fleet_requests_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CancelSpotFleetRequestsOutput,
    crate::error::CancelSpotFleetRequestsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CancelSpotFleetRequestsError::unhandled)?;
    Err(crate::error::CancelSpotFleetRequestsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_cancel_spot_fleet_requests_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CancelSpotFleetRequestsOutput,
    crate::error::CancelSpotFleetRequestsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::cancel_spot_fleet_requests_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_cancel_spot_fleet_requests(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CancelSpotFleetRequestsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_cancel_spot_instance_requests_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CancelSpotInstanceRequestsOutput,
    crate::error::CancelSpotInstanceRequestsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CancelSpotInstanceRequestsError::unhandled)?;
    Err(crate::error::CancelSpotInstanceRequestsError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_cancel_spot_instance_requests_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CancelSpotInstanceRequestsOutput,
    crate::error::CancelSpotInstanceRequestsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::cancel_spot_instance_requests_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_cancel_spot_instance_requests(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CancelSpotInstanceRequestsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_confirm_product_instance_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ConfirmProductInstanceOutput,
    crate::error::ConfirmProductInstanceError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ConfirmProductInstanceError::unhandled)?;
    Err(crate::error::ConfirmProductInstanceError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_confirm_product_instance_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ConfirmProductInstanceOutput,
    crate::error::ConfirmProductInstanceError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::confirm_product_instance_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_confirm_product_instance(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ConfirmProductInstanceError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_copy_fpga_image_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CopyFpgaImageOutput, crate::error::CopyFpgaImageError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CopyFpgaImageError::unhandled)?;
    Err(crate::error::CopyFpgaImageError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_copy_fpga_image_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CopyFpgaImageOutput, crate::error::CopyFpgaImageError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::copy_fpga_image_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_copy_fpga_image(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CopyFpgaImageError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_copy_image_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CopyImageOutput, crate::error::CopyImageError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CopyImageError::unhandled)?;
    Err(crate::error::CopyImageError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_copy_image_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CopyImageOutput, crate::error::CopyImageError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::copy_image_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_copy_image(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CopyImageError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_copy_snapshot_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CopySnapshotOutput, crate::error::CopySnapshotError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CopySnapshotError::unhandled)?;
    Err(crate::error::CopySnapshotError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_copy_snapshot_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CopySnapshotOutput, crate::error::CopySnapshotError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::copy_snapshot_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_copy_snapshot(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CopySnapshotError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_capacity_reservation_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateCapacityReservationOutput,
    crate::error::CreateCapacityReservationError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateCapacityReservationError::unhandled)?;
    Err(crate::error::CreateCapacityReservationError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_capacity_reservation_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateCapacityReservationOutput,
    crate::error::CreateCapacityReservationError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_capacity_reservation_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_capacity_reservation(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateCapacityReservationError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_capacity_reservation_fleet_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateCapacityReservationFleetOutput,
    crate::error::CreateCapacityReservationFleetError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateCapacityReservationFleetError::unhandled)?;
    Err(crate::error::CreateCapacityReservationFleetError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_capacity_reservation_fleet_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateCapacityReservationFleetOutput,
    crate::error::CreateCapacityReservationFleetError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::create_capacity_reservation_fleet_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_create_capacity_reservation_fleet(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::CreateCapacityReservationFleetError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_carrier_gateway_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateCarrierGatewayOutput,
    crate::error::CreateCarrierGatewayError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateCarrierGatewayError::unhandled)?;
    Err(crate::error::CreateCarrierGatewayError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_carrier_gateway_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateCarrierGatewayOutput,
    crate::error::CreateCarrierGatewayError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_carrier_gateway_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_carrier_gateway(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateCarrierGatewayError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_client_vpn_endpoint_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateClientVpnEndpointOutput,
    crate::error::CreateClientVpnEndpointError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateClientVpnEndpointError::unhandled)?;
    Err(crate::error::CreateClientVpnEndpointError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_client_vpn_endpoint_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateClientVpnEndpointOutput,
    crate::error::CreateClientVpnEndpointError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_client_vpn_endpoint_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_client_vpn_endpoint(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateClientVpnEndpointError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_client_vpn_route_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateClientVpnRouteOutput,
    crate::error::CreateClientVpnRouteError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateClientVpnRouteError::unhandled)?;
    Err(crate::error::CreateClientVpnRouteError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_client_vpn_route_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateClientVpnRouteOutput,
    crate::error::CreateClientVpnRouteError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_client_vpn_route_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_client_vpn_route(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateClientVpnRouteError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_customer_gateway_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateCustomerGatewayOutput,
    crate::error::CreateCustomerGatewayError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateCustomerGatewayError::unhandled)?;
    Err(crate::error::CreateCustomerGatewayError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_customer_gateway_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateCustomerGatewayOutput,
    crate::error::CreateCustomerGatewayError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_customer_gateway_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_customer_gateway(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateCustomerGatewayError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_default_subnet_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateDefaultSubnetOutput,
    crate::error::CreateDefaultSubnetError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateDefaultSubnetError::unhandled)?;
    Err(crate::error::CreateDefaultSubnetError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_default_subnet_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateDefaultSubnetOutput,
    crate::error::CreateDefaultSubnetError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_default_subnet_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_default_subnet(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateDefaultSubnetError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_default_vpc_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateDefaultVpcOutput, crate::error::CreateDefaultVpcError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateDefaultVpcError::unhandled)?;
    Err(crate::error::CreateDefaultVpcError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_default_vpc_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateDefaultVpcOutput, crate::error::CreateDefaultVpcError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_default_vpc_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_default_vpc(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateDefaultVpcError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_dhcp_options_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateDhcpOptionsOutput, crate::error::CreateDhcpOptionsError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateDhcpOptionsError::unhandled)?;
    Err(crate::error::CreateDhcpOptionsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_dhcp_options_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateDhcpOptionsOutput, crate::error::CreateDhcpOptionsError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_dhcp_options_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_dhcp_options(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateDhcpOptionsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_egress_only_internet_gateway_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateEgressOnlyInternetGatewayOutput,
    crate::error::CreateEgressOnlyInternetGatewayError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateEgressOnlyInternetGatewayError::unhandled)?;
    Err(crate::error::CreateEgressOnlyInternetGatewayError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_egress_only_internet_gateway_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateEgressOnlyInternetGatewayOutput,
    crate::error::CreateEgressOnlyInternetGatewayError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::create_egress_only_internet_gateway_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_create_egress_only_internet_gateway(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::CreateEgressOnlyInternetGatewayError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_fleet_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateFleetOutput, crate::error::CreateFleetError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateFleetError::unhandled)?;
    Err(crate::error::CreateFleetError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_fleet_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateFleetOutput, crate::error::CreateFleetError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_fleet_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_fleet(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateFleetError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_flow_logs_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateFlowLogsOutput, crate::error::CreateFlowLogsError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateFlowLogsError::unhandled)?;
    Err(crate::error::CreateFlowLogsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_flow_logs_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateFlowLogsOutput, crate::error::CreateFlowLogsError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_flow_logs_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_flow_logs(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateFlowLogsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_fpga_image_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateFpgaImageOutput, crate::error::CreateFpgaImageError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateFpgaImageError::unhandled)?;
    Err(crate::error::CreateFpgaImageError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_fpga_image_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateFpgaImageOutput, crate::error::CreateFpgaImageError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_fpga_image_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_fpga_image(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateFpgaImageError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_image_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateImageOutput, crate::error::CreateImageError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateImageError::unhandled)?;
    Err(crate::error::CreateImageError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_image_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateImageOutput, crate::error::CreateImageError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_image_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_image(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateImageError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_instance_event_window_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateInstanceEventWindowOutput,
    crate::error::CreateInstanceEventWindowError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateInstanceEventWindowError::unhandled)?;
    Err(crate::error::CreateInstanceEventWindowError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_instance_event_window_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateInstanceEventWindowOutput,
    crate::error::CreateInstanceEventWindowError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_instance_event_window_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_instance_event_window(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateInstanceEventWindowError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_instance_export_task_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateInstanceExportTaskOutput,
    crate::error::CreateInstanceExportTaskError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateInstanceExportTaskError::unhandled)?;
    Err(crate::error::CreateInstanceExportTaskError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_instance_export_task_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateInstanceExportTaskOutput,
    crate::error::CreateInstanceExportTaskError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_instance_export_task_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_instance_export_task(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateInstanceExportTaskError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_internet_gateway_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateInternetGatewayOutput,
    crate::error::CreateInternetGatewayError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateInternetGatewayError::unhandled)?;
    Err(crate::error::CreateInternetGatewayError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_internet_gateway_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateInternetGatewayOutput,
    crate::error::CreateInternetGatewayError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_internet_gateway_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_internet_gateway(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateInternetGatewayError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_key_pair_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateKeyPairOutput, crate::error::CreateKeyPairError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateKeyPairError::unhandled)?;
    Err(crate::error::CreateKeyPairError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_key_pair_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateKeyPairOutput, crate::error::CreateKeyPairError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_key_pair_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_key_pair(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateKeyPairError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_launch_template_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateLaunchTemplateOutput,
    crate::error::CreateLaunchTemplateError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateLaunchTemplateError::unhandled)?;
    Err(crate::error::CreateLaunchTemplateError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_launch_template_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateLaunchTemplateOutput,
    crate::error::CreateLaunchTemplateError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_launch_template_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_launch_template(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateLaunchTemplateError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_launch_template_version_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateLaunchTemplateVersionOutput,
    crate::error::CreateLaunchTemplateVersionError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateLaunchTemplateVersionError::unhandled)?;
    Err(crate::error::CreateLaunchTemplateVersionError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_launch_template_version_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateLaunchTemplateVersionOutput,
    crate::error::CreateLaunchTemplateVersionError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_launch_template_version_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_launch_template_version(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateLaunchTemplateVersionError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_local_gateway_route_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateLocalGatewayRouteOutput,
    crate::error::CreateLocalGatewayRouteError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateLocalGatewayRouteError::unhandled)?;
    Err(crate::error::CreateLocalGatewayRouteError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_local_gateway_route_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateLocalGatewayRouteOutput,
    crate::error::CreateLocalGatewayRouteError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_local_gateway_route_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_local_gateway_route(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateLocalGatewayRouteError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_local_gateway_route_table_vpc_association_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateLocalGatewayRouteTableVpcAssociationOutput,
    crate::error::CreateLocalGatewayRouteTableVpcAssociationError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateLocalGatewayRouteTableVpcAssociationError::unhandled)?;
    Err(crate::error::CreateLocalGatewayRouteTableVpcAssociationError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_local_gateway_route_table_vpc_association_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateLocalGatewayRouteTableVpcAssociationOutput,
    crate::error::CreateLocalGatewayRouteTableVpcAssociationError,
> {
    Ok({
        #[allow(unused_mut)]let mut output = crate::output::create_local_gateway_route_table_vpc_association_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_local_gateway_route_table_vpc_association(response.body().as_ref(), output).map_err(crate::error::CreateLocalGatewayRouteTableVpcAssociationError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_managed_prefix_list_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateManagedPrefixListOutput,
    crate::error::CreateManagedPrefixListError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateManagedPrefixListError::unhandled)?;
    Err(crate::error::CreateManagedPrefixListError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_managed_prefix_list_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateManagedPrefixListOutput,
    crate::error::CreateManagedPrefixListError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_managed_prefix_list_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_managed_prefix_list(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateManagedPrefixListError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_nat_gateway_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateNatGatewayOutput, crate::error::CreateNatGatewayError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateNatGatewayError::unhandled)?;
    Err(crate::error::CreateNatGatewayError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_nat_gateway_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateNatGatewayOutput, crate::error::CreateNatGatewayError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_nat_gateway_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_nat_gateway(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateNatGatewayError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_network_acl_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateNetworkAclOutput, crate::error::CreateNetworkAclError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateNetworkAclError::unhandled)?;
    Err(crate::error::CreateNetworkAclError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_network_acl_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateNetworkAclOutput, crate::error::CreateNetworkAclError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_network_acl_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_network_acl(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateNetworkAclError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_network_acl_entry_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateNetworkAclEntryOutput,
    crate::error::CreateNetworkAclEntryError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateNetworkAclEntryError::unhandled)?;
    Err(crate::error::CreateNetworkAclEntryError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_network_acl_entry_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateNetworkAclEntryOutput,
    crate::error::CreateNetworkAclEntryError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_network_acl_entry_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_network_insights_path_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateNetworkInsightsPathOutput,
    crate::error::CreateNetworkInsightsPathError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateNetworkInsightsPathError::unhandled)?;
    Err(crate::error::CreateNetworkInsightsPathError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_network_insights_path_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateNetworkInsightsPathOutput,
    crate::error::CreateNetworkInsightsPathError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_network_insights_path_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_network_insights_path(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateNetworkInsightsPathError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_network_interface_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateNetworkInterfaceOutput,
    crate::error::CreateNetworkInterfaceError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateNetworkInterfaceError::unhandled)?;
    Err(crate::error::CreateNetworkInterfaceError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_network_interface_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateNetworkInterfaceOutput,
    crate::error::CreateNetworkInterfaceError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_network_interface_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_network_interface(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateNetworkInterfaceError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_network_interface_permission_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateNetworkInterfacePermissionOutput,
    crate::error::CreateNetworkInterfacePermissionError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateNetworkInterfacePermissionError::unhandled)?;
    Err(crate::error::CreateNetworkInterfacePermissionError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_network_interface_permission_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateNetworkInterfacePermissionOutput,
    crate::error::CreateNetworkInterfacePermissionError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::create_network_interface_permission_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_create_network_interface_permission(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::CreateNetworkInterfacePermissionError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_placement_group_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreatePlacementGroupOutput,
    crate::error::CreatePlacementGroupError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreatePlacementGroupError::unhandled)?;
    Err(crate::error::CreatePlacementGroupError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_placement_group_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreatePlacementGroupOutput,
    crate::error::CreatePlacementGroupError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_placement_group_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_placement_group(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreatePlacementGroupError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_replace_root_volume_task_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateReplaceRootVolumeTaskOutput,
    crate::error::CreateReplaceRootVolumeTaskError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateReplaceRootVolumeTaskError::unhandled)?;
    Err(crate::error::CreateReplaceRootVolumeTaskError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_replace_root_volume_task_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateReplaceRootVolumeTaskOutput,
    crate::error::CreateReplaceRootVolumeTaskError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_replace_root_volume_task_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_replace_root_volume_task(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateReplaceRootVolumeTaskError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_reserved_instances_listing_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateReservedInstancesListingOutput,
    crate::error::CreateReservedInstancesListingError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateReservedInstancesListingError::unhandled)?;
    Err(crate::error::CreateReservedInstancesListingError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_reserved_instances_listing_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateReservedInstancesListingOutput,
    crate::error::CreateReservedInstancesListingError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::create_reserved_instances_listing_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_create_reserved_instances_listing(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::CreateReservedInstancesListingError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_restore_image_task_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateRestoreImageTaskOutput,
    crate::error::CreateRestoreImageTaskError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateRestoreImageTaskError::unhandled)?;
    Err(crate::error::CreateRestoreImageTaskError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_restore_image_task_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateRestoreImageTaskOutput,
    crate::error::CreateRestoreImageTaskError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_restore_image_task_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_restore_image_task(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateRestoreImageTaskError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_route_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateRouteOutput, crate::error::CreateRouteError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateRouteError::unhandled)?;
    Err(crate::error::CreateRouteError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_route_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateRouteOutput, crate::error::CreateRouteError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_route_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_route(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateRouteError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_route_table_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateRouteTableOutput, crate::error::CreateRouteTableError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateRouteTableError::unhandled)?;
    Err(crate::error::CreateRouteTableError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_route_table_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateRouteTableOutput, crate::error::CreateRouteTableError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_route_table_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_route_table(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateRouteTableError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_security_group_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateSecurityGroupOutput,
    crate::error::CreateSecurityGroupError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateSecurityGroupError::unhandled)?;
    Err(crate::error::CreateSecurityGroupError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_security_group_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateSecurityGroupOutput,
    crate::error::CreateSecurityGroupError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_security_group_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_security_group(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateSecurityGroupError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_snapshot_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateSnapshotOutput, crate::error::CreateSnapshotError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateSnapshotError::unhandled)?;
    Err(crate::error::CreateSnapshotError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_snapshot_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateSnapshotOutput, crate::error::CreateSnapshotError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_snapshot_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_snapshot(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateSnapshotError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_snapshots_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateSnapshotsOutput, crate::error::CreateSnapshotsError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateSnapshotsError::unhandled)?;
    Err(crate::error::CreateSnapshotsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_snapshots_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateSnapshotsOutput, crate::error::CreateSnapshotsError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_snapshots_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_snapshots(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateSnapshotsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_spot_datafeed_subscription_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateSpotDatafeedSubscriptionOutput,
    crate::error::CreateSpotDatafeedSubscriptionError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateSpotDatafeedSubscriptionError::unhandled)?;
    Err(crate::error::CreateSpotDatafeedSubscriptionError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_spot_datafeed_subscription_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateSpotDatafeedSubscriptionOutput,
    crate::error::CreateSpotDatafeedSubscriptionError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::create_spot_datafeed_subscription_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_create_spot_datafeed_subscription(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::CreateSpotDatafeedSubscriptionError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_store_image_task_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateStoreImageTaskOutput,
    crate::error::CreateStoreImageTaskError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateStoreImageTaskError::unhandled)?;
    Err(crate::error::CreateStoreImageTaskError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_store_image_task_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateStoreImageTaskOutput,
    crate::error::CreateStoreImageTaskError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_store_image_task_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_store_image_task(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateStoreImageTaskError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_subnet_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateSubnetOutput, crate::error::CreateSubnetError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateSubnetError::unhandled)?;
    Err(crate::error::CreateSubnetError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_subnet_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateSubnetOutput, crate::error::CreateSubnetError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_subnet_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_subnet(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateSubnetError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_subnet_cidr_reservation_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateSubnetCidrReservationOutput,
    crate::error::CreateSubnetCidrReservationError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateSubnetCidrReservationError::unhandled)?;
    Err(crate::error::CreateSubnetCidrReservationError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_subnet_cidr_reservation_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateSubnetCidrReservationOutput,
    crate::error::CreateSubnetCidrReservationError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_subnet_cidr_reservation_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_subnet_cidr_reservation(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateSubnetCidrReservationError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_tags_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateTagsOutput, crate::error::CreateTagsError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateTagsError::unhandled)?;
    Err(crate::error::CreateTagsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_tags_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateTagsOutput, crate::error::CreateTagsError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_tags_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_traffic_mirror_filter_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateTrafficMirrorFilterOutput,
    crate::error::CreateTrafficMirrorFilterError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateTrafficMirrorFilterError::unhandled)?;
    Err(crate::error::CreateTrafficMirrorFilterError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_traffic_mirror_filter_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateTrafficMirrorFilterOutput,
    crate::error::CreateTrafficMirrorFilterError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_traffic_mirror_filter_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_traffic_mirror_filter(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateTrafficMirrorFilterError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_traffic_mirror_filter_rule_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateTrafficMirrorFilterRuleOutput,
    crate::error::CreateTrafficMirrorFilterRuleError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateTrafficMirrorFilterRuleError::unhandled)?;
    Err(crate::error::CreateTrafficMirrorFilterRuleError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_traffic_mirror_filter_rule_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateTrafficMirrorFilterRuleOutput,
    crate::error::CreateTrafficMirrorFilterRuleError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::create_traffic_mirror_filter_rule_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_create_traffic_mirror_filter_rule(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::CreateTrafficMirrorFilterRuleError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_traffic_mirror_session_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateTrafficMirrorSessionOutput,
    crate::error::CreateTrafficMirrorSessionError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateTrafficMirrorSessionError::unhandled)?;
    Err(crate::error::CreateTrafficMirrorSessionError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_traffic_mirror_session_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateTrafficMirrorSessionOutput,
    crate::error::CreateTrafficMirrorSessionError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_traffic_mirror_session_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_traffic_mirror_session(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateTrafficMirrorSessionError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_traffic_mirror_target_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateTrafficMirrorTargetOutput,
    crate::error::CreateTrafficMirrorTargetError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateTrafficMirrorTargetError::unhandled)?;
    Err(crate::error::CreateTrafficMirrorTargetError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_traffic_mirror_target_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateTrafficMirrorTargetOutput,
    crate::error::CreateTrafficMirrorTargetError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_traffic_mirror_target_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_traffic_mirror_target(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateTrafficMirrorTargetError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_transit_gateway_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateTransitGatewayOutput,
    crate::error::CreateTransitGatewayError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateTransitGatewayError::unhandled)?;
    Err(crate::error::CreateTransitGatewayError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_transit_gateway_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateTransitGatewayOutput,
    crate::error::CreateTransitGatewayError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_transit_gateway_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_transit_gateway(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateTransitGatewayError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_transit_gateway_connect_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateTransitGatewayConnectOutput,
    crate::error::CreateTransitGatewayConnectError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateTransitGatewayConnectError::unhandled)?;
    Err(crate::error::CreateTransitGatewayConnectError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_transit_gateway_connect_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateTransitGatewayConnectOutput,
    crate::error::CreateTransitGatewayConnectError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_transit_gateway_connect_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_transit_gateway_connect(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateTransitGatewayConnectError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_transit_gateway_connect_peer_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateTransitGatewayConnectPeerOutput,
    crate::error::CreateTransitGatewayConnectPeerError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateTransitGatewayConnectPeerError::unhandled)?;
    Err(crate::error::CreateTransitGatewayConnectPeerError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_transit_gateway_connect_peer_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateTransitGatewayConnectPeerOutput,
    crate::error::CreateTransitGatewayConnectPeerError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::create_transit_gateway_connect_peer_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_create_transit_gateway_connect_peer(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::CreateTransitGatewayConnectPeerError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_transit_gateway_multicast_domain_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateTransitGatewayMulticastDomainOutput,
    crate::error::CreateTransitGatewayMulticastDomainError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateTransitGatewayMulticastDomainError::unhandled)?;
    Err(crate::error::CreateTransitGatewayMulticastDomainError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_transit_gateway_multicast_domain_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateTransitGatewayMulticastDomainOutput,
    crate::error::CreateTransitGatewayMulticastDomainError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::create_transit_gateway_multicast_domain_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_transit_gateway_multicast_domain(response.body().as_ref(), output).map_err(crate::error::CreateTransitGatewayMulticastDomainError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_transit_gateway_peering_attachment_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateTransitGatewayPeeringAttachmentOutput,
    crate::error::CreateTransitGatewayPeeringAttachmentError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateTransitGatewayPeeringAttachmentError::unhandled)?;
    Err(crate::error::CreateTransitGatewayPeeringAttachmentError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_transit_gateway_peering_attachment_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateTransitGatewayPeeringAttachmentOutput,
    crate::error::CreateTransitGatewayPeeringAttachmentError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::create_transit_gateway_peering_attachment_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_transit_gateway_peering_attachment(response.body().as_ref(), output).map_err(crate::error::CreateTransitGatewayPeeringAttachmentError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_transit_gateway_prefix_list_reference_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateTransitGatewayPrefixListReferenceOutput,
    crate::error::CreateTransitGatewayPrefixListReferenceError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateTransitGatewayPrefixListReferenceError::unhandled)?;
    Err(crate::error::CreateTransitGatewayPrefixListReferenceError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_transit_gateway_prefix_list_reference_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateTransitGatewayPrefixListReferenceOutput,
    crate::error::CreateTransitGatewayPrefixListReferenceError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::create_transit_gateway_prefix_list_reference_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_transit_gateway_prefix_list_reference(response.body().as_ref(), output).map_err(crate::error::CreateTransitGatewayPrefixListReferenceError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_transit_gateway_route_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateTransitGatewayRouteOutput,
    crate::error::CreateTransitGatewayRouteError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateTransitGatewayRouteError::unhandled)?;
    Err(crate::error::CreateTransitGatewayRouteError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_transit_gateway_route_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateTransitGatewayRouteOutput,
    crate::error::CreateTransitGatewayRouteError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_transit_gateway_route_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_transit_gateway_route(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateTransitGatewayRouteError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_transit_gateway_route_table_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateTransitGatewayRouteTableOutput,
    crate::error::CreateTransitGatewayRouteTableError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateTransitGatewayRouteTableError::unhandled)?;
    Err(crate::error::CreateTransitGatewayRouteTableError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_transit_gateway_route_table_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateTransitGatewayRouteTableOutput,
    crate::error::CreateTransitGatewayRouteTableError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::create_transit_gateway_route_table_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_create_transit_gateway_route_table(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::CreateTransitGatewayRouteTableError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_transit_gateway_vpc_attachment_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateTransitGatewayVpcAttachmentOutput,
    crate::error::CreateTransitGatewayVpcAttachmentError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateTransitGatewayVpcAttachmentError::unhandled)?;
    Err(crate::error::CreateTransitGatewayVpcAttachmentError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_transit_gateway_vpc_attachment_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateTransitGatewayVpcAttachmentOutput,
    crate::error::CreateTransitGatewayVpcAttachmentError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::create_transit_gateway_vpc_attachment_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_transit_gateway_vpc_attachment(response.body().as_ref(), output).map_err(crate::error::CreateTransitGatewayVpcAttachmentError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_volume_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateVolumeOutput, crate::error::CreateVolumeError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateVolumeError::unhandled)?;
    Err(crate::error::CreateVolumeError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_volume_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateVolumeOutput, crate::error::CreateVolumeError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_volume_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_volume(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateVolumeError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_vpc_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateVpcOutput, crate::error::CreateVpcError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateVpcError::unhandled)?;
    Err(crate::error::CreateVpcError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_vpc_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateVpcOutput, crate::error::CreateVpcError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_vpc_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_vpc(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateVpcError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_vpc_endpoint_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateVpcEndpointOutput, crate::error::CreateVpcEndpointError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateVpcEndpointError::unhandled)?;
    Err(crate::error::CreateVpcEndpointError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_vpc_endpoint_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateVpcEndpointOutput, crate::error::CreateVpcEndpointError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_vpc_endpoint_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_vpc_endpoint(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateVpcEndpointError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_vpc_endpoint_connection_notification_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateVpcEndpointConnectionNotificationOutput,
    crate::error::CreateVpcEndpointConnectionNotificationError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateVpcEndpointConnectionNotificationError::unhandled)?;
    Err(crate::error::CreateVpcEndpointConnectionNotificationError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_vpc_endpoint_connection_notification_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateVpcEndpointConnectionNotificationOutput,
    crate::error::CreateVpcEndpointConnectionNotificationError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::create_vpc_endpoint_connection_notification_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_vpc_endpoint_connection_notification(response.body().as_ref(), output).map_err(crate::error::CreateVpcEndpointConnectionNotificationError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_vpc_endpoint_service_configuration_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateVpcEndpointServiceConfigurationOutput,
    crate::error::CreateVpcEndpointServiceConfigurationError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateVpcEndpointServiceConfigurationError::unhandled)?;
    Err(crate::error::CreateVpcEndpointServiceConfigurationError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_vpc_endpoint_service_configuration_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateVpcEndpointServiceConfigurationOutput,
    crate::error::CreateVpcEndpointServiceConfigurationError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::create_vpc_endpoint_service_configuration_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_vpc_endpoint_service_configuration(response.body().as_ref(), output).map_err(crate::error::CreateVpcEndpointServiceConfigurationError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_vpc_peering_connection_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateVpcPeeringConnectionOutput,
    crate::error::CreateVpcPeeringConnectionError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateVpcPeeringConnectionError::unhandled)?;
    Err(crate::error::CreateVpcPeeringConnectionError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_vpc_peering_connection_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateVpcPeeringConnectionOutput,
    crate::error::CreateVpcPeeringConnectionError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_vpc_peering_connection_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_vpc_peering_connection(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateVpcPeeringConnectionError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_vpn_connection_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateVpnConnectionOutput,
    crate::error::CreateVpnConnectionError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateVpnConnectionError::unhandled)?;
    Err(crate::error::CreateVpnConnectionError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_vpn_connection_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateVpnConnectionOutput,
    crate::error::CreateVpnConnectionError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_vpn_connection_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_vpn_connection(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateVpnConnectionError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_vpn_connection_route_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateVpnConnectionRouteOutput,
    crate::error::CreateVpnConnectionRouteError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateVpnConnectionRouteError::unhandled)?;
    Err(crate::error::CreateVpnConnectionRouteError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_vpn_connection_route_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateVpnConnectionRouteOutput,
    crate::error::CreateVpnConnectionRouteError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_vpn_connection_route_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_vpn_gateway_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateVpnGatewayOutput, crate::error::CreateVpnGatewayError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateVpnGatewayError::unhandled)?;
    Err(crate::error::CreateVpnGatewayError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_vpn_gateway_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateVpnGatewayOutput, crate::error::CreateVpnGatewayError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_vpn_gateway_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_create_vpn_gateway(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateVpnGatewayError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_carrier_gateway_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteCarrierGatewayOutput,
    crate::error::DeleteCarrierGatewayError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteCarrierGatewayError::unhandled)?;
    Err(crate::error::DeleteCarrierGatewayError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_carrier_gateway_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteCarrierGatewayOutput,
    crate::error::DeleteCarrierGatewayError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_carrier_gateway_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_carrier_gateway(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DeleteCarrierGatewayError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_client_vpn_endpoint_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteClientVpnEndpointOutput,
    crate::error::DeleteClientVpnEndpointError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteClientVpnEndpointError::unhandled)?;
    Err(crate::error::DeleteClientVpnEndpointError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_client_vpn_endpoint_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteClientVpnEndpointOutput,
    crate::error::DeleteClientVpnEndpointError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_client_vpn_endpoint_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_client_vpn_endpoint(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DeleteClientVpnEndpointError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_client_vpn_route_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteClientVpnRouteOutput,
    crate::error::DeleteClientVpnRouteError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteClientVpnRouteError::unhandled)?;
    Err(crate::error::DeleteClientVpnRouteError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_client_vpn_route_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteClientVpnRouteOutput,
    crate::error::DeleteClientVpnRouteError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_client_vpn_route_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_client_vpn_route(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DeleteClientVpnRouteError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_customer_gateway_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteCustomerGatewayOutput,
    crate::error::DeleteCustomerGatewayError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteCustomerGatewayError::unhandled)?;
    Err(crate::error::DeleteCustomerGatewayError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_customer_gateway_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteCustomerGatewayOutput,
    crate::error::DeleteCustomerGatewayError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_customer_gateway_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_dhcp_options_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteDhcpOptionsOutput, crate::error::DeleteDhcpOptionsError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteDhcpOptionsError::unhandled)?;
    Err(crate::error::DeleteDhcpOptionsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_dhcp_options_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteDhcpOptionsOutput, crate::error::DeleteDhcpOptionsError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_dhcp_options_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_egress_only_internet_gateway_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteEgressOnlyInternetGatewayOutput,
    crate::error::DeleteEgressOnlyInternetGatewayError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteEgressOnlyInternetGatewayError::unhandled)?;
    Err(crate::error::DeleteEgressOnlyInternetGatewayError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_egress_only_internet_gateway_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteEgressOnlyInternetGatewayOutput,
    crate::error::DeleteEgressOnlyInternetGatewayError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::delete_egress_only_internet_gateway_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_delete_egress_only_internet_gateway(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DeleteEgressOnlyInternetGatewayError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_fleets_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteFleetsOutput, crate::error::DeleteFleetsError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteFleetsError::unhandled)?;
    Err(crate::error::DeleteFleetsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_fleets_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteFleetsOutput, crate::error::DeleteFleetsError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_fleets_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_fleets(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DeleteFleetsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_flow_logs_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteFlowLogsOutput, crate::error::DeleteFlowLogsError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteFlowLogsError::unhandled)?;
    Err(crate::error::DeleteFlowLogsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_flow_logs_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteFlowLogsOutput, crate::error::DeleteFlowLogsError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_flow_logs_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_flow_logs(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DeleteFlowLogsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_fpga_image_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteFpgaImageOutput, crate::error::DeleteFpgaImageError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteFpgaImageError::unhandled)?;
    Err(crate::error::DeleteFpgaImageError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_fpga_image_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteFpgaImageOutput, crate::error::DeleteFpgaImageError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_fpga_image_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_fpga_image(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DeleteFpgaImageError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_instance_event_window_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteInstanceEventWindowOutput,
    crate::error::DeleteInstanceEventWindowError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteInstanceEventWindowError::unhandled)?;
    Err(crate::error::DeleteInstanceEventWindowError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_instance_event_window_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteInstanceEventWindowOutput,
    crate::error::DeleteInstanceEventWindowError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_instance_event_window_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_instance_event_window(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DeleteInstanceEventWindowError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_internet_gateway_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteInternetGatewayOutput,
    crate::error::DeleteInternetGatewayError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteInternetGatewayError::unhandled)?;
    Err(crate::error::DeleteInternetGatewayError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_internet_gateway_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteInternetGatewayOutput,
    crate::error::DeleteInternetGatewayError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_internet_gateway_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_key_pair_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteKeyPairOutput, crate::error::DeleteKeyPairError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteKeyPairError::unhandled)?;
    Err(crate::error::DeleteKeyPairError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_key_pair_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteKeyPairOutput, crate::error::DeleteKeyPairError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_key_pair_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_launch_template_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteLaunchTemplateOutput,
    crate::error::DeleteLaunchTemplateError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteLaunchTemplateError::unhandled)?;
    Err(crate::error::DeleteLaunchTemplateError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_launch_template_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteLaunchTemplateOutput,
    crate::error::DeleteLaunchTemplateError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_launch_template_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_launch_template(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DeleteLaunchTemplateError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_launch_template_versions_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteLaunchTemplateVersionsOutput,
    crate::error::DeleteLaunchTemplateVersionsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteLaunchTemplateVersionsError::unhandled)?;
    Err(crate::error::DeleteLaunchTemplateVersionsError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_launch_template_versions_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteLaunchTemplateVersionsOutput,
    crate::error::DeleteLaunchTemplateVersionsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_launch_template_versions_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_launch_template_versions(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DeleteLaunchTemplateVersionsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_local_gateway_route_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteLocalGatewayRouteOutput,
    crate::error::DeleteLocalGatewayRouteError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteLocalGatewayRouteError::unhandled)?;
    Err(crate::error::DeleteLocalGatewayRouteError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_local_gateway_route_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteLocalGatewayRouteOutput,
    crate::error::DeleteLocalGatewayRouteError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_local_gateway_route_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_local_gateway_route(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DeleteLocalGatewayRouteError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_local_gateway_route_table_vpc_association_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteLocalGatewayRouteTableVpcAssociationOutput,
    crate::error::DeleteLocalGatewayRouteTableVpcAssociationError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteLocalGatewayRouteTableVpcAssociationError::unhandled)?;
    Err(crate::error::DeleteLocalGatewayRouteTableVpcAssociationError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_local_gateway_route_table_vpc_association_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteLocalGatewayRouteTableVpcAssociationOutput,
    crate::error::DeleteLocalGatewayRouteTableVpcAssociationError,
> {
    Ok({
        #[allow(unused_mut)]let mut output = crate::output::delete_local_gateway_route_table_vpc_association_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_local_gateway_route_table_vpc_association(response.body().as_ref(), output).map_err(crate::error::DeleteLocalGatewayRouteTableVpcAssociationError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_managed_prefix_list_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteManagedPrefixListOutput,
    crate::error::DeleteManagedPrefixListError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteManagedPrefixListError::unhandled)?;
    Err(crate::error::DeleteManagedPrefixListError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_managed_prefix_list_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteManagedPrefixListOutput,
    crate::error::DeleteManagedPrefixListError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_managed_prefix_list_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_managed_prefix_list(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DeleteManagedPrefixListError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_nat_gateway_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteNatGatewayOutput, crate::error::DeleteNatGatewayError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteNatGatewayError::unhandled)?;
    Err(crate::error::DeleteNatGatewayError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_nat_gateway_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteNatGatewayOutput, crate::error::DeleteNatGatewayError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_nat_gateway_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_nat_gateway(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DeleteNatGatewayError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_network_acl_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteNetworkAclOutput, crate::error::DeleteNetworkAclError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteNetworkAclError::unhandled)?;
    Err(crate::error::DeleteNetworkAclError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_network_acl_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteNetworkAclOutput, crate::error::DeleteNetworkAclError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_network_acl_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_network_acl_entry_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteNetworkAclEntryOutput,
    crate::error::DeleteNetworkAclEntryError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteNetworkAclEntryError::unhandled)?;
    Err(crate::error::DeleteNetworkAclEntryError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_network_acl_entry_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteNetworkAclEntryOutput,
    crate::error::DeleteNetworkAclEntryError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_network_acl_entry_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_network_insights_analysis_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteNetworkInsightsAnalysisOutput,
    crate::error::DeleteNetworkInsightsAnalysisError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteNetworkInsightsAnalysisError::unhandled)?;
    Err(crate::error::DeleteNetworkInsightsAnalysisError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_network_insights_analysis_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteNetworkInsightsAnalysisOutput,
    crate::error::DeleteNetworkInsightsAnalysisError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_network_insights_analysis_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_delete_network_insights_analysis(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DeleteNetworkInsightsAnalysisError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_network_insights_path_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteNetworkInsightsPathOutput,
    crate::error::DeleteNetworkInsightsPathError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteNetworkInsightsPathError::unhandled)?;
    Err(crate::error::DeleteNetworkInsightsPathError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_network_insights_path_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteNetworkInsightsPathOutput,
    crate::error::DeleteNetworkInsightsPathError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_network_insights_path_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_network_insights_path(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DeleteNetworkInsightsPathError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_network_interface_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteNetworkInterfaceOutput,
    crate::error::DeleteNetworkInterfaceError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteNetworkInterfaceError::unhandled)?;
    Err(crate::error::DeleteNetworkInterfaceError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_network_interface_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteNetworkInterfaceOutput,
    crate::error::DeleteNetworkInterfaceError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_network_interface_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_network_interface_permission_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteNetworkInterfacePermissionOutput,
    crate::error::DeleteNetworkInterfacePermissionError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteNetworkInterfacePermissionError::unhandled)?;
    Err(crate::error::DeleteNetworkInterfacePermissionError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_network_interface_permission_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteNetworkInterfacePermissionOutput,
    crate::error::DeleteNetworkInterfacePermissionError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::delete_network_interface_permission_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_delete_network_interface_permission(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DeleteNetworkInterfacePermissionError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_placement_group_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeletePlacementGroupOutput,
    crate::error::DeletePlacementGroupError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeletePlacementGroupError::unhandled)?;
    Err(crate::error::DeletePlacementGroupError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_placement_group_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeletePlacementGroupOutput,
    crate::error::DeletePlacementGroupError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_placement_group_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_queued_reserved_instances_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteQueuedReservedInstancesOutput,
    crate::error::DeleteQueuedReservedInstancesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteQueuedReservedInstancesError::unhandled)?;
    Err(crate::error::DeleteQueuedReservedInstancesError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_queued_reserved_instances_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteQueuedReservedInstancesOutput,
    crate::error::DeleteQueuedReservedInstancesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_queued_reserved_instances_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_delete_queued_reserved_instances(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DeleteQueuedReservedInstancesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_route_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteRouteOutput, crate::error::DeleteRouteError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteRouteError::unhandled)?;
    Err(crate::error::DeleteRouteError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_route_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteRouteOutput, crate::error::DeleteRouteError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_route_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_route_table_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteRouteTableOutput, crate::error::DeleteRouteTableError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteRouteTableError::unhandled)?;
    Err(crate::error::DeleteRouteTableError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_route_table_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteRouteTableOutput, crate::error::DeleteRouteTableError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_route_table_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_security_group_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteSecurityGroupOutput,
    crate::error::DeleteSecurityGroupError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteSecurityGroupError::unhandled)?;
    Err(crate::error::DeleteSecurityGroupError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_security_group_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteSecurityGroupOutput,
    crate::error::DeleteSecurityGroupError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_security_group_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_snapshot_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteSnapshotOutput, crate::error::DeleteSnapshotError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteSnapshotError::unhandled)?;
    Err(crate::error::DeleteSnapshotError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_snapshot_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteSnapshotOutput, crate::error::DeleteSnapshotError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_snapshot_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_spot_datafeed_subscription_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteSpotDatafeedSubscriptionOutput,
    crate::error::DeleteSpotDatafeedSubscriptionError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteSpotDatafeedSubscriptionError::unhandled)?;
    Err(crate::error::DeleteSpotDatafeedSubscriptionError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_spot_datafeed_subscription_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteSpotDatafeedSubscriptionOutput,
    crate::error::DeleteSpotDatafeedSubscriptionError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::delete_spot_datafeed_subscription_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_subnet_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteSubnetOutput, crate::error::DeleteSubnetError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteSubnetError::unhandled)?;
    Err(crate::error::DeleteSubnetError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_subnet_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteSubnetOutput, crate::error::DeleteSubnetError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_subnet_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_subnet_cidr_reservation_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteSubnetCidrReservationOutput,
    crate::error::DeleteSubnetCidrReservationError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteSubnetCidrReservationError::unhandled)?;
    Err(crate::error::DeleteSubnetCidrReservationError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_subnet_cidr_reservation_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteSubnetCidrReservationOutput,
    crate::error::DeleteSubnetCidrReservationError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_subnet_cidr_reservation_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_subnet_cidr_reservation(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DeleteSubnetCidrReservationError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_tags_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteTagsOutput, crate::error::DeleteTagsError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteTagsError::unhandled)?;
    Err(crate::error::DeleteTagsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_tags_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteTagsOutput, crate::error::DeleteTagsError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_tags_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_traffic_mirror_filter_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteTrafficMirrorFilterOutput,
    crate::error::DeleteTrafficMirrorFilterError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteTrafficMirrorFilterError::unhandled)?;
    Err(crate::error::DeleteTrafficMirrorFilterError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_traffic_mirror_filter_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteTrafficMirrorFilterOutput,
    crate::error::DeleteTrafficMirrorFilterError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_traffic_mirror_filter_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_traffic_mirror_filter(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DeleteTrafficMirrorFilterError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_traffic_mirror_filter_rule_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteTrafficMirrorFilterRuleOutput,
    crate::error::DeleteTrafficMirrorFilterRuleError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteTrafficMirrorFilterRuleError::unhandled)?;
    Err(crate::error::DeleteTrafficMirrorFilterRuleError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_traffic_mirror_filter_rule_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteTrafficMirrorFilterRuleOutput,
    crate::error::DeleteTrafficMirrorFilterRuleError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::delete_traffic_mirror_filter_rule_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_delete_traffic_mirror_filter_rule(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DeleteTrafficMirrorFilterRuleError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_traffic_mirror_session_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteTrafficMirrorSessionOutput,
    crate::error::DeleteTrafficMirrorSessionError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteTrafficMirrorSessionError::unhandled)?;
    Err(crate::error::DeleteTrafficMirrorSessionError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_traffic_mirror_session_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteTrafficMirrorSessionOutput,
    crate::error::DeleteTrafficMirrorSessionError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_traffic_mirror_session_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_traffic_mirror_session(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DeleteTrafficMirrorSessionError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_traffic_mirror_target_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteTrafficMirrorTargetOutput,
    crate::error::DeleteTrafficMirrorTargetError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteTrafficMirrorTargetError::unhandled)?;
    Err(crate::error::DeleteTrafficMirrorTargetError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_traffic_mirror_target_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteTrafficMirrorTargetOutput,
    crate::error::DeleteTrafficMirrorTargetError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_traffic_mirror_target_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_traffic_mirror_target(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DeleteTrafficMirrorTargetError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_transit_gateway_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteTransitGatewayOutput,
    crate::error::DeleteTransitGatewayError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteTransitGatewayError::unhandled)?;
    Err(crate::error::DeleteTransitGatewayError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_transit_gateway_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteTransitGatewayOutput,
    crate::error::DeleteTransitGatewayError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_transit_gateway_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_transit_gateway(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DeleteTransitGatewayError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_transit_gateway_connect_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteTransitGatewayConnectOutput,
    crate::error::DeleteTransitGatewayConnectError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteTransitGatewayConnectError::unhandled)?;
    Err(crate::error::DeleteTransitGatewayConnectError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_transit_gateway_connect_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteTransitGatewayConnectOutput,
    crate::error::DeleteTransitGatewayConnectError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_transit_gateway_connect_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_transit_gateway_connect(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DeleteTransitGatewayConnectError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_transit_gateway_connect_peer_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteTransitGatewayConnectPeerOutput,
    crate::error::DeleteTransitGatewayConnectPeerError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteTransitGatewayConnectPeerError::unhandled)?;
    Err(crate::error::DeleteTransitGatewayConnectPeerError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_transit_gateway_connect_peer_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteTransitGatewayConnectPeerOutput,
    crate::error::DeleteTransitGatewayConnectPeerError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::delete_transit_gateway_connect_peer_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_delete_transit_gateway_connect_peer(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DeleteTransitGatewayConnectPeerError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_transit_gateway_multicast_domain_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteTransitGatewayMulticastDomainOutput,
    crate::error::DeleteTransitGatewayMulticastDomainError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteTransitGatewayMulticastDomainError::unhandled)?;
    Err(crate::error::DeleteTransitGatewayMulticastDomainError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_transit_gateway_multicast_domain_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteTransitGatewayMulticastDomainOutput,
    crate::error::DeleteTransitGatewayMulticastDomainError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::delete_transit_gateway_multicast_domain_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_transit_gateway_multicast_domain(response.body().as_ref(), output).map_err(crate::error::DeleteTransitGatewayMulticastDomainError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_transit_gateway_peering_attachment_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteTransitGatewayPeeringAttachmentOutput,
    crate::error::DeleteTransitGatewayPeeringAttachmentError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteTransitGatewayPeeringAttachmentError::unhandled)?;
    Err(crate::error::DeleteTransitGatewayPeeringAttachmentError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_transit_gateway_peering_attachment_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteTransitGatewayPeeringAttachmentOutput,
    crate::error::DeleteTransitGatewayPeeringAttachmentError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::delete_transit_gateway_peering_attachment_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_transit_gateway_peering_attachment(response.body().as_ref(), output).map_err(crate::error::DeleteTransitGatewayPeeringAttachmentError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_transit_gateway_prefix_list_reference_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteTransitGatewayPrefixListReferenceOutput,
    crate::error::DeleteTransitGatewayPrefixListReferenceError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteTransitGatewayPrefixListReferenceError::unhandled)?;
    Err(crate::error::DeleteTransitGatewayPrefixListReferenceError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_transit_gateway_prefix_list_reference_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteTransitGatewayPrefixListReferenceOutput,
    crate::error::DeleteTransitGatewayPrefixListReferenceError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::delete_transit_gateway_prefix_list_reference_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_transit_gateway_prefix_list_reference(response.body().as_ref(), output).map_err(crate::error::DeleteTransitGatewayPrefixListReferenceError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_transit_gateway_route_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteTransitGatewayRouteOutput,
    crate::error::DeleteTransitGatewayRouteError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteTransitGatewayRouteError::unhandled)?;
    Err(crate::error::DeleteTransitGatewayRouteError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_transit_gateway_route_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteTransitGatewayRouteOutput,
    crate::error::DeleteTransitGatewayRouteError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_transit_gateway_route_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_transit_gateway_route(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DeleteTransitGatewayRouteError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_transit_gateway_route_table_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteTransitGatewayRouteTableOutput,
    crate::error::DeleteTransitGatewayRouteTableError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteTransitGatewayRouteTableError::unhandled)?;
    Err(crate::error::DeleteTransitGatewayRouteTableError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_transit_gateway_route_table_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteTransitGatewayRouteTableOutput,
    crate::error::DeleteTransitGatewayRouteTableError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::delete_transit_gateway_route_table_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_delete_transit_gateway_route_table(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DeleteTransitGatewayRouteTableError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_transit_gateway_vpc_attachment_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteTransitGatewayVpcAttachmentOutput,
    crate::error::DeleteTransitGatewayVpcAttachmentError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteTransitGatewayVpcAttachmentError::unhandled)?;
    Err(crate::error::DeleteTransitGatewayVpcAttachmentError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_transit_gateway_vpc_attachment_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteTransitGatewayVpcAttachmentOutput,
    crate::error::DeleteTransitGatewayVpcAttachmentError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::delete_transit_gateway_vpc_attachment_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_transit_gateway_vpc_attachment(response.body().as_ref(), output).map_err(crate::error::DeleteTransitGatewayVpcAttachmentError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_volume_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteVolumeOutput, crate::error::DeleteVolumeError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteVolumeError::unhandled)?;
    Err(crate::error::DeleteVolumeError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_volume_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteVolumeOutput, crate::error::DeleteVolumeError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_volume_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_vpc_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteVpcOutput, crate::error::DeleteVpcError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteVpcError::unhandled)?;
    Err(crate::error::DeleteVpcError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_vpc_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteVpcOutput, crate::error::DeleteVpcError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_vpc_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_vpc_endpoint_connection_notifications_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteVpcEndpointConnectionNotificationsOutput,
    crate::error::DeleteVpcEndpointConnectionNotificationsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteVpcEndpointConnectionNotificationsError::unhandled)?;
    Err(crate::error::DeleteVpcEndpointConnectionNotificationsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_vpc_endpoint_connection_notifications_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteVpcEndpointConnectionNotificationsOutput,
    crate::error::DeleteVpcEndpointConnectionNotificationsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::delete_vpc_endpoint_connection_notifications_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_vpc_endpoint_connection_notifications(response.body().as_ref(), output).map_err(crate::error::DeleteVpcEndpointConnectionNotificationsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_vpc_endpoints_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteVpcEndpointsOutput,
    crate::error::DeleteVpcEndpointsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteVpcEndpointsError::unhandled)?;
    Err(crate::error::DeleteVpcEndpointsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_vpc_endpoints_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteVpcEndpointsOutput,
    crate::error::DeleteVpcEndpointsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_vpc_endpoints_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_vpc_endpoints(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DeleteVpcEndpointsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_vpc_endpoint_service_configurations_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteVpcEndpointServiceConfigurationsOutput,
    crate::error::DeleteVpcEndpointServiceConfigurationsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteVpcEndpointServiceConfigurationsError::unhandled)?;
    Err(crate::error::DeleteVpcEndpointServiceConfigurationsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_vpc_endpoint_service_configurations_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteVpcEndpointServiceConfigurationsOutput,
    crate::error::DeleteVpcEndpointServiceConfigurationsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::delete_vpc_endpoint_service_configurations_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_vpc_endpoint_service_configurations(response.body().as_ref(), output).map_err(crate::error::DeleteVpcEndpointServiceConfigurationsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_vpc_peering_connection_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteVpcPeeringConnectionOutput,
    crate::error::DeleteVpcPeeringConnectionError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteVpcPeeringConnectionError::unhandled)?;
    Err(crate::error::DeleteVpcPeeringConnectionError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_vpc_peering_connection_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteVpcPeeringConnectionOutput,
    crate::error::DeleteVpcPeeringConnectionError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_vpc_peering_connection_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_delete_vpc_peering_connection(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DeleteVpcPeeringConnectionError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_vpn_connection_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteVpnConnectionOutput,
    crate::error::DeleteVpnConnectionError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteVpnConnectionError::unhandled)?;
    Err(crate::error::DeleteVpnConnectionError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_vpn_connection_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteVpnConnectionOutput,
    crate::error::DeleteVpnConnectionError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_vpn_connection_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_vpn_connection_route_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteVpnConnectionRouteOutput,
    crate::error::DeleteVpnConnectionRouteError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteVpnConnectionRouteError::unhandled)?;
    Err(crate::error::DeleteVpnConnectionRouteError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_vpn_connection_route_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteVpnConnectionRouteOutput,
    crate::error::DeleteVpnConnectionRouteError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_vpn_connection_route_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_vpn_gateway_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteVpnGatewayOutput, crate::error::DeleteVpnGatewayError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteVpnGatewayError::unhandled)?;
    Err(crate::error::DeleteVpnGatewayError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_vpn_gateway_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteVpnGatewayOutput, crate::error::DeleteVpnGatewayError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_vpn_gateway_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_deprovision_byoip_cidr_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeprovisionByoipCidrOutput,
    crate::error::DeprovisionByoipCidrError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeprovisionByoipCidrError::unhandled)?;
    Err(crate::error::DeprovisionByoipCidrError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_deprovision_byoip_cidr_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeprovisionByoipCidrOutput,
    crate::error::DeprovisionByoipCidrError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::deprovision_byoip_cidr_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_deprovision_byoip_cidr(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DeprovisionByoipCidrError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_deregister_image_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeregisterImageOutput, crate::error::DeregisterImageError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeregisterImageError::unhandled)?;
    Err(crate::error::DeregisterImageError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_deregister_image_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeregisterImageOutput, crate::error::DeregisterImageError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::deregister_image_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_deregister_instance_event_notification_attributes_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeregisterInstanceEventNotificationAttributesOutput,
    crate::error::DeregisterInstanceEventNotificationAttributesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeregisterInstanceEventNotificationAttributesError::unhandled)?;
    Err(crate::error::DeregisterInstanceEventNotificationAttributesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_deregister_instance_event_notification_attributes_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeregisterInstanceEventNotificationAttributesOutput,
    crate::error::DeregisterInstanceEventNotificationAttributesError,
> {
    Ok({
        #[allow(unused_mut)]let mut output = crate::output::deregister_instance_event_notification_attributes_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_deregister_instance_event_notification_attributes(response.body().as_ref(), output).map_err(crate::error::DeregisterInstanceEventNotificationAttributesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_deregister_transit_gateway_multicast_group_members_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeregisterTransitGatewayMulticastGroupMembersOutput,
    crate::error::DeregisterTransitGatewayMulticastGroupMembersError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeregisterTransitGatewayMulticastGroupMembersError::unhandled)?;
    Err(crate::error::DeregisterTransitGatewayMulticastGroupMembersError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_deregister_transit_gateway_multicast_group_members_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeregisterTransitGatewayMulticastGroupMembersOutput,
    crate::error::DeregisterTransitGatewayMulticastGroupMembersError,
> {
    Ok({
        #[allow(unused_mut)]let mut output = crate::output::deregister_transit_gateway_multicast_group_members_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_deregister_transit_gateway_multicast_group_members(response.body().as_ref(), output).map_err(crate::error::DeregisterTransitGatewayMulticastGroupMembersError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_deregister_transit_gateway_multicast_group_sources_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeregisterTransitGatewayMulticastGroupSourcesOutput,
    crate::error::DeregisterTransitGatewayMulticastGroupSourcesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeregisterTransitGatewayMulticastGroupSourcesError::unhandled)?;
    Err(crate::error::DeregisterTransitGatewayMulticastGroupSourcesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_deregister_transit_gateway_multicast_group_sources_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeregisterTransitGatewayMulticastGroupSourcesOutput,
    crate::error::DeregisterTransitGatewayMulticastGroupSourcesError,
> {
    Ok({
        #[allow(unused_mut)]let mut output = crate::output::deregister_transit_gateway_multicast_group_sources_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_deregister_transit_gateway_multicast_group_sources(response.body().as_ref(), output).map_err(crate::error::DeregisterTransitGatewayMulticastGroupSourcesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_account_attributes_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeAccountAttributesOutput,
    crate::error::DescribeAccountAttributesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeAccountAttributesError::unhandled)?;
    Err(crate::error::DescribeAccountAttributesError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_account_attributes_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeAccountAttributesOutput,
    crate::error::DescribeAccountAttributesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_account_attributes_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_account_attributes(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeAccountAttributesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_addresses_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeAddressesOutput, crate::error::DescribeAddressesError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeAddressesError::unhandled)?;
    Err(crate::error::DescribeAddressesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_addresses_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeAddressesOutput, crate::error::DescribeAddressesError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_addresses_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_addresses(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeAddressesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_addresses_attribute_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeAddressesAttributeOutput,
    crate::error::DescribeAddressesAttributeError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeAddressesAttributeError::unhandled)?;
    Err(crate::error::DescribeAddressesAttributeError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_addresses_attribute_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeAddressesAttributeOutput,
    crate::error::DescribeAddressesAttributeError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_addresses_attribute_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_addresses_attribute(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeAddressesAttributeError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_aggregate_id_format_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeAggregateIdFormatOutput,
    crate::error::DescribeAggregateIdFormatError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeAggregateIdFormatError::unhandled)?;
    Err(crate::error::DescribeAggregateIdFormatError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_aggregate_id_format_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeAggregateIdFormatOutput,
    crate::error::DescribeAggregateIdFormatError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_aggregate_id_format_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_aggregate_id_format(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeAggregateIdFormatError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_availability_zones_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeAvailabilityZonesOutput,
    crate::error::DescribeAvailabilityZonesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeAvailabilityZonesError::unhandled)?;
    Err(crate::error::DescribeAvailabilityZonesError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_availability_zones_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeAvailabilityZonesOutput,
    crate::error::DescribeAvailabilityZonesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_availability_zones_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_availability_zones(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeAvailabilityZonesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_bundle_tasks_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeBundleTasksOutput,
    crate::error::DescribeBundleTasksError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeBundleTasksError::unhandled)?;
    Err(crate::error::DescribeBundleTasksError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_bundle_tasks_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeBundleTasksOutput,
    crate::error::DescribeBundleTasksError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_bundle_tasks_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_bundle_tasks(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeBundleTasksError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_byoip_cidrs_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeByoipCidrsOutput,
    crate::error::DescribeByoipCidrsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeByoipCidrsError::unhandled)?;
    Err(crate::error::DescribeByoipCidrsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_byoip_cidrs_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeByoipCidrsOutput,
    crate::error::DescribeByoipCidrsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_byoip_cidrs_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_byoip_cidrs(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeByoipCidrsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_capacity_reservation_fleets_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeCapacityReservationFleetsOutput,
    crate::error::DescribeCapacityReservationFleetsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeCapacityReservationFleetsError::unhandled)?;
    Err(crate::error::DescribeCapacityReservationFleetsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_capacity_reservation_fleets_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeCapacityReservationFleetsOutput,
    crate::error::DescribeCapacityReservationFleetsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_capacity_reservation_fleets_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_describe_capacity_reservation_fleets(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DescribeCapacityReservationFleetsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_capacity_reservations_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeCapacityReservationsOutput,
    crate::error::DescribeCapacityReservationsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeCapacityReservationsError::unhandled)?;
    Err(crate::error::DescribeCapacityReservationsError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_capacity_reservations_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeCapacityReservationsOutput,
    crate::error::DescribeCapacityReservationsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_capacity_reservations_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_capacity_reservations(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeCapacityReservationsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_carrier_gateways_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeCarrierGatewaysOutput,
    crate::error::DescribeCarrierGatewaysError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeCarrierGatewaysError::unhandled)?;
    Err(crate::error::DescribeCarrierGatewaysError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_carrier_gateways_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeCarrierGatewaysOutput,
    crate::error::DescribeCarrierGatewaysError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_carrier_gateways_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_carrier_gateways(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeCarrierGatewaysError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_classic_link_instances_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeClassicLinkInstancesOutput,
    crate::error::DescribeClassicLinkInstancesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeClassicLinkInstancesError::unhandled)?;
    Err(crate::error::DescribeClassicLinkInstancesError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_classic_link_instances_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeClassicLinkInstancesOutput,
    crate::error::DescribeClassicLinkInstancesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_classic_link_instances_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_classic_link_instances(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeClassicLinkInstancesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_client_vpn_authorization_rules_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeClientVpnAuthorizationRulesOutput,
    crate::error::DescribeClientVpnAuthorizationRulesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeClientVpnAuthorizationRulesError::unhandled)?;
    Err(crate::error::DescribeClientVpnAuthorizationRulesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_client_vpn_authorization_rules_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeClientVpnAuthorizationRulesOutput,
    crate::error::DescribeClientVpnAuthorizationRulesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_client_vpn_authorization_rules_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_client_vpn_authorization_rules(response.body().as_ref(), output).map_err(crate::error::DescribeClientVpnAuthorizationRulesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_client_vpn_connections_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeClientVpnConnectionsOutput,
    crate::error::DescribeClientVpnConnectionsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeClientVpnConnectionsError::unhandled)?;
    Err(crate::error::DescribeClientVpnConnectionsError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_client_vpn_connections_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeClientVpnConnectionsOutput,
    crate::error::DescribeClientVpnConnectionsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_client_vpn_connections_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_client_vpn_connections(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeClientVpnConnectionsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_client_vpn_endpoints_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeClientVpnEndpointsOutput,
    crate::error::DescribeClientVpnEndpointsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeClientVpnEndpointsError::unhandled)?;
    Err(crate::error::DescribeClientVpnEndpointsError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_client_vpn_endpoints_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeClientVpnEndpointsOutput,
    crate::error::DescribeClientVpnEndpointsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_client_vpn_endpoints_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_client_vpn_endpoints(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeClientVpnEndpointsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_client_vpn_routes_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeClientVpnRoutesOutput,
    crate::error::DescribeClientVpnRoutesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeClientVpnRoutesError::unhandled)?;
    Err(crate::error::DescribeClientVpnRoutesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_client_vpn_routes_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeClientVpnRoutesOutput,
    crate::error::DescribeClientVpnRoutesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_client_vpn_routes_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_client_vpn_routes(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeClientVpnRoutesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_client_vpn_target_networks_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeClientVpnTargetNetworksOutput,
    crate::error::DescribeClientVpnTargetNetworksError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeClientVpnTargetNetworksError::unhandled)?;
    Err(crate::error::DescribeClientVpnTargetNetworksError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_client_vpn_target_networks_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeClientVpnTargetNetworksOutput,
    crate::error::DescribeClientVpnTargetNetworksError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_client_vpn_target_networks_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_describe_client_vpn_target_networks(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DescribeClientVpnTargetNetworksError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_coip_pools_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeCoipPoolsOutput, crate::error::DescribeCoipPoolsError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeCoipPoolsError::unhandled)?;
    Err(crate::error::DescribeCoipPoolsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_coip_pools_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeCoipPoolsOutput, crate::error::DescribeCoipPoolsError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_coip_pools_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_coip_pools(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeCoipPoolsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_conversion_tasks_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeConversionTasksOutput,
    crate::error::DescribeConversionTasksError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeConversionTasksError::unhandled)?;
    Err(crate::error::DescribeConversionTasksError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_conversion_tasks_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeConversionTasksOutput,
    crate::error::DescribeConversionTasksError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_conversion_tasks_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_conversion_tasks(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeConversionTasksError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_customer_gateways_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeCustomerGatewaysOutput,
    crate::error::DescribeCustomerGatewaysError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeCustomerGatewaysError::unhandled)?;
    Err(crate::error::DescribeCustomerGatewaysError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_customer_gateways_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeCustomerGatewaysOutput,
    crate::error::DescribeCustomerGatewaysError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_customer_gateways_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_customer_gateways(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeCustomerGatewaysError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_dhcp_options_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeDhcpOptionsOutput,
    crate::error::DescribeDhcpOptionsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeDhcpOptionsError::unhandled)?;
    Err(crate::error::DescribeDhcpOptionsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_dhcp_options_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeDhcpOptionsOutput,
    crate::error::DescribeDhcpOptionsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_dhcp_options_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_dhcp_options(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeDhcpOptionsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_egress_only_internet_gateways_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeEgressOnlyInternetGatewaysOutput,
    crate::error::DescribeEgressOnlyInternetGatewaysError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeEgressOnlyInternetGatewaysError::unhandled)?;
    Err(crate::error::DescribeEgressOnlyInternetGatewaysError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_egress_only_internet_gateways_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeEgressOnlyInternetGatewaysOutput,
    crate::error::DescribeEgressOnlyInternetGatewaysError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_egress_only_internet_gateways_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_egress_only_internet_gateways(response.body().as_ref(), output).map_err(crate::error::DescribeEgressOnlyInternetGatewaysError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_elastic_gpus_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeElasticGpusOutput,
    crate::error::DescribeElasticGpusError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeElasticGpusError::unhandled)?;
    Err(crate::error::DescribeElasticGpusError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_elastic_gpus_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeElasticGpusOutput,
    crate::error::DescribeElasticGpusError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_elastic_gpus_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_elastic_gpus(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeElasticGpusError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_export_image_tasks_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeExportImageTasksOutput,
    crate::error::DescribeExportImageTasksError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeExportImageTasksError::unhandled)?;
    Err(crate::error::DescribeExportImageTasksError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_export_image_tasks_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeExportImageTasksOutput,
    crate::error::DescribeExportImageTasksError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_export_image_tasks_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_export_image_tasks(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeExportImageTasksError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_export_tasks_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeExportTasksOutput,
    crate::error::DescribeExportTasksError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeExportTasksError::unhandled)?;
    Err(crate::error::DescribeExportTasksError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_export_tasks_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeExportTasksOutput,
    crate::error::DescribeExportTasksError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_export_tasks_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_export_tasks(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeExportTasksError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_fast_snapshot_restores_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeFastSnapshotRestoresOutput,
    crate::error::DescribeFastSnapshotRestoresError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeFastSnapshotRestoresError::unhandled)?;
    Err(crate::error::DescribeFastSnapshotRestoresError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_fast_snapshot_restores_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeFastSnapshotRestoresOutput,
    crate::error::DescribeFastSnapshotRestoresError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_fast_snapshot_restores_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_fast_snapshot_restores(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeFastSnapshotRestoresError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_fleet_history_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeFleetHistoryOutput,
    crate::error::DescribeFleetHistoryError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeFleetHistoryError::unhandled)?;
    Err(crate::error::DescribeFleetHistoryError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_fleet_history_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeFleetHistoryOutput,
    crate::error::DescribeFleetHistoryError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_fleet_history_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_fleet_history(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeFleetHistoryError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_fleet_instances_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeFleetInstancesOutput,
    crate::error::DescribeFleetInstancesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeFleetInstancesError::unhandled)?;
    Err(crate::error::DescribeFleetInstancesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_fleet_instances_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeFleetInstancesOutput,
    crate::error::DescribeFleetInstancesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_fleet_instances_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_fleet_instances(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeFleetInstancesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_fleets_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeFleetsOutput, crate::error::DescribeFleetsError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeFleetsError::unhandled)?;
    Err(crate::error::DescribeFleetsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_fleets_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeFleetsOutput, crate::error::DescribeFleetsError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_fleets_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_fleets(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeFleetsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_flow_logs_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeFlowLogsOutput, crate::error::DescribeFlowLogsError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeFlowLogsError::unhandled)?;
    Err(crate::error::DescribeFlowLogsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_flow_logs_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeFlowLogsOutput, crate::error::DescribeFlowLogsError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_flow_logs_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_flow_logs(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeFlowLogsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_fpga_image_attribute_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeFpgaImageAttributeOutput,
    crate::error::DescribeFpgaImageAttributeError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeFpgaImageAttributeError::unhandled)?;
    Err(crate::error::DescribeFpgaImageAttributeError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_fpga_image_attribute_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeFpgaImageAttributeOutput,
    crate::error::DescribeFpgaImageAttributeError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_fpga_image_attribute_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_fpga_image_attribute(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeFpgaImageAttributeError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_fpga_images_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeFpgaImagesOutput,
    crate::error::DescribeFpgaImagesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeFpgaImagesError::unhandled)?;
    Err(crate::error::DescribeFpgaImagesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_fpga_images_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeFpgaImagesOutput,
    crate::error::DescribeFpgaImagesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_fpga_images_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_fpga_images(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeFpgaImagesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_host_reservation_offerings_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeHostReservationOfferingsOutput,
    crate::error::DescribeHostReservationOfferingsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeHostReservationOfferingsError::unhandled)?;
    Err(crate::error::DescribeHostReservationOfferingsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_host_reservation_offerings_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeHostReservationOfferingsOutput,
    crate::error::DescribeHostReservationOfferingsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_host_reservation_offerings_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_describe_host_reservation_offerings(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DescribeHostReservationOfferingsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_host_reservations_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeHostReservationsOutput,
    crate::error::DescribeHostReservationsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeHostReservationsError::unhandled)?;
    Err(crate::error::DescribeHostReservationsError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_host_reservations_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeHostReservationsOutput,
    crate::error::DescribeHostReservationsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_host_reservations_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_host_reservations(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeHostReservationsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_hosts_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeHostsOutput, crate::error::DescribeHostsError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeHostsError::unhandled)?;
    Err(crate::error::DescribeHostsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_hosts_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeHostsOutput, crate::error::DescribeHostsError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_hosts_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_hosts(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeHostsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_iam_instance_profile_associations_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeIamInstanceProfileAssociationsOutput,
    crate::error::DescribeIamInstanceProfileAssociationsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeIamInstanceProfileAssociationsError::unhandled)?;
    Err(crate::error::DescribeIamInstanceProfileAssociationsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_iam_instance_profile_associations_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeIamInstanceProfileAssociationsOutput,
    crate::error::DescribeIamInstanceProfileAssociationsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_iam_instance_profile_associations_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_iam_instance_profile_associations(response.body().as_ref(), output).map_err(crate::error::DescribeIamInstanceProfileAssociationsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_identity_id_format_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeIdentityIdFormatOutput,
    crate::error::DescribeIdentityIdFormatError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeIdentityIdFormatError::unhandled)?;
    Err(crate::error::DescribeIdentityIdFormatError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_identity_id_format_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeIdentityIdFormatOutput,
    crate::error::DescribeIdentityIdFormatError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_identity_id_format_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_identity_id_format(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeIdentityIdFormatError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_id_format_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeIdFormatOutput, crate::error::DescribeIdFormatError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeIdFormatError::unhandled)?;
    Err(crate::error::DescribeIdFormatError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_id_format_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeIdFormatOutput, crate::error::DescribeIdFormatError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_id_format_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_id_format(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeIdFormatError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_image_attribute_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeImageAttributeOutput,
    crate::error::DescribeImageAttributeError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeImageAttributeError::unhandled)?;
    Err(crate::error::DescribeImageAttributeError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_image_attribute_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeImageAttributeOutput,
    crate::error::DescribeImageAttributeError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_image_attribute_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_image_attribute(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeImageAttributeError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_images_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeImagesOutput, crate::error::DescribeImagesError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeImagesError::unhandled)?;
    Err(crate::error::DescribeImagesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_images_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeImagesOutput, crate::error::DescribeImagesError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_images_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_images(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeImagesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_import_image_tasks_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeImportImageTasksOutput,
    crate::error::DescribeImportImageTasksError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeImportImageTasksError::unhandled)?;
    Err(crate::error::DescribeImportImageTasksError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_import_image_tasks_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeImportImageTasksOutput,
    crate::error::DescribeImportImageTasksError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_import_image_tasks_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_import_image_tasks(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeImportImageTasksError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_import_snapshot_tasks_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeImportSnapshotTasksOutput,
    crate::error::DescribeImportSnapshotTasksError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeImportSnapshotTasksError::unhandled)?;
    Err(crate::error::DescribeImportSnapshotTasksError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_import_snapshot_tasks_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeImportSnapshotTasksOutput,
    crate::error::DescribeImportSnapshotTasksError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_import_snapshot_tasks_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_import_snapshot_tasks(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeImportSnapshotTasksError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_instance_attribute_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeInstanceAttributeOutput,
    crate::error::DescribeInstanceAttributeError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeInstanceAttributeError::unhandled)?;
    Err(crate::error::DescribeInstanceAttributeError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_instance_attribute_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeInstanceAttributeOutput,
    crate::error::DescribeInstanceAttributeError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_instance_attribute_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_instance_attribute(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeInstanceAttributeError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_instance_credit_specifications_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeInstanceCreditSpecificationsOutput,
    crate::error::DescribeInstanceCreditSpecificationsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeInstanceCreditSpecificationsError::unhandled)?;
    Err(crate::error::DescribeInstanceCreditSpecificationsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_instance_credit_specifications_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeInstanceCreditSpecificationsOutput,
    crate::error::DescribeInstanceCreditSpecificationsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_instance_credit_specifications_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_instance_credit_specifications(response.body().as_ref(), output).map_err(crate::error::DescribeInstanceCreditSpecificationsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_instance_event_notification_attributes_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeInstanceEventNotificationAttributesOutput,
    crate::error::DescribeInstanceEventNotificationAttributesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeInstanceEventNotificationAttributesError::unhandled)?;
    Err(crate::error::DescribeInstanceEventNotificationAttributesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_instance_event_notification_attributes_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeInstanceEventNotificationAttributesOutput,
    crate::error::DescribeInstanceEventNotificationAttributesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_instance_event_notification_attributes_output::Builder::default(
            );
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_instance_event_notification_attributes(response.body().as_ref(), output).map_err(crate::error::DescribeInstanceEventNotificationAttributesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_instance_event_windows_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeInstanceEventWindowsOutput,
    crate::error::DescribeInstanceEventWindowsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeInstanceEventWindowsError::unhandled)?;
    Err(crate::error::DescribeInstanceEventWindowsError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_instance_event_windows_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeInstanceEventWindowsOutput,
    crate::error::DescribeInstanceEventWindowsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_instance_event_windows_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_instance_event_windows(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeInstanceEventWindowsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_instances_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeInstancesOutput, crate::error::DescribeInstancesError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeInstancesError::unhandled)?;
    Err(crate::error::DescribeInstancesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_instances_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeInstancesOutput, crate::error::DescribeInstancesError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_instances_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_instances(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeInstancesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_instance_status_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeInstanceStatusOutput,
    crate::error::DescribeInstanceStatusError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeInstanceStatusError::unhandled)?;
    Err(crate::error::DescribeInstanceStatusError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_instance_status_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeInstanceStatusOutput,
    crate::error::DescribeInstanceStatusError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_instance_status_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_instance_status(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeInstanceStatusError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_instance_type_offerings_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeInstanceTypeOfferingsOutput,
    crate::error::DescribeInstanceTypeOfferingsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeInstanceTypeOfferingsError::unhandled)?;
    Err(crate::error::DescribeInstanceTypeOfferingsError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_instance_type_offerings_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeInstanceTypeOfferingsOutput,
    crate::error::DescribeInstanceTypeOfferingsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_instance_type_offerings_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_describe_instance_type_offerings(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DescribeInstanceTypeOfferingsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_instance_types_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeInstanceTypesOutput,
    crate::error::DescribeInstanceTypesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeInstanceTypesError::unhandled)?;
    Err(crate::error::DescribeInstanceTypesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_instance_types_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeInstanceTypesOutput,
    crate::error::DescribeInstanceTypesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_instance_types_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_instance_types(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeInstanceTypesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_internet_gateways_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeInternetGatewaysOutput,
    crate::error::DescribeInternetGatewaysError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeInternetGatewaysError::unhandled)?;
    Err(crate::error::DescribeInternetGatewaysError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_internet_gateways_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeInternetGatewaysOutput,
    crate::error::DescribeInternetGatewaysError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_internet_gateways_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_internet_gateways(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeInternetGatewaysError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_ipv6_pools_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeIpv6PoolsOutput, crate::error::DescribeIpv6PoolsError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeIpv6PoolsError::unhandled)?;
    Err(crate::error::DescribeIpv6PoolsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_ipv6_pools_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeIpv6PoolsOutput, crate::error::DescribeIpv6PoolsError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_ipv6_pools_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_ipv6_pools(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeIpv6PoolsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_key_pairs_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeKeyPairsOutput, crate::error::DescribeKeyPairsError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeKeyPairsError::unhandled)?;
    Err(crate::error::DescribeKeyPairsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_key_pairs_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeKeyPairsOutput, crate::error::DescribeKeyPairsError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_key_pairs_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_key_pairs(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeKeyPairsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_launch_templates_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeLaunchTemplatesOutput,
    crate::error::DescribeLaunchTemplatesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeLaunchTemplatesError::unhandled)?;
    Err(crate::error::DescribeLaunchTemplatesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_launch_templates_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeLaunchTemplatesOutput,
    crate::error::DescribeLaunchTemplatesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_launch_templates_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_launch_templates(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeLaunchTemplatesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_launch_template_versions_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeLaunchTemplateVersionsOutput,
    crate::error::DescribeLaunchTemplateVersionsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeLaunchTemplateVersionsError::unhandled)?;
    Err(crate::error::DescribeLaunchTemplateVersionsError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_launch_template_versions_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeLaunchTemplateVersionsOutput,
    crate::error::DescribeLaunchTemplateVersionsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_launch_template_versions_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_describe_launch_template_versions(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DescribeLaunchTemplateVersionsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_local_gateway_route_tables_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeLocalGatewayRouteTablesOutput,
    crate::error::DescribeLocalGatewayRouteTablesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeLocalGatewayRouteTablesError::unhandled)?;
    Err(crate::error::DescribeLocalGatewayRouteTablesError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_local_gateway_route_tables_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeLocalGatewayRouteTablesOutput,
    crate::error::DescribeLocalGatewayRouteTablesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_local_gateway_route_tables_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_describe_local_gateway_route_tables(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DescribeLocalGatewayRouteTablesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_local_gateway_route_table_virtual_interface_group_associations_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput,
    crate::error::DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response).map_err(crate::error::DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsError::unhandled)?;
    Err(
        crate::error::DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsError::generic(
            generic,
        ),
    )
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_local_gateway_route_table_virtual_interface_group_associations_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput,
    crate::error::DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsError,
> {
    Ok({
        #[allow(unused_mut)]let mut output = crate::output::describe_local_gateway_route_table_virtual_interface_group_associations_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_local_gateway_route_table_virtual_interface_group_associations(response.body().as_ref(), output).map_err(crate::error::DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_local_gateway_route_table_vpc_associations_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeLocalGatewayRouteTableVpcAssociationsOutput,
    crate::error::DescribeLocalGatewayRouteTableVpcAssociationsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeLocalGatewayRouteTableVpcAssociationsError::unhandled)?;
    Err(crate::error::DescribeLocalGatewayRouteTableVpcAssociationsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_local_gateway_route_table_vpc_associations_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeLocalGatewayRouteTableVpcAssociationsOutput,
    crate::error::DescribeLocalGatewayRouteTableVpcAssociationsError,
> {
    Ok({
        #[allow(unused_mut)]let mut output = crate::output::describe_local_gateway_route_table_vpc_associations_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_local_gateway_route_table_vpc_associations(response.body().as_ref(), output).map_err(crate::error::DescribeLocalGatewayRouteTableVpcAssociationsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_local_gateways_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeLocalGatewaysOutput,
    crate::error::DescribeLocalGatewaysError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeLocalGatewaysError::unhandled)?;
    Err(crate::error::DescribeLocalGatewaysError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_local_gateways_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeLocalGatewaysOutput,
    crate::error::DescribeLocalGatewaysError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_local_gateways_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_local_gateways(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeLocalGatewaysError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_local_gateway_virtual_interface_groups_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeLocalGatewayVirtualInterfaceGroupsOutput,
    crate::error::DescribeLocalGatewayVirtualInterfaceGroupsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeLocalGatewayVirtualInterfaceGroupsError::unhandled)?;
    Err(crate::error::DescribeLocalGatewayVirtualInterfaceGroupsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_local_gateway_virtual_interface_groups_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeLocalGatewayVirtualInterfaceGroupsOutput,
    crate::error::DescribeLocalGatewayVirtualInterfaceGroupsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_local_gateway_virtual_interface_groups_output::Builder::default(
            );
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_local_gateway_virtual_interface_groups(response.body().as_ref(), output).map_err(crate::error::DescribeLocalGatewayVirtualInterfaceGroupsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_local_gateway_virtual_interfaces_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeLocalGatewayVirtualInterfacesOutput,
    crate::error::DescribeLocalGatewayVirtualInterfacesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeLocalGatewayVirtualInterfacesError::unhandled)?;
    Err(crate::error::DescribeLocalGatewayVirtualInterfacesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_local_gateway_virtual_interfaces_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeLocalGatewayVirtualInterfacesOutput,
    crate::error::DescribeLocalGatewayVirtualInterfacesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_local_gateway_virtual_interfaces_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_local_gateway_virtual_interfaces(response.body().as_ref(), output).map_err(crate::error::DescribeLocalGatewayVirtualInterfacesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_managed_prefix_lists_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeManagedPrefixListsOutput,
    crate::error::DescribeManagedPrefixListsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeManagedPrefixListsError::unhandled)?;
    Err(crate::error::DescribeManagedPrefixListsError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_managed_prefix_lists_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeManagedPrefixListsOutput,
    crate::error::DescribeManagedPrefixListsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_managed_prefix_lists_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_managed_prefix_lists(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeManagedPrefixListsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_moving_addresses_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeMovingAddressesOutput,
    crate::error::DescribeMovingAddressesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeMovingAddressesError::unhandled)?;
    Err(crate::error::DescribeMovingAddressesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_moving_addresses_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeMovingAddressesOutput,
    crate::error::DescribeMovingAddressesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_moving_addresses_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_moving_addresses(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeMovingAddressesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_nat_gateways_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeNatGatewaysOutput,
    crate::error::DescribeNatGatewaysError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeNatGatewaysError::unhandled)?;
    Err(crate::error::DescribeNatGatewaysError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_nat_gateways_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeNatGatewaysOutput,
    crate::error::DescribeNatGatewaysError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_nat_gateways_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_nat_gateways(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeNatGatewaysError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_network_acls_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeNetworkAclsOutput,
    crate::error::DescribeNetworkAclsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeNetworkAclsError::unhandled)?;
    Err(crate::error::DescribeNetworkAclsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_network_acls_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeNetworkAclsOutput,
    crate::error::DescribeNetworkAclsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_network_acls_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_network_acls(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeNetworkAclsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_network_insights_analyses_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeNetworkInsightsAnalysesOutput,
    crate::error::DescribeNetworkInsightsAnalysesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeNetworkInsightsAnalysesError::unhandled)?;
    Err(crate::error::DescribeNetworkInsightsAnalysesError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_network_insights_analyses_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeNetworkInsightsAnalysesOutput,
    crate::error::DescribeNetworkInsightsAnalysesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_network_insights_analyses_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_describe_network_insights_analyses(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DescribeNetworkInsightsAnalysesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_network_insights_paths_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeNetworkInsightsPathsOutput,
    crate::error::DescribeNetworkInsightsPathsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeNetworkInsightsPathsError::unhandled)?;
    Err(crate::error::DescribeNetworkInsightsPathsError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_network_insights_paths_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeNetworkInsightsPathsOutput,
    crate::error::DescribeNetworkInsightsPathsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_network_insights_paths_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_network_insights_paths(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeNetworkInsightsPathsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_network_interface_attribute_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeNetworkInterfaceAttributeOutput,
    crate::error::DescribeNetworkInterfaceAttributeError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeNetworkInterfaceAttributeError::unhandled)?;
    Err(crate::error::DescribeNetworkInterfaceAttributeError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_network_interface_attribute_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeNetworkInterfaceAttributeOutput,
    crate::error::DescribeNetworkInterfaceAttributeError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_network_interface_attribute_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_describe_network_interface_attribute(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DescribeNetworkInterfaceAttributeError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_network_interface_permissions_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeNetworkInterfacePermissionsOutput,
    crate::error::DescribeNetworkInterfacePermissionsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeNetworkInterfacePermissionsError::unhandled)?;
    Err(crate::error::DescribeNetworkInterfacePermissionsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_network_interface_permissions_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeNetworkInterfacePermissionsOutput,
    crate::error::DescribeNetworkInterfacePermissionsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_network_interface_permissions_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_network_interface_permissions(response.body().as_ref(), output).map_err(crate::error::DescribeNetworkInterfacePermissionsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_network_interfaces_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeNetworkInterfacesOutput,
    crate::error::DescribeNetworkInterfacesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeNetworkInterfacesError::unhandled)?;
    Err(crate::error::DescribeNetworkInterfacesError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_network_interfaces_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeNetworkInterfacesOutput,
    crate::error::DescribeNetworkInterfacesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_network_interfaces_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_network_interfaces(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeNetworkInterfacesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_placement_groups_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribePlacementGroupsOutput,
    crate::error::DescribePlacementGroupsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribePlacementGroupsError::unhandled)?;
    Err(crate::error::DescribePlacementGroupsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_placement_groups_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribePlacementGroupsOutput,
    crate::error::DescribePlacementGroupsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_placement_groups_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_placement_groups(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribePlacementGroupsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_prefix_lists_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribePrefixListsOutput,
    crate::error::DescribePrefixListsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribePrefixListsError::unhandled)?;
    Err(crate::error::DescribePrefixListsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_prefix_lists_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribePrefixListsOutput,
    crate::error::DescribePrefixListsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_prefix_lists_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_prefix_lists(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribePrefixListsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_principal_id_format_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribePrincipalIdFormatOutput,
    crate::error::DescribePrincipalIdFormatError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribePrincipalIdFormatError::unhandled)?;
    Err(crate::error::DescribePrincipalIdFormatError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_principal_id_format_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribePrincipalIdFormatOutput,
    crate::error::DescribePrincipalIdFormatError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_principal_id_format_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_principal_id_format(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribePrincipalIdFormatError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_public_ipv4_pools_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribePublicIpv4PoolsOutput,
    crate::error::DescribePublicIpv4PoolsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribePublicIpv4PoolsError::unhandled)?;
    Err(crate::error::DescribePublicIpv4PoolsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_public_ipv4_pools_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribePublicIpv4PoolsOutput,
    crate::error::DescribePublicIpv4PoolsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_public_ipv4_pools_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_public_ipv4_pools(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribePublicIpv4PoolsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_regions_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeRegionsOutput, crate::error::DescribeRegionsError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeRegionsError::unhandled)?;
    Err(crate::error::DescribeRegionsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_regions_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeRegionsOutput, crate::error::DescribeRegionsError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_regions_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_regions(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeRegionsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_replace_root_volume_tasks_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeReplaceRootVolumeTasksOutput,
    crate::error::DescribeReplaceRootVolumeTasksError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeReplaceRootVolumeTasksError::unhandled)?;
    Err(crate::error::DescribeReplaceRootVolumeTasksError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_replace_root_volume_tasks_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeReplaceRootVolumeTasksOutput,
    crate::error::DescribeReplaceRootVolumeTasksError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_replace_root_volume_tasks_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_describe_replace_root_volume_tasks(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DescribeReplaceRootVolumeTasksError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_reserved_instances_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeReservedInstancesOutput,
    crate::error::DescribeReservedInstancesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeReservedInstancesError::unhandled)?;
    Err(crate::error::DescribeReservedInstancesError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_reserved_instances_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeReservedInstancesOutput,
    crate::error::DescribeReservedInstancesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_reserved_instances_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_reserved_instances(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeReservedInstancesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_reserved_instances_listings_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeReservedInstancesListingsOutput,
    crate::error::DescribeReservedInstancesListingsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeReservedInstancesListingsError::unhandled)?;
    Err(crate::error::DescribeReservedInstancesListingsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_reserved_instances_listings_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeReservedInstancesListingsOutput,
    crate::error::DescribeReservedInstancesListingsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_reserved_instances_listings_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_describe_reserved_instances_listings(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DescribeReservedInstancesListingsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_reserved_instances_modifications_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeReservedInstancesModificationsOutput,
    crate::error::DescribeReservedInstancesModificationsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeReservedInstancesModificationsError::unhandled)?;
    Err(crate::error::DescribeReservedInstancesModificationsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_reserved_instances_modifications_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeReservedInstancesModificationsOutput,
    crate::error::DescribeReservedInstancesModificationsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_reserved_instances_modifications_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_reserved_instances_modifications(response.body().as_ref(), output).map_err(crate::error::DescribeReservedInstancesModificationsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_reserved_instances_offerings_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeReservedInstancesOfferingsOutput,
    crate::error::DescribeReservedInstancesOfferingsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeReservedInstancesOfferingsError::unhandled)?;
    Err(crate::error::DescribeReservedInstancesOfferingsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_reserved_instances_offerings_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeReservedInstancesOfferingsOutput,
    crate::error::DescribeReservedInstancesOfferingsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_reserved_instances_offerings_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_reserved_instances_offerings(response.body().as_ref(), output).map_err(crate::error::DescribeReservedInstancesOfferingsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_route_tables_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeRouteTablesOutput,
    crate::error::DescribeRouteTablesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeRouteTablesError::unhandled)?;
    Err(crate::error::DescribeRouteTablesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_route_tables_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeRouteTablesOutput,
    crate::error::DescribeRouteTablesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_route_tables_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_route_tables(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeRouteTablesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_scheduled_instance_availability_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeScheduledInstanceAvailabilityOutput,
    crate::error::DescribeScheduledInstanceAvailabilityError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeScheduledInstanceAvailabilityError::unhandled)?;
    Err(crate::error::DescribeScheduledInstanceAvailabilityError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_scheduled_instance_availability_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeScheduledInstanceAvailabilityOutput,
    crate::error::DescribeScheduledInstanceAvailabilityError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_scheduled_instance_availability_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_scheduled_instance_availability(response.body().as_ref(), output).map_err(crate::error::DescribeScheduledInstanceAvailabilityError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_scheduled_instances_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeScheduledInstancesOutput,
    crate::error::DescribeScheduledInstancesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeScheduledInstancesError::unhandled)?;
    Err(crate::error::DescribeScheduledInstancesError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_scheduled_instances_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeScheduledInstancesOutput,
    crate::error::DescribeScheduledInstancesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_scheduled_instances_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_scheduled_instances(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeScheduledInstancesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_security_group_references_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeSecurityGroupReferencesOutput,
    crate::error::DescribeSecurityGroupReferencesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeSecurityGroupReferencesError::unhandled)?;
    Err(crate::error::DescribeSecurityGroupReferencesError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_security_group_references_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeSecurityGroupReferencesOutput,
    crate::error::DescribeSecurityGroupReferencesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_security_group_references_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_describe_security_group_references(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DescribeSecurityGroupReferencesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_security_group_rules_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeSecurityGroupRulesOutput,
    crate::error::DescribeSecurityGroupRulesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeSecurityGroupRulesError::unhandled)?;
    Err(crate::error::DescribeSecurityGroupRulesError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_security_group_rules_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeSecurityGroupRulesOutput,
    crate::error::DescribeSecurityGroupRulesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_security_group_rules_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_security_group_rules(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeSecurityGroupRulesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_security_groups_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeSecurityGroupsOutput,
    crate::error::DescribeSecurityGroupsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeSecurityGroupsError::unhandled)?;
    Err(crate::error::DescribeSecurityGroupsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_security_groups_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeSecurityGroupsOutput,
    crate::error::DescribeSecurityGroupsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_security_groups_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_security_groups(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeSecurityGroupsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_snapshot_attribute_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeSnapshotAttributeOutput,
    crate::error::DescribeSnapshotAttributeError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeSnapshotAttributeError::unhandled)?;
    Err(crate::error::DescribeSnapshotAttributeError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_snapshot_attribute_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeSnapshotAttributeOutput,
    crate::error::DescribeSnapshotAttributeError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_snapshot_attribute_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_snapshot_attribute(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeSnapshotAttributeError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_snapshots_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeSnapshotsOutput, crate::error::DescribeSnapshotsError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeSnapshotsError::unhandled)?;
    Err(crate::error::DescribeSnapshotsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_snapshots_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeSnapshotsOutput, crate::error::DescribeSnapshotsError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_snapshots_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_snapshots(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeSnapshotsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_spot_datafeed_subscription_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeSpotDatafeedSubscriptionOutput,
    crate::error::DescribeSpotDatafeedSubscriptionError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeSpotDatafeedSubscriptionError::unhandled)?;
    Err(crate::error::DescribeSpotDatafeedSubscriptionError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_spot_datafeed_subscription_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeSpotDatafeedSubscriptionOutput,
    crate::error::DescribeSpotDatafeedSubscriptionError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_spot_datafeed_subscription_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_describe_spot_datafeed_subscription(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DescribeSpotDatafeedSubscriptionError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_spot_fleet_instances_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeSpotFleetInstancesOutput,
    crate::error::DescribeSpotFleetInstancesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeSpotFleetInstancesError::unhandled)?;
    Err(crate::error::DescribeSpotFleetInstancesError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_spot_fleet_instances_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeSpotFleetInstancesOutput,
    crate::error::DescribeSpotFleetInstancesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_spot_fleet_instances_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_spot_fleet_instances(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeSpotFleetInstancesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_spot_fleet_request_history_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeSpotFleetRequestHistoryOutput,
    crate::error::DescribeSpotFleetRequestHistoryError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeSpotFleetRequestHistoryError::unhandled)?;
    Err(crate::error::DescribeSpotFleetRequestHistoryError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_spot_fleet_request_history_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeSpotFleetRequestHistoryOutput,
    crate::error::DescribeSpotFleetRequestHistoryError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_spot_fleet_request_history_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_describe_spot_fleet_request_history(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DescribeSpotFleetRequestHistoryError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_spot_fleet_requests_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeSpotFleetRequestsOutput,
    crate::error::DescribeSpotFleetRequestsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeSpotFleetRequestsError::unhandled)?;
    Err(crate::error::DescribeSpotFleetRequestsError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_spot_fleet_requests_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeSpotFleetRequestsOutput,
    crate::error::DescribeSpotFleetRequestsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_spot_fleet_requests_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_spot_fleet_requests(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeSpotFleetRequestsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_spot_instance_requests_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeSpotInstanceRequestsOutput,
    crate::error::DescribeSpotInstanceRequestsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeSpotInstanceRequestsError::unhandled)?;
    Err(crate::error::DescribeSpotInstanceRequestsError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_spot_instance_requests_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeSpotInstanceRequestsOutput,
    crate::error::DescribeSpotInstanceRequestsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_spot_instance_requests_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_spot_instance_requests(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeSpotInstanceRequestsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_spot_price_history_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeSpotPriceHistoryOutput,
    crate::error::DescribeSpotPriceHistoryError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeSpotPriceHistoryError::unhandled)?;
    Err(crate::error::DescribeSpotPriceHistoryError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_spot_price_history_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeSpotPriceHistoryOutput,
    crate::error::DescribeSpotPriceHistoryError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_spot_price_history_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_spot_price_history(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeSpotPriceHistoryError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_stale_security_groups_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeStaleSecurityGroupsOutput,
    crate::error::DescribeStaleSecurityGroupsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeStaleSecurityGroupsError::unhandled)?;
    Err(crate::error::DescribeStaleSecurityGroupsError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_stale_security_groups_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeStaleSecurityGroupsOutput,
    crate::error::DescribeStaleSecurityGroupsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_stale_security_groups_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_stale_security_groups(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeStaleSecurityGroupsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_store_image_tasks_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeStoreImageTasksOutput,
    crate::error::DescribeStoreImageTasksError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeStoreImageTasksError::unhandled)?;
    Err(crate::error::DescribeStoreImageTasksError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_store_image_tasks_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeStoreImageTasksOutput,
    crate::error::DescribeStoreImageTasksError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_store_image_tasks_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_store_image_tasks(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeStoreImageTasksError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_subnets_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeSubnetsOutput, crate::error::DescribeSubnetsError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeSubnetsError::unhandled)?;
    Err(crate::error::DescribeSubnetsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_subnets_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeSubnetsOutput, crate::error::DescribeSubnetsError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_subnets_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_subnets(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeSubnetsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_tags_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeTagsOutput, crate::error::DescribeTagsError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeTagsError::unhandled)?;
    Err(crate::error::DescribeTagsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_tags_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeTagsOutput, crate::error::DescribeTagsError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_tags_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_tags(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeTagsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_traffic_mirror_filters_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeTrafficMirrorFiltersOutput,
    crate::error::DescribeTrafficMirrorFiltersError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeTrafficMirrorFiltersError::unhandled)?;
    Err(crate::error::DescribeTrafficMirrorFiltersError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_traffic_mirror_filters_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeTrafficMirrorFiltersOutput,
    crate::error::DescribeTrafficMirrorFiltersError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_traffic_mirror_filters_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_traffic_mirror_filters(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeTrafficMirrorFiltersError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_traffic_mirror_sessions_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeTrafficMirrorSessionsOutput,
    crate::error::DescribeTrafficMirrorSessionsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeTrafficMirrorSessionsError::unhandled)?;
    Err(crate::error::DescribeTrafficMirrorSessionsError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_traffic_mirror_sessions_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeTrafficMirrorSessionsOutput,
    crate::error::DescribeTrafficMirrorSessionsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_traffic_mirror_sessions_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_describe_traffic_mirror_sessions(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DescribeTrafficMirrorSessionsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_traffic_mirror_targets_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeTrafficMirrorTargetsOutput,
    crate::error::DescribeTrafficMirrorTargetsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeTrafficMirrorTargetsError::unhandled)?;
    Err(crate::error::DescribeTrafficMirrorTargetsError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_traffic_mirror_targets_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeTrafficMirrorTargetsOutput,
    crate::error::DescribeTrafficMirrorTargetsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_traffic_mirror_targets_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_traffic_mirror_targets(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeTrafficMirrorTargetsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_transit_gateway_attachments_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeTransitGatewayAttachmentsOutput,
    crate::error::DescribeTransitGatewayAttachmentsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeTransitGatewayAttachmentsError::unhandled)?;
    Err(crate::error::DescribeTransitGatewayAttachmentsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_transit_gateway_attachments_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeTransitGatewayAttachmentsOutput,
    crate::error::DescribeTransitGatewayAttachmentsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_transit_gateway_attachments_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_describe_transit_gateway_attachments(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DescribeTransitGatewayAttachmentsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_transit_gateway_connect_peers_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeTransitGatewayConnectPeersOutput,
    crate::error::DescribeTransitGatewayConnectPeersError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeTransitGatewayConnectPeersError::unhandled)?;
    Err(crate::error::DescribeTransitGatewayConnectPeersError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_transit_gateway_connect_peers_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeTransitGatewayConnectPeersOutput,
    crate::error::DescribeTransitGatewayConnectPeersError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_transit_gateway_connect_peers_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_transit_gateway_connect_peers(response.body().as_ref(), output).map_err(crate::error::DescribeTransitGatewayConnectPeersError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_transit_gateway_connects_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeTransitGatewayConnectsOutput,
    crate::error::DescribeTransitGatewayConnectsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeTransitGatewayConnectsError::unhandled)?;
    Err(crate::error::DescribeTransitGatewayConnectsError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_transit_gateway_connects_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeTransitGatewayConnectsOutput,
    crate::error::DescribeTransitGatewayConnectsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_transit_gateway_connects_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_describe_transit_gateway_connects(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DescribeTransitGatewayConnectsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_transit_gateway_multicast_domains_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeTransitGatewayMulticastDomainsOutput,
    crate::error::DescribeTransitGatewayMulticastDomainsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeTransitGatewayMulticastDomainsError::unhandled)?;
    Err(crate::error::DescribeTransitGatewayMulticastDomainsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_transit_gateway_multicast_domains_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeTransitGatewayMulticastDomainsOutput,
    crate::error::DescribeTransitGatewayMulticastDomainsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_transit_gateway_multicast_domains_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_transit_gateway_multicast_domains(response.body().as_ref(), output).map_err(crate::error::DescribeTransitGatewayMulticastDomainsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_transit_gateway_peering_attachments_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeTransitGatewayPeeringAttachmentsOutput,
    crate::error::DescribeTransitGatewayPeeringAttachmentsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeTransitGatewayPeeringAttachmentsError::unhandled)?;
    Err(crate::error::DescribeTransitGatewayPeeringAttachmentsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_transit_gateway_peering_attachments_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeTransitGatewayPeeringAttachmentsOutput,
    crate::error::DescribeTransitGatewayPeeringAttachmentsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_transit_gateway_peering_attachments_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_transit_gateway_peering_attachments(response.body().as_ref(), output).map_err(crate::error::DescribeTransitGatewayPeeringAttachmentsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_transit_gateway_route_tables_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeTransitGatewayRouteTablesOutput,
    crate::error::DescribeTransitGatewayRouteTablesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeTransitGatewayRouteTablesError::unhandled)?;
    Err(crate::error::DescribeTransitGatewayRouteTablesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_transit_gateway_route_tables_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeTransitGatewayRouteTablesOutput,
    crate::error::DescribeTransitGatewayRouteTablesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_transit_gateway_route_tables_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_transit_gateway_route_tables(response.body().as_ref(), output).map_err(crate::error::DescribeTransitGatewayRouteTablesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_transit_gateways_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeTransitGatewaysOutput,
    crate::error::DescribeTransitGatewaysError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeTransitGatewaysError::unhandled)?;
    Err(crate::error::DescribeTransitGatewaysError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_transit_gateways_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeTransitGatewaysOutput,
    crate::error::DescribeTransitGatewaysError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_transit_gateways_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_transit_gateways(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeTransitGatewaysError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_transit_gateway_vpc_attachments_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeTransitGatewayVpcAttachmentsOutput,
    crate::error::DescribeTransitGatewayVpcAttachmentsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeTransitGatewayVpcAttachmentsError::unhandled)?;
    Err(crate::error::DescribeTransitGatewayVpcAttachmentsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_transit_gateway_vpc_attachments_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeTransitGatewayVpcAttachmentsOutput,
    crate::error::DescribeTransitGatewayVpcAttachmentsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_transit_gateway_vpc_attachments_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_transit_gateway_vpc_attachments(response.body().as_ref(), output).map_err(crate::error::DescribeTransitGatewayVpcAttachmentsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_trunk_interface_associations_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeTrunkInterfaceAssociationsOutput,
    crate::error::DescribeTrunkInterfaceAssociationsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeTrunkInterfaceAssociationsError::unhandled)?;
    Err(crate::error::DescribeTrunkInterfaceAssociationsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_trunk_interface_associations_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeTrunkInterfaceAssociationsOutput,
    crate::error::DescribeTrunkInterfaceAssociationsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_trunk_interface_associations_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_trunk_interface_associations(response.body().as_ref(), output).map_err(crate::error::DescribeTrunkInterfaceAssociationsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_volume_attribute_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVolumeAttributeOutput,
    crate::error::DescribeVolumeAttributeError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeVolumeAttributeError::unhandled)?;
    Err(crate::error::DescribeVolumeAttributeError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_volume_attribute_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVolumeAttributeOutput,
    crate::error::DescribeVolumeAttributeError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_volume_attribute_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_volume_attribute(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeVolumeAttributeError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_volumes_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeVolumesOutput, crate::error::DescribeVolumesError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeVolumesError::unhandled)?;
    Err(crate::error::DescribeVolumesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_volumes_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeVolumesOutput, crate::error::DescribeVolumesError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_volumes_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_volumes(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeVolumesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_volumes_modifications_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVolumesModificationsOutput,
    crate::error::DescribeVolumesModificationsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeVolumesModificationsError::unhandled)?;
    Err(crate::error::DescribeVolumesModificationsError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_volumes_modifications_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVolumesModificationsOutput,
    crate::error::DescribeVolumesModificationsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_volumes_modifications_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_volumes_modifications(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeVolumesModificationsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_volume_status_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVolumeStatusOutput,
    crate::error::DescribeVolumeStatusError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeVolumeStatusError::unhandled)?;
    Err(crate::error::DescribeVolumeStatusError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_volume_status_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVolumeStatusOutput,
    crate::error::DescribeVolumeStatusError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_volume_status_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_volume_status(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeVolumeStatusError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_vpc_attribute_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVpcAttributeOutput,
    crate::error::DescribeVpcAttributeError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeVpcAttributeError::unhandled)?;
    Err(crate::error::DescribeVpcAttributeError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_vpc_attribute_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVpcAttributeOutput,
    crate::error::DescribeVpcAttributeError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_vpc_attribute_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_vpc_attribute(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeVpcAttributeError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_vpc_classic_link_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVpcClassicLinkOutput,
    crate::error::DescribeVpcClassicLinkError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeVpcClassicLinkError::unhandled)?;
    Err(crate::error::DescribeVpcClassicLinkError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_vpc_classic_link_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVpcClassicLinkOutput,
    crate::error::DescribeVpcClassicLinkError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_vpc_classic_link_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_vpc_classic_link(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeVpcClassicLinkError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_vpc_classic_link_dns_support_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVpcClassicLinkDnsSupportOutput,
    crate::error::DescribeVpcClassicLinkDnsSupportError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeVpcClassicLinkDnsSupportError::unhandled)?;
    Err(crate::error::DescribeVpcClassicLinkDnsSupportError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_vpc_classic_link_dns_support_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVpcClassicLinkDnsSupportOutput,
    crate::error::DescribeVpcClassicLinkDnsSupportError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_vpc_classic_link_dns_support_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_vpc_classic_link_dns_support(response.body().as_ref(), output).map_err(crate::error::DescribeVpcClassicLinkDnsSupportError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_vpc_endpoint_connection_notifications_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVpcEndpointConnectionNotificationsOutput,
    crate::error::DescribeVpcEndpointConnectionNotificationsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeVpcEndpointConnectionNotificationsError::unhandled)?;
    Err(crate::error::DescribeVpcEndpointConnectionNotificationsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_vpc_endpoint_connection_notifications_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVpcEndpointConnectionNotificationsOutput,
    crate::error::DescribeVpcEndpointConnectionNotificationsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_vpc_endpoint_connection_notifications_output::Builder::default(
            );
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_vpc_endpoint_connection_notifications(response.body().as_ref(), output).map_err(crate::error::DescribeVpcEndpointConnectionNotificationsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_vpc_endpoint_connections_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVpcEndpointConnectionsOutput,
    crate::error::DescribeVpcEndpointConnectionsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeVpcEndpointConnectionsError::unhandled)?;
    Err(crate::error::DescribeVpcEndpointConnectionsError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_vpc_endpoint_connections_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVpcEndpointConnectionsOutput,
    crate::error::DescribeVpcEndpointConnectionsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_vpc_endpoint_connections_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_describe_vpc_endpoint_connections(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DescribeVpcEndpointConnectionsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_vpc_endpoints_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVpcEndpointsOutput,
    crate::error::DescribeVpcEndpointsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeVpcEndpointsError::unhandled)?;
    Err(crate::error::DescribeVpcEndpointsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_vpc_endpoints_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVpcEndpointsOutput,
    crate::error::DescribeVpcEndpointsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_vpc_endpoints_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_vpc_endpoints(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeVpcEndpointsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_vpc_endpoint_service_configurations_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVpcEndpointServiceConfigurationsOutput,
    crate::error::DescribeVpcEndpointServiceConfigurationsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeVpcEndpointServiceConfigurationsError::unhandled)?;
    Err(crate::error::DescribeVpcEndpointServiceConfigurationsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_vpc_endpoint_service_configurations_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVpcEndpointServiceConfigurationsOutput,
    crate::error::DescribeVpcEndpointServiceConfigurationsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_vpc_endpoint_service_configurations_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_vpc_endpoint_service_configurations(response.body().as_ref(), output).map_err(crate::error::DescribeVpcEndpointServiceConfigurationsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_vpc_endpoint_service_permissions_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVpcEndpointServicePermissionsOutput,
    crate::error::DescribeVpcEndpointServicePermissionsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeVpcEndpointServicePermissionsError::unhandled)?;
    Err(crate::error::DescribeVpcEndpointServicePermissionsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_vpc_endpoint_service_permissions_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVpcEndpointServicePermissionsOutput,
    crate::error::DescribeVpcEndpointServicePermissionsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::describe_vpc_endpoint_service_permissions_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_vpc_endpoint_service_permissions(response.body().as_ref(), output).map_err(crate::error::DescribeVpcEndpointServicePermissionsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_vpc_endpoint_services_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVpcEndpointServicesOutput,
    crate::error::DescribeVpcEndpointServicesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeVpcEndpointServicesError::unhandled)?;
    Err(crate::error::DescribeVpcEndpointServicesError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_vpc_endpoint_services_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVpcEndpointServicesOutput,
    crate::error::DescribeVpcEndpointServicesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_vpc_endpoint_services_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_vpc_endpoint_services(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeVpcEndpointServicesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_vpc_peering_connections_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVpcPeeringConnectionsOutput,
    crate::error::DescribeVpcPeeringConnectionsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeVpcPeeringConnectionsError::unhandled)?;
    Err(crate::error::DescribeVpcPeeringConnectionsError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_vpc_peering_connections_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVpcPeeringConnectionsOutput,
    crate::error::DescribeVpcPeeringConnectionsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_vpc_peering_connections_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_describe_vpc_peering_connections(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DescribeVpcPeeringConnectionsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_vpcs_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeVpcsOutput, crate::error::DescribeVpcsError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeVpcsError::unhandled)?;
    Err(crate::error::DescribeVpcsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_vpcs_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeVpcsOutput, crate::error::DescribeVpcsError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_vpcs_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_vpcs(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeVpcsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_vpn_connections_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVpnConnectionsOutput,
    crate::error::DescribeVpnConnectionsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeVpnConnectionsError::unhandled)?;
    Err(crate::error::DescribeVpnConnectionsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_vpn_connections_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVpnConnectionsOutput,
    crate::error::DescribeVpnConnectionsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_vpn_connections_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_vpn_connections(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeVpnConnectionsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_vpn_gateways_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVpnGatewaysOutput,
    crate::error::DescribeVpnGatewaysError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DescribeVpnGatewaysError::unhandled)?;
    Err(crate::error::DescribeVpnGatewaysError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_vpn_gateways_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DescribeVpnGatewaysOutput,
    crate::error::DescribeVpnGatewaysError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::describe_vpn_gateways_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_describe_vpn_gateways(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DescribeVpnGatewaysError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_detach_classic_link_vpc_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DetachClassicLinkVpcOutput,
    crate::error::DetachClassicLinkVpcError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DetachClassicLinkVpcError::unhandled)?;
    Err(crate::error::DetachClassicLinkVpcError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_detach_classic_link_vpc_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DetachClassicLinkVpcOutput,
    crate::error::DetachClassicLinkVpcError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::detach_classic_link_vpc_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_detach_classic_link_vpc(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DetachClassicLinkVpcError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_detach_internet_gateway_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DetachInternetGatewayOutput,
    crate::error::DetachInternetGatewayError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DetachInternetGatewayError::unhandled)?;
    Err(crate::error::DetachInternetGatewayError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_detach_internet_gateway_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DetachInternetGatewayOutput,
    crate::error::DetachInternetGatewayError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::detach_internet_gateway_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_detach_network_interface_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DetachNetworkInterfaceOutput,
    crate::error::DetachNetworkInterfaceError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DetachNetworkInterfaceError::unhandled)?;
    Err(crate::error::DetachNetworkInterfaceError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_detach_network_interface_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DetachNetworkInterfaceOutput,
    crate::error::DetachNetworkInterfaceError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::detach_network_interface_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_detach_volume_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DetachVolumeOutput, crate::error::DetachVolumeError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DetachVolumeError::unhandled)?;
    Err(crate::error::DetachVolumeError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_detach_volume_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DetachVolumeOutput, crate::error::DetachVolumeError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::detach_volume_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_detach_volume(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DetachVolumeError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_detach_vpn_gateway_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DetachVpnGatewayOutput, crate::error::DetachVpnGatewayError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DetachVpnGatewayError::unhandled)?;
    Err(crate::error::DetachVpnGatewayError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_detach_vpn_gateway_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DetachVpnGatewayOutput, crate::error::DetachVpnGatewayError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::detach_vpn_gateway_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disable_ebs_encryption_by_default_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisableEbsEncryptionByDefaultOutput,
    crate::error::DisableEbsEncryptionByDefaultError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DisableEbsEncryptionByDefaultError::unhandled)?;
    Err(crate::error::DisableEbsEncryptionByDefaultError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disable_ebs_encryption_by_default_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisableEbsEncryptionByDefaultOutput,
    crate::error::DisableEbsEncryptionByDefaultError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::disable_ebs_encryption_by_default_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_disable_ebs_encryption_by_default(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DisableEbsEncryptionByDefaultError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disable_fast_snapshot_restores_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisableFastSnapshotRestoresOutput,
    crate::error::DisableFastSnapshotRestoresError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DisableFastSnapshotRestoresError::unhandled)?;
    Err(crate::error::DisableFastSnapshotRestoresError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disable_fast_snapshot_restores_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisableFastSnapshotRestoresOutput,
    crate::error::DisableFastSnapshotRestoresError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::disable_fast_snapshot_restores_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_disable_fast_snapshot_restores(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DisableFastSnapshotRestoresError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disable_image_deprecation_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisableImageDeprecationOutput,
    crate::error::DisableImageDeprecationError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DisableImageDeprecationError::unhandled)?;
    Err(crate::error::DisableImageDeprecationError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disable_image_deprecation_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisableImageDeprecationOutput,
    crate::error::DisableImageDeprecationError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::disable_image_deprecation_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_disable_image_deprecation(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DisableImageDeprecationError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disable_serial_console_access_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisableSerialConsoleAccessOutput,
    crate::error::DisableSerialConsoleAccessError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DisableSerialConsoleAccessError::unhandled)?;
    Err(crate::error::DisableSerialConsoleAccessError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disable_serial_console_access_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisableSerialConsoleAccessOutput,
    crate::error::DisableSerialConsoleAccessError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::disable_serial_console_access_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_disable_serial_console_access(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DisableSerialConsoleAccessError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disable_transit_gateway_route_table_propagation_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisableTransitGatewayRouteTablePropagationOutput,
    crate::error::DisableTransitGatewayRouteTablePropagationError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DisableTransitGatewayRouteTablePropagationError::unhandled)?;
    Err(crate::error::DisableTransitGatewayRouteTablePropagationError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disable_transit_gateway_route_table_propagation_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisableTransitGatewayRouteTablePropagationOutput,
    crate::error::DisableTransitGatewayRouteTablePropagationError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::disable_transit_gateway_route_table_propagation_output::Builder::default(
            );
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_disable_transit_gateway_route_table_propagation(response.body().as_ref(), output).map_err(crate::error::DisableTransitGatewayRouteTablePropagationError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disable_vgw_route_propagation_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisableVgwRoutePropagationOutput,
    crate::error::DisableVgwRoutePropagationError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DisableVgwRoutePropagationError::unhandled)?;
    Err(crate::error::DisableVgwRoutePropagationError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disable_vgw_route_propagation_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisableVgwRoutePropagationOutput,
    crate::error::DisableVgwRoutePropagationError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::disable_vgw_route_propagation_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disable_vpc_classic_link_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisableVpcClassicLinkOutput,
    crate::error::DisableVpcClassicLinkError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DisableVpcClassicLinkError::unhandled)?;
    Err(crate::error::DisableVpcClassicLinkError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disable_vpc_classic_link_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisableVpcClassicLinkOutput,
    crate::error::DisableVpcClassicLinkError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::disable_vpc_classic_link_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_disable_vpc_classic_link(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DisableVpcClassicLinkError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disable_vpc_classic_link_dns_support_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisableVpcClassicLinkDnsSupportOutput,
    crate::error::DisableVpcClassicLinkDnsSupportError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DisableVpcClassicLinkDnsSupportError::unhandled)?;
    Err(crate::error::DisableVpcClassicLinkDnsSupportError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disable_vpc_classic_link_dns_support_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisableVpcClassicLinkDnsSupportOutput,
    crate::error::DisableVpcClassicLinkDnsSupportError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::disable_vpc_classic_link_dns_support_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_disable_vpc_classic_link_dns_support(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DisableVpcClassicLinkDnsSupportError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_address_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisassociateAddressOutput,
    crate::error::DisassociateAddressError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DisassociateAddressError::unhandled)?;
    Err(crate::error::DisassociateAddressError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_address_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisassociateAddressOutput,
    crate::error::DisassociateAddressError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::disassociate_address_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_client_vpn_target_network_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisassociateClientVpnTargetNetworkOutput,
    crate::error::DisassociateClientVpnTargetNetworkError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DisassociateClientVpnTargetNetworkError::unhandled)?;
    Err(crate::error::DisassociateClientVpnTargetNetworkError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_client_vpn_target_network_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisassociateClientVpnTargetNetworkOutput,
    crate::error::DisassociateClientVpnTargetNetworkError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::disassociate_client_vpn_target_network_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_disassociate_client_vpn_target_network(response.body().as_ref(), output).map_err(crate::error::DisassociateClientVpnTargetNetworkError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_enclave_certificate_iam_role_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisassociateEnclaveCertificateIamRoleOutput,
    crate::error::DisassociateEnclaveCertificateIamRoleError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DisassociateEnclaveCertificateIamRoleError::unhandled)?;
    Err(crate::error::DisassociateEnclaveCertificateIamRoleError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_enclave_certificate_iam_role_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisassociateEnclaveCertificateIamRoleOutput,
    crate::error::DisassociateEnclaveCertificateIamRoleError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::disassociate_enclave_certificate_iam_role_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_disassociate_enclave_certificate_iam_role(response.body().as_ref(), output).map_err(crate::error::DisassociateEnclaveCertificateIamRoleError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_iam_instance_profile_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisassociateIamInstanceProfileOutput,
    crate::error::DisassociateIamInstanceProfileError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DisassociateIamInstanceProfileError::unhandled)?;
    Err(crate::error::DisassociateIamInstanceProfileError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_iam_instance_profile_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisassociateIamInstanceProfileOutput,
    crate::error::DisassociateIamInstanceProfileError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::disassociate_iam_instance_profile_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_disassociate_iam_instance_profile(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DisassociateIamInstanceProfileError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_instance_event_window_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisassociateInstanceEventWindowOutput,
    crate::error::DisassociateInstanceEventWindowError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DisassociateInstanceEventWindowError::unhandled)?;
    Err(crate::error::DisassociateInstanceEventWindowError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_instance_event_window_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisassociateInstanceEventWindowOutput,
    crate::error::DisassociateInstanceEventWindowError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::disassociate_instance_event_window_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_disassociate_instance_event_window(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::DisassociateInstanceEventWindowError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_route_table_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisassociateRouteTableOutput,
    crate::error::DisassociateRouteTableError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DisassociateRouteTableError::unhandled)?;
    Err(crate::error::DisassociateRouteTableError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_route_table_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisassociateRouteTableOutput,
    crate::error::DisassociateRouteTableError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::disassociate_route_table_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_subnet_cidr_block_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisassociateSubnetCidrBlockOutput,
    crate::error::DisassociateSubnetCidrBlockError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DisassociateSubnetCidrBlockError::unhandled)?;
    Err(crate::error::DisassociateSubnetCidrBlockError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_subnet_cidr_block_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisassociateSubnetCidrBlockOutput,
    crate::error::DisassociateSubnetCidrBlockError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::disassociate_subnet_cidr_block_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_disassociate_subnet_cidr_block(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DisassociateSubnetCidrBlockError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_transit_gateway_multicast_domain_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisassociateTransitGatewayMulticastDomainOutput,
    crate::error::DisassociateTransitGatewayMulticastDomainError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DisassociateTransitGatewayMulticastDomainError::unhandled)?;
    Err(crate::error::DisassociateTransitGatewayMulticastDomainError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_transit_gateway_multicast_domain_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisassociateTransitGatewayMulticastDomainOutput,
    crate::error::DisassociateTransitGatewayMulticastDomainError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::disassociate_transit_gateway_multicast_domain_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_disassociate_transit_gateway_multicast_domain(response.body().as_ref(), output).map_err(crate::error::DisassociateTransitGatewayMulticastDomainError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_transit_gateway_route_table_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisassociateTransitGatewayRouteTableOutput,
    crate::error::DisassociateTransitGatewayRouteTableError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DisassociateTransitGatewayRouteTableError::unhandled)?;
    Err(crate::error::DisassociateTransitGatewayRouteTableError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_transit_gateway_route_table_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisassociateTransitGatewayRouteTableOutput,
    crate::error::DisassociateTransitGatewayRouteTableError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::disassociate_transit_gateway_route_table_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_disassociate_transit_gateway_route_table(response.body().as_ref(), output).map_err(crate::error::DisassociateTransitGatewayRouteTableError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_trunk_interface_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisassociateTrunkInterfaceOutput,
    crate::error::DisassociateTrunkInterfaceError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DisassociateTrunkInterfaceError::unhandled)?;
    Err(crate::error::DisassociateTrunkInterfaceError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_trunk_interface_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisassociateTrunkInterfaceOutput,
    crate::error::DisassociateTrunkInterfaceError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::disassociate_trunk_interface_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_disassociate_trunk_interface(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DisassociateTrunkInterfaceError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_vpc_cidr_block_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisassociateVpcCidrBlockOutput,
    crate::error::DisassociateVpcCidrBlockError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::DisassociateVpcCidrBlockError::unhandled)?;
    Err(crate::error::DisassociateVpcCidrBlockError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_vpc_cidr_block_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DisassociateVpcCidrBlockOutput,
    crate::error::DisassociateVpcCidrBlockError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::disassociate_vpc_cidr_block_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_disassociate_vpc_cidr_block(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DisassociateVpcCidrBlockError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_enable_ebs_encryption_by_default_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::EnableEbsEncryptionByDefaultOutput,
    crate::error::EnableEbsEncryptionByDefaultError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::EnableEbsEncryptionByDefaultError::unhandled)?;
    Err(crate::error::EnableEbsEncryptionByDefaultError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_enable_ebs_encryption_by_default_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::EnableEbsEncryptionByDefaultOutput,
    crate::error::EnableEbsEncryptionByDefaultError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::enable_ebs_encryption_by_default_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_enable_ebs_encryption_by_default(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::EnableEbsEncryptionByDefaultError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_enable_fast_snapshot_restores_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::EnableFastSnapshotRestoresOutput,
    crate::error::EnableFastSnapshotRestoresError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::EnableFastSnapshotRestoresError::unhandled)?;
    Err(crate::error::EnableFastSnapshotRestoresError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_enable_fast_snapshot_restores_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::EnableFastSnapshotRestoresOutput,
    crate::error::EnableFastSnapshotRestoresError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::enable_fast_snapshot_restores_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_enable_fast_snapshot_restores(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::EnableFastSnapshotRestoresError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_enable_image_deprecation_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::EnableImageDeprecationOutput,
    crate::error::EnableImageDeprecationError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::EnableImageDeprecationError::unhandled)?;
    Err(crate::error::EnableImageDeprecationError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_enable_image_deprecation_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::EnableImageDeprecationOutput,
    crate::error::EnableImageDeprecationError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::enable_image_deprecation_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_enable_image_deprecation(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::EnableImageDeprecationError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_enable_serial_console_access_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::EnableSerialConsoleAccessOutput,
    crate::error::EnableSerialConsoleAccessError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::EnableSerialConsoleAccessError::unhandled)?;
    Err(crate::error::EnableSerialConsoleAccessError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_enable_serial_console_access_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::EnableSerialConsoleAccessOutput,
    crate::error::EnableSerialConsoleAccessError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::enable_serial_console_access_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_enable_serial_console_access(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::EnableSerialConsoleAccessError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_enable_transit_gateway_route_table_propagation_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::EnableTransitGatewayRouteTablePropagationOutput,
    crate::error::EnableTransitGatewayRouteTablePropagationError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::EnableTransitGatewayRouteTablePropagationError::unhandled)?;
    Err(crate::error::EnableTransitGatewayRouteTablePropagationError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_enable_transit_gateway_route_table_propagation_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::EnableTransitGatewayRouteTablePropagationOutput,
    crate::error::EnableTransitGatewayRouteTablePropagationError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::enable_transit_gateway_route_table_propagation_output::Builder::default(
            );
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_enable_transit_gateway_route_table_propagation(response.body().as_ref(), output).map_err(crate::error::EnableTransitGatewayRouteTablePropagationError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_enable_vgw_route_propagation_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::EnableVgwRoutePropagationOutput,
    crate::error::EnableVgwRoutePropagationError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::EnableVgwRoutePropagationError::unhandled)?;
    Err(crate::error::EnableVgwRoutePropagationError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_enable_vgw_route_propagation_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::EnableVgwRoutePropagationOutput,
    crate::error::EnableVgwRoutePropagationError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::enable_vgw_route_propagation_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_enable_volume_io_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::EnableVolumeIoOutput, crate::error::EnableVolumeIOError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::EnableVolumeIOError::unhandled)?;
    Err(crate::error::EnableVolumeIOError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_enable_volume_io_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::EnableVolumeIoOutput, crate::error::EnableVolumeIOError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::enable_volume_io_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_enable_vpc_classic_link_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::EnableVpcClassicLinkOutput,
    crate::error::EnableVpcClassicLinkError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::EnableVpcClassicLinkError::unhandled)?;
    Err(crate::error::EnableVpcClassicLinkError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_enable_vpc_classic_link_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::EnableVpcClassicLinkOutput,
    crate::error::EnableVpcClassicLinkError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::enable_vpc_classic_link_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_enable_vpc_classic_link(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::EnableVpcClassicLinkError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_enable_vpc_classic_link_dns_support_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::EnableVpcClassicLinkDnsSupportOutput,
    crate::error::EnableVpcClassicLinkDnsSupportError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::EnableVpcClassicLinkDnsSupportError::unhandled)?;
    Err(crate::error::EnableVpcClassicLinkDnsSupportError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_enable_vpc_classic_link_dns_support_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::EnableVpcClassicLinkDnsSupportOutput,
    crate::error::EnableVpcClassicLinkDnsSupportError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::enable_vpc_classic_link_dns_support_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_enable_vpc_classic_link_dns_support(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::EnableVpcClassicLinkDnsSupportError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_export_client_vpn_client_certificate_revocation_list_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ExportClientVpnClientCertificateRevocationListOutput,
    crate::error::ExportClientVpnClientCertificateRevocationListError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ExportClientVpnClientCertificateRevocationListError::unhandled)?;
    Err(crate::error::ExportClientVpnClientCertificateRevocationListError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_export_client_vpn_client_certificate_revocation_list_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ExportClientVpnClientCertificateRevocationListOutput,
    crate::error::ExportClientVpnClientCertificateRevocationListError,
> {
    Ok({
        #[allow(unused_mut)]let mut output = crate::output::export_client_vpn_client_certificate_revocation_list_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_export_client_vpn_client_certificate_revocation_list(response.body().as_ref(), output).map_err(crate::error::ExportClientVpnClientCertificateRevocationListError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_export_client_vpn_client_configuration_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ExportClientVpnClientConfigurationOutput,
    crate::error::ExportClientVpnClientConfigurationError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ExportClientVpnClientConfigurationError::unhandled)?;
    Err(crate::error::ExportClientVpnClientConfigurationError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_export_client_vpn_client_configuration_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ExportClientVpnClientConfigurationOutput,
    crate::error::ExportClientVpnClientConfigurationError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::export_client_vpn_client_configuration_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_export_client_vpn_client_configuration(response.body().as_ref(), output).map_err(crate::error::ExportClientVpnClientConfigurationError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_export_image_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ExportImageOutput, crate::error::ExportImageError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ExportImageError::unhandled)?;
    Err(crate::error::ExportImageError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_export_image_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ExportImageOutput, crate::error::ExportImageError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::export_image_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_export_image(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ExportImageError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_export_transit_gateway_routes_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ExportTransitGatewayRoutesOutput,
    crate::error::ExportTransitGatewayRoutesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ExportTransitGatewayRoutesError::unhandled)?;
    Err(crate::error::ExportTransitGatewayRoutesError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_export_transit_gateway_routes_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ExportTransitGatewayRoutesOutput,
    crate::error::ExportTransitGatewayRoutesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::export_transit_gateway_routes_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_export_transit_gateway_routes(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ExportTransitGatewayRoutesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_associated_enclave_certificate_iam_roles_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetAssociatedEnclaveCertificateIamRolesOutput,
    crate::error::GetAssociatedEnclaveCertificateIamRolesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetAssociatedEnclaveCertificateIamRolesError::unhandled)?;
    Err(crate::error::GetAssociatedEnclaveCertificateIamRolesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_associated_enclave_certificate_iam_roles_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetAssociatedEnclaveCertificateIamRolesOutput,
    crate::error::GetAssociatedEnclaveCertificateIamRolesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::get_associated_enclave_certificate_iam_roles_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_get_associated_enclave_certificate_iam_roles(response.body().as_ref(), output).map_err(crate::error::GetAssociatedEnclaveCertificateIamRolesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_associated_ipv6_pool_cidrs_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetAssociatedIpv6PoolCidrsOutput,
    crate::error::GetAssociatedIpv6PoolCidrsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetAssociatedIpv6PoolCidrsError::unhandled)?;
    Err(crate::error::GetAssociatedIpv6PoolCidrsError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_associated_ipv6_pool_cidrs_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetAssociatedIpv6PoolCidrsOutput,
    crate::error::GetAssociatedIpv6PoolCidrsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::get_associated_ipv6_pool_cidrs_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_get_associated_ipv6_pool_cidrs(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::GetAssociatedIpv6PoolCidrsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_capacity_reservation_usage_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetCapacityReservationUsageOutput,
    crate::error::GetCapacityReservationUsageError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetCapacityReservationUsageError::unhandled)?;
    Err(crate::error::GetCapacityReservationUsageError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_capacity_reservation_usage_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetCapacityReservationUsageOutput,
    crate::error::GetCapacityReservationUsageError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::get_capacity_reservation_usage_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_get_capacity_reservation_usage(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::GetCapacityReservationUsageError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_coip_pool_usage_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetCoipPoolUsageOutput, crate::error::GetCoipPoolUsageError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetCoipPoolUsageError::unhandled)?;
    Err(crate::error::GetCoipPoolUsageError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_coip_pool_usage_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetCoipPoolUsageOutput, crate::error::GetCoipPoolUsageError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::get_coip_pool_usage_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_get_coip_pool_usage(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::GetCoipPoolUsageError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_console_output_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetConsoleOutputOutput, crate::error::GetConsoleOutputError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetConsoleOutputError::unhandled)?;
    Err(crate::error::GetConsoleOutputError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_console_output_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetConsoleOutputOutput, crate::error::GetConsoleOutputError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::get_console_output_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_get_console_output(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::GetConsoleOutputError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_console_screenshot_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetConsoleScreenshotOutput,
    crate::error::GetConsoleScreenshotError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetConsoleScreenshotError::unhandled)?;
    Err(crate::error::GetConsoleScreenshotError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_console_screenshot_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetConsoleScreenshotOutput,
    crate::error::GetConsoleScreenshotError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::get_console_screenshot_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_get_console_screenshot(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::GetConsoleScreenshotError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_default_credit_specification_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetDefaultCreditSpecificationOutput,
    crate::error::GetDefaultCreditSpecificationError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetDefaultCreditSpecificationError::unhandled)?;
    Err(crate::error::GetDefaultCreditSpecificationError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_default_credit_specification_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetDefaultCreditSpecificationOutput,
    crate::error::GetDefaultCreditSpecificationError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::get_default_credit_specification_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_get_default_credit_specification(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::GetDefaultCreditSpecificationError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_ebs_default_kms_key_id_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetEbsDefaultKmsKeyIdOutput,
    crate::error::GetEbsDefaultKmsKeyIdError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetEbsDefaultKmsKeyIdError::unhandled)?;
    Err(crate::error::GetEbsDefaultKmsKeyIdError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_ebs_default_kms_key_id_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetEbsDefaultKmsKeyIdOutput,
    crate::error::GetEbsDefaultKmsKeyIdError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::get_ebs_default_kms_key_id_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_get_ebs_default_kms_key_id(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::GetEbsDefaultKmsKeyIdError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_ebs_encryption_by_default_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetEbsEncryptionByDefaultOutput,
    crate::error::GetEbsEncryptionByDefaultError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetEbsEncryptionByDefaultError::unhandled)?;
    Err(crate::error::GetEbsEncryptionByDefaultError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_ebs_encryption_by_default_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetEbsEncryptionByDefaultOutput,
    crate::error::GetEbsEncryptionByDefaultError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::get_ebs_encryption_by_default_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_get_ebs_encryption_by_default(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::GetEbsEncryptionByDefaultError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_flow_logs_integration_template_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetFlowLogsIntegrationTemplateOutput,
    crate::error::GetFlowLogsIntegrationTemplateError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetFlowLogsIntegrationTemplateError::unhandled)?;
    Err(crate::error::GetFlowLogsIntegrationTemplateError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_flow_logs_integration_template_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetFlowLogsIntegrationTemplateOutput,
    crate::error::GetFlowLogsIntegrationTemplateError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::get_flow_logs_integration_template_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_get_flow_logs_integration_template(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::GetFlowLogsIntegrationTemplateError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_groups_for_capacity_reservation_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetGroupsForCapacityReservationOutput,
    crate::error::GetGroupsForCapacityReservationError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetGroupsForCapacityReservationError::unhandled)?;
    Err(crate::error::GetGroupsForCapacityReservationError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_groups_for_capacity_reservation_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetGroupsForCapacityReservationOutput,
    crate::error::GetGroupsForCapacityReservationError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::get_groups_for_capacity_reservation_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_get_groups_for_capacity_reservation(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::GetGroupsForCapacityReservationError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_host_reservation_purchase_preview_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetHostReservationPurchasePreviewOutput,
    crate::error::GetHostReservationPurchasePreviewError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetHostReservationPurchasePreviewError::unhandled)?;
    Err(crate::error::GetHostReservationPurchasePreviewError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_host_reservation_purchase_preview_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetHostReservationPurchasePreviewOutput,
    crate::error::GetHostReservationPurchasePreviewError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::get_host_reservation_purchase_preview_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_get_host_reservation_purchase_preview(response.body().as_ref(), output).map_err(crate::error::GetHostReservationPurchasePreviewError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_launch_template_data_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetLaunchTemplateDataOutput,
    crate::error::GetLaunchTemplateDataError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetLaunchTemplateDataError::unhandled)?;
    Err(crate::error::GetLaunchTemplateDataError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_launch_template_data_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetLaunchTemplateDataOutput,
    crate::error::GetLaunchTemplateDataError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::get_launch_template_data_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_get_launch_template_data(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::GetLaunchTemplateDataError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_managed_prefix_list_associations_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetManagedPrefixListAssociationsOutput,
    crate::error::GetManagedPrefixListAssociationsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetManagedPrefixListAssociationsError::unhandled)?;
    Err(crate::error::GetManagedPrefixListAssociationsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_managed_prefix_list_associations_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetManagedPrefixListAssociationsOutput,
    crate::error::GetManagedPrefixListAssociationsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::get_managed_prefix_list_associations_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_get_managed_prefix_list_associations(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::GetManagedPrefixListAssociationsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_managed_prefix_list_entries_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetManagedPrefixListEntriesOutput,
    crate::error::GetManagedPrefixListEntriesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetManagedPrefixListEntriesError::unhandled)?;
    Err(crate::error::GetManagedPrefixListEntriesError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_managed_prefix_list_entries_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetManagedPrefixListEntriesOutput,
    crate::error::GetManagedPrefixListEntriesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::get_managed_prefix_list_entries_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_get_managed_prefix_list_entries(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::GetManagedPrefixListEntriesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_password_data_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetPasswordDataOutput, crate::error::GetPasswordDataError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetPasswordDataError::unhandled)?;
    Err(crate::error::GetPasswordDataError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_password_data_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetPasswordDataOutput, crate::error::GetPasswordDataError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::get_password_data_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_get_password_data(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::GetPasswordDataError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_reserved_instances_exchange_quote_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetReservedInstancesExchangeQuoteOutput,
    crate::error::GetReservedInstancesExchangeQuoteError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetReservedInstancesExchangeQuoteError::unhandled)?;
    Err(crate::error::GetReservedInstancesExchangeQuoteError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_reserved_instances_exchange_quote_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetReservedInstancesExchangeQuoteOutput,
    crate::error::GetReservedInstancesExchangeQuoteError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::get_reserved_instances_exchange_quote_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_get_reserved_instances_exchange_quote(response.body().as_ref(), output).map_err(crate::error::GetReservedInstancesExchangeQuoteError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_serial_console_access_status_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetSerialConsoleAccessStatusOutput,
    crate::error::GetSerialConsoleAccessStatusError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetSerialConsoleAccessStatusError::unhandled)?;
    Err(crate::error::GetSerialConsoleAccessStatusError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_serial_console_access_status_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetSerialConsoleAccessStatusOutput,
    crate::error::GetSerialConsoleAccessStatusError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::get_serial_console_access_status_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_get_serial_console_access_status(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::GetSerialConsoleAccessStatusError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_subnet_cidr_reservations_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetSubnetCidrReservationsOutput,
    crate::error::GetSubnetCidrReservationsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetSubnetCidrReservationsError::unhandled)?;
    Err(crate::error::GetSubnetCidrReservationsError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_subnet_cidr_reservations_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetSubnetCidrReservationsOutput,
    crate::error::GetSubnetCidrReservationsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::get_subnet_cidr_reservations_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_get_subnet_cidr_reservations(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::GetSubnetCidrReservationsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_transit_gateway_attachment_propagations_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetTransitGatewayAttachmentPropagationsOutput,
    crate::error::GetTransitGatewayAttachmentPropagationsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetTransitGatewayAttachmentPropagationsError::unhandled)?;
    Err(crate::error::GetTransitGatewayAttachmentPropagationsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_transit_gateway_attachment_propagations_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetTransitGatewayAttachmentPropagationsOutput,
    crate::error::GetTransitGatewayAttachmentPropagationsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::get_transit_gateway_attachment_propagations_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_get_transit_gateway_attachment_propagations(response.body().as_ref(), output).map_err(crate::error::GetTransitGatewayAttachmentPropagationsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_transit_gateway_multicast_domain_associations_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetTransitGatewayMulticastDomainAssociationsOutput,
    crate::error::GetTransitGatewayMulticastDomainAssociationsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetTransitGatewayMulticastDomainAssociationsError::unhandled)?;
    Err(crate::error::GetTransitGatewayMulticastDomainAssociationsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_transit_gateway_multicast_domain_associations_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetTransitGatewayMulticastDomainAssociationsOutput,
    crate::error::GetTransitGatewayMulticastDomainAssociationsError,
> {
    Ok({
        #[allow(unused_mut)]let mut output = crate::output::get_transit_gateway_multicast_domain_associations_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_get_transit_gateway_multicast_domain_associations(response.body().as_ref(), output).map_err(crate::error::GetTransitGatewayMulticastDomainAssociationsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_transit_gateway_prefix_list_references_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetTransitGatewayPrefixListReferencesOutput,
    crate::error::GetTransitGatewayPrefixListReferencesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetTransitGatewayPrefixListReferencesError::unhandled)?;
    Err(crate::error::GetTransitGatewayPrefixListReferencesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_transit_gateway_prefix_list_references_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetTransitGatewayPrefixListReferencesOutput,
    crate::error::GetTransitGatewayPrefixListReferencesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::get_transit_gateway_prefix_list_references_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_get_transit_gateway_prefix_list_references(response.body().as_ref(), output).map_err(crate::error::GetTransitGatewayPrefixListReferencesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_transit_gateway_route_table_associations_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetTransitGatewayRouteTableAssociationsOutput,
    crate::error::GetTransitGatewayRouteTableAssociationsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetTransitGatewayRouteTableAssociationsError::unhandled)?;
    Err(crate::error::GetTransitGatewayRouteTableAssociationsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_transit_gateway_route_table_associations_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetTransitGatewayRouteTableAssociationsOutput,
    crate::error::GetTransitGatewayRouteTableAssociationsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::get_transit_gateway_route_table_associations_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_get_transit_gateway_route_table_associations(response.body().as_ref(), output).map_err(crate::error::GetTransitGatewayRouteTableAssociationsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_transit_gateway_route_table_propagations_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetTransitGatewayRouteTablePropagationsOutput,
    crate::error::GetTransitGatewayRouteTablePropagationsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetTransitGatewayRouteTablePropagationsError::unhandled)?;
    Err(crate::error::GetTransitGatewayRouteTablePropagationsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_transit_gateway_route_table_propagations_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetTransitGatewayRouteTablePropagationsOutput,
    crate::error::GetTransitGatewayRouteTablePropagationsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::get_transit_gateway_route_table_propagations_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_get_transit_gateway_route_table_propagations(response.body().as_ref(), output).map_err(crate::error::GetTransitGatewayRouteTablePropagationsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_vpn_connection_device_sample_configuration_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetVpnConnectionDeviceSampleConfigurationOutput,
    crate::error::GetVpnConnectionDeviceSampleConfigurationError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetVpnConnectionDeviceSampleConfigurationError::unhandled)?;
    Err(crate::error::GetVpnConnectionDeviceSampleConfigurationError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_vpn_connection_device_sample_configuration_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetVpnConnectionDeviceSampleConfigurationOutput,
    crate::error::GetVpnConnectionDeviceSampleConfigurationError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::get_vpn_connection_device_sample_configuration_output::Builder::default(
            );
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_get_vpn_connection_device_sample_configuration(response.body().as_ref(), output).map_err(crate::error::GetVpnConnectionDeviceSampleConfigurationError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_vpn_connection_device_types_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetVpnConnectionDeviceTypesOutput,
    crate::error::GetVpnConnectionDeviceTypesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetVpnConnectionDeviceTypesError::unhandled)?;
    Err(crate::error::GetVpnConnectionDeviceTypesError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_vpn_connection_device_types_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetVpnConnectionDeviceTypesOutput,
    crate::error::GetVpnConnectionDeviceTypesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::get_vpn_connection_device_types_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_get_vpn_connection_device_types(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::GetVpnConnectionDeviceTypesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_import_client_vpn_client_certificate_revocation_list_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ImportClientVpnClientCertificateRevocationListOutput,
    crate::error::ImportClientVpnClientCertificateRevocationListError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ImportClientVpnClientCertificateRevocationListError::unhandled)?;
    Err(crate::error::ImportClientVpnClientCertificateRevocationListError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_import_client_vpn_client_certificate_revocation_list_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ImportClientVpnClientCertificateRevocationListOutput,
    crate::error::ImportClientVpnClientCertificateRevocationListError,
> {
    Ok({
        #[allow(unused_mut)]let mut output = crate::output::import_client_vpn_client_certificate_revocation_list_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_import_client_vpn_client_certificate_revocation_list(response.body().as_ref(), output).map_err(crate::error::ImportClientVpnClientCertificateRevocationListError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_import_image_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ImportImageOutput, crate::error::ImportImageError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ImportImageError::unhandled)?;
    Err(crate::error::ImportImageError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_import_image_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ImportImageOutput, crate::error::ImportImageError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::import_image_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_import_image(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ImportImageError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_import_instance_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ImportInstanceOutput, crate::error::ImportInstanceError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ImportInstanceError::unhandled)?;
    Err(crate::error::ImportInstanceError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_import_instance_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ImportInstanceOutput, crate::error::ImportInstanceError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::import_instance_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_import_instance(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ImportInstanceError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_import_key_pair_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ImportKeyPairOutput, crate::error::ImportKeyPairError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ImportKeyPairError::unhandled)?;
    Err(crate::error::ImportKeyPairError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_import_key_pair_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ImportKeyPairOutput, crate::error::ImportKeyPairError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::import_key_pair_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_import_key_pair(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ImportKeyPairError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_import_snapshot_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ImportSnapshotOutput, crate::error::ImportSnapshotError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ImportSnapshotError::unhandled)?;
    Err(crate::error::ImportSnapshotError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_import_snapshot_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ImportSnapshotOutput, crate::error::ImportSnapshotError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::import_snapshot_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_import_snapshot(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ImportSnapshotError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_import_volume_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ImportVolumeOutput, crate::error::ImportVolumeError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ImportVolumeError::unhandled)?;
    Err(crate::error::ImportVolumeError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_import_volume_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ImportVolumeOutput, crate::error::ImportVolumeError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::import_volume_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_import_volume(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ImportVolumeError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_address_attribute_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyAddressAttributeOutput,
    crate::error::ModifyAddressAttributeError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyAddressAttributeError::unhandled)?;
    Err(crate::error::ModifyAddressAttributeError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_address_attribute_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyAddressAttributeOutput,
    crate::error::ModifyAddressAttributeError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_address_attribute_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_address_attribute(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ModifyAddressAttributeError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_availability_zone_group_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyAvailabilityZoneGroupOutput,
    crate::error::ModifyAvailabilityZoneGroupError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyAvailabilityZoneGroupError::unhandled)?;
    Err(crate::error::ModifyAvailabilityZoneGroupError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_availability_zone_group_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyAvailabilityZoneGroupOutput,
    crate::error::ModifyAvailabilityZoneGroupError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_availability_zone_group_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_availability_zone_group(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ModifyAvailabilityZoneGroupError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_capacity_reservation_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyCapacityReservationOutput,
    crate::error::ModifyCapacityReservationError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyCapacityReservationError::unhandled)?;
    Err(crate::error::ModifyCapacityReservationError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_capacity_reservation_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyCapacityReservationOutput,
    crate::error::ModifyCapacityReservationError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_capacity_reservation_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_capacity_reservation(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ModifyCapacityReservationError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_capacity_reservation_fleet_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyCapacityReservationFleetOutput,
    crate::error::ModifyCapacityReservationFleetError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyCapacityReservationFleetError::unhandled)?;
    Err(crate::error::ModifyCapacityReservationFleetError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_capacity_reservation_fleet_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyCapacityReservationFleetOutput,
    crate::error::ModifyCapacityReservationFleetError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::modify_capacity_reservation_fleet_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_modify_capacity_reservation_fleet(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::ModifyCapacityReservationFleetError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_client_vpn_endpoint_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyClientVpnEndpointOutput,
    crate::error::ModifyClientVpnEndpointError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyClientVpnEndpointError::unhandled)?;
    Err(crate::error::ModifyClientVpnEndpointError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_client_vpn_endpoint_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyClientVpnEndpointOutput,
    crate::error::ModifyClientVpnEndpointError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_client_vpn_endpoint_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_client_vpn_endpoint(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ModifyClientVpnEndpointError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_default_credit_specification_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyDefaultCreditSpecificationOutput,
    crate::error::ModifyDefaultCreditSpecificationError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyDefaultCreditSpecificationError::unhandled)?;
    Err(crate::error::ModifyDefaultCreditSpecificationError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_default_credit_specification_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyDefaultCreditSpecificationOutput,
    crate::error::ModifyDefaultCreditSpecificationError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::modify_default_credit_specification_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_modify_default_credit_specification(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::ModifyDefaultCreditSpecificationError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_ebs_default_kms_key_id_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyEbsDefaultKmsKeyIdOutput,
    crate::error::ModifyEbsDefaultKmsKeyIdError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyEbsDefaultKmsKeyIdError::unhandled)?;
    Err(crate::error::ModifyEbsDefaultKmsKeyIdError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_ebs_default_kms_key_id_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyEbsDefaultKmsKeyIdOutput,
    crate::error::ModifyEbsDefaultKmsKeyIdError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_ebs_default_kms_key_id_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_ebs_default_kms_key_id(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ModifyEbsDefaultKmsKeyIdError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_fleet_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ModifyFleetOutput, crate::error::ModifyFleetError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyFleetError::unhandled)?;
    Err(crate::error::ModifyFleetError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_fleet_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ModifyFleetOutput, crate::error::ModifyFleetError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_fleet_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_fleet(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ModifyFleetError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_fpga_image_attribute_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyFpgaImageAttributeOutput,
    crate::error::ModifyFpgaImageAttributeError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyFpgaImageAttributeError::unhandled)?;
    Err(crate::error::ModifyFpgaImageAttributeError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_fpga_image_attribute_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyFpgaImageAttributeOutput,
    crate::error::ModifyFpgaImageAttributeError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_fpga_image_attribute_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_fpga_image_attribute(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ModifyFpgaImageAttributeError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_hosts_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ModifyHostsOutput, crate::error::ModifyHostsError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyHostsError::unhandled)?;
    Err(crate::error::ModifyHostsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_hosts_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ModifyHostsOutput, crate::error::ModifyHostsError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_hosts_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_hosts(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ModifyHostsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_identity_id_format_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyIdentityIdFormatOutput,
    crate::error::ModifyIdentityIdFormatError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyIdentityIdFormatError::unhandled)?;
    Err(crate::error::ModifyIdentityIdFormatError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_identity_id_format_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyIdentityIdFormatOutput,
    crate::error::ModifyIdentityIdFormatError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_identity_id_format_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_id_format_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ModifyIdFormatOutput, crate::error::ModifyIdFormatError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyIdFormatError::unhandled)?;
    Err(crate::error::ModifyIdFormatError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_id_format_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ModifyIdFormatOutput, crate::error::ModifyIdFormatError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_id_format_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_image_attribute_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyImageAttributeOutput,
    crate::error::ModifyImageAttributeError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyImageAttributeError::unhandled)?;
    Err(crate::error::ModifyImageAttributeError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_image_attribute_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyImageAttributeOutput,
    crate::error::ModifyImageAttributeError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_image_attribute_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_instance_attribute_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyInstanceAttributeOutput,
    crate::error::ModifyInstanceAttributeError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyInstanceAttributeError::unhandled)?;
    Err(crate::error::ModifyInstanceAttributeError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_instance_attribute_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyInstanceAttributeOutput,
    crate::error::ModifyInstanceAttributeError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_instance_attribute_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_instance_capacity_reservation_attributes_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyInstanceCapacityReservationAttributesOutput,
    crate::error::ModifyInstanceCapacityReservationAttributesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyInstanceCapacityReservationAttributesError::unhandled)?;
    Err(crate::error::ModifyInstanceCapacityReservationAttributesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_instance_capacity_reservation_attributes_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyInstanceCapacityReservationAttributesOutput,
    crate::error::ModifyInstanceCapacityReservationAttributesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::modify_instance_capacity_reservation_attributes_output::Builder::default(
            );
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_instance_capacity_reservation_attributes(response.body().as_ref(), output).map_err(crate::error::ModifyInstanceCapacityReservationAttributesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_instance_credit_specification_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyInstanceCreditSpecificationOutput,
    crate::error::ModifyInstanceCreditSpecificationError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyInstanceCreditSpecificationError::unhandled)?;
    Err(crate::error::ModifyInstanceCreditSpecificationError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_instance_credit_specification_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyInstanceCreditSpecificationOutput,
    crate::error::ModifyInstanceCreditSpecificationError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::modify_instance_credit_specification_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_modify_instance_credit_specification(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::ModifyInstanceCreditSpecificationError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_instance_event_start_time_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyInstanceEventStartTimeOutput,
    crate::error::ModifyInstanceEventStartTimeError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyInstanceEventStartTimeError::unhandled)?;
    Err(crate::error::ModifyInstanceEventStartTimeError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_instance_event_start_time_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyInstanceEventStartTimeOutput,
    crate::error::ModifyInstanceEventStartTimeError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_instance_event_start_time_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_modify_instance_event_start_time(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::ModifyInstanceEventStartTimeError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_instance_event_window_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyInstanceEventWindowOutput,
    crate::error::ModifyInstanceEventWindowError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyInstanceEventWindowError::unhandled)?;
    Err(crate::error::ModifyInstanceEventWindowError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_instance_event_window_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyInstanceEventWindowOutput,
    crate::error::ModifyInstanceEventWindowError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_instance_event_window_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_instance_event_window(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ModifyInstanceEventWindowError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_instance_metadata_options_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyInstanceMetadataOptionsOutput,
    crate::error::ModifyInstanceMetadataOptionsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyInstanceMetadataOptionsError::unhandled)?;
    Err(crate::error::ModifyInstanceMetadataOptionsError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_instance_metadata_options_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyInstanceMetadataOptionsOutput,
    crate::error::ModifyInstanceMetadataOptionsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_instance_metadata_options_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_modify_instance_metadata_options(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::ModifyInstanceMetadataOptionsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_instance_placement_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyInstancePlacementOutput,
    crate::error::ModifyInstancePlacementError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyInstancePlacementError::unhandled)?;
    Err(crate::error::ModifyInstancePlacementError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_instance_placement_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyInstancePlacementOutput,
    crate::error::ModifyInstancePlacementError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_instance_placement_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_instance_placement(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ModifyInstancePlacementError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_launch_template_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyLaunchTemplateOutput,
    crate::error::ModifyLaunchTemplateError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyLaunchTemplateError::unhandled)?;
    Err(crate::error::ModifyLaunchTemplateError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_launch_template_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyLaunchTemplateOutput,
    crate::error::ModifyLaunchTemplateError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_launch_template_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_launch_template(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ModifyLaunchTemplateError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_managed_prefix_list_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyManagedPrefixListOutput,
    crate::error::ModifyManagedPrefixListError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyManagedPrefixListError::unhandled)?;
    Err(crate::error::ModifyManagedPrefixListError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_managed_prefix_list_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyManagedPrefixListOutput,
    crate::error::ModifyManagedPrefixListError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_managed_prefix_list_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_managed_prefix_list(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ModifyManagedPrefixListError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_network_interface_attribute_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyNetworkInterfaceAttributeOutput,
    crate::error::ModifyNetworkInterfaceAttributeError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyNetworkInterfaceAttributeError::unhandled)?;
    Err(crate::error::ModifyNetworkInterfaceAttributeError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_network_interface_attribute_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyNetworkInterfaceAttributeOutput,
    crate::error::ModifyNetworkInterfaceAttributeError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::modify_network_interface_attribute_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_reserved_instances_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyReservedInstancesOutput,
    crate::error::ModifyReservedInstancesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyReservedInstancesError::unhandled)?;
    Err(crate::error::ModifyReservedInstancesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_reserved_instances_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyReservedInstancesOutput,
    crate::error::ModifyReservedInstancesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_reserved_instances_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_reserved_instances(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ModifyReservedInstancesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_security_group_rules_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifySecurityGroupRulesOutput,
    crate::error::ModifySecurityGroupRulesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifySecurityGroupRulesError::unhandled)?;
    Err(crate::error::ModifySecurityGroupRulesError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_security_group_rules_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifySecurityGroupRulesOutput,
    crate::error::ModifySecurityGroupRulesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_security_group_rules_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_security_group_rules(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ModifySecurityGroupRulesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_snapshot_attribute_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifySnapshotAttributeOutput,
    crate::error::ModifySnapshotAttributeError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifySnapshotAttributeError::unhandled)?;
    Err(crate::error::ModifySnapshotAttributeError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_snapshot_attribute_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifySnapshotAttributeOutput,
    crate::error::ModifySnapshotAttributeError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_snapshot_attribute_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_spot_fleet_request_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifySpotFleetRequestOutput,
    crate::error::ModifySpotFleetRequestError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifySpotFleetRequestError::unhandled)?;
    Err(crate::error::ModifySpotFleetRequestError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_spot_fleet_request_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifySpotFleetRequestOutput,
    crate::error::ModifySpotFleetRequestError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_spot_fleet_request_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_spot_fleet_request(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ModifySpotFleetRequestError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_subnet_attribute_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifySubnetAttributeOutput,
    crate::error::ModifySubnetAttributeError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifySubnetAttributeError::unhandled)?;
    Err(crate::error::ModifySubnetAttributeError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_subnet_attribute_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifySubnetAttributeOutput,
    crate::error::ModifySubnetAttributeError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_subnet_attribute_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_traffic_mirror_filter_network_services_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyTrafficMirrorFilterNetworkServicesOutput,
    crate::error::ModifyTrafficMirrorFilterNetworkServicesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyTrafficMirrorFilterNetworkServicesError::unhandled)?;
    Err(crate::error::ModifyTrafficMirrorFilterNetworkServicesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_traffic_mirror_filter_network_services_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyTrafficMirrorFilterNetworkServicesOutput,
    crate::error::ModifyTrafficMirrorFilterNetworkServicesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::modify_traffic_mirror_filter_network_services_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_traffic_mirror_filter_network_services(response.body().as_ref(), output).map_err(crate::error::ModifyTrafficMirrorFilterNetworkServicesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_traffic_mirror_filter_rule_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyTrafficMirrorFilterRuleOutput,
    crate::error::ModifyTrafficMirrorFilterRuleError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyTrafficMirrorFilterRuleError::unhandled)?;
    Err(crate::error::ModifyTrafficMirrorFilterRuleError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_traffic_mirror_filter_rule_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyTrafficMirrorFilterRuleOutput,
    crate::error::ModifyTrafficMirrorFilterRuleError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::modify_traffic_mirror_filter_rule_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_modify_traffic_mirror_filter_rule(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::ModifyTrafficMirrorFilterRuleError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_traffic_mirror_session_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyTrafficMirrorSessionOutput,
    crate::error::ModifyTrafficMirrorSessionError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyTrafficMirrorSessionError::unhandled)?;
    Err(crate::error::ModifyTrafficMirrorSessionError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_traffic_mirror_session_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyTrafficMirrorSessionOutput,
    crate::error::ModifyTrafficMirrorSessionError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_traffic_mirror_session_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_traffic_mirror_session(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ModifyTrafficMirrorSessionError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_transit_gateway_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyTransitGatewayOutput,
    crate::error::ModifyTransitGatewayError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyTransitGatewayError::unhandled)?;
    Err(crate::error::ModifyTransitGatewayError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_transit_gateway_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyTransitGatewayOutput,
    crate::error::ModifyTransitGatewayError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_transit_gateway_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_transit_gateway(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ModifyTransitGatewayError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_transit_gateway_prefix_list_reference_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyTransitGatewayPrefixListReferenceOutput,
    crate::error::ModifyTransitGatewayPrefixListReferenceError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyTransitGatewayPrefixListReferenceError::unhandled)?;
    Err(crate::error::ModifyTransitGatewayPrefixListReferenceError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_transit_gateway_prefix_list_reference_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyTransitGatewayPrefixListReferenceOutput,
    crate::error::ModifyTransitGatewayPrefixListReferenceError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::modify_transit_gateway_prefix_list_reference_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_transit_gateway_prefix_list_reference(response.body().as_ref(), output).map_err(crate::error::ModifyTransitGatewayPrefixListReferenceError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_transit_gateway_vpc_attachment_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyTransitGatewayVpcAttachmentOutput,
    crate::error::ModifyTransitGatewayVpcAttachmentError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyTransitGatewayVpcAttachmentError::unhandled)?;
    Err(crate::error::ModifyTransitGatewayVpcAttachmentError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_transit_gateway_vpc_attachment_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyTransitGatewayVpcAttachmentOutput,
    crate::error::ModifyTransitGatewayVpcAttachmentError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::modify_transit_gateway_vpc_attachment_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_transit_gateway_vpc_attachment(response.body().as_ref(), output).map_err(crate::error::ModifyTransitGatewayVpcAttachmentError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_volume_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ModifyVolumeOutput, crate::error::ModifyVolumeError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyVolumeError::unhandled)?;
    Err(crate::error::ModifyVolumeError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_volume_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ModifyVolumeOutput, crate::error::ModifyVolumeError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_volume_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_volume(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ModifyVolumeError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_volume_attribute_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyVolumeAttributeOutput,
    crate::error::ModifyVolumeAttributeError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyVolumeAttributeError::unhandled)?;
    Err(crate::error::ModifyVolumeAttributeError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_volume_attribute_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyVolumeAttributeOutput,
    crate::error::ModifyVolumeAttributeError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_volume_attribute_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_vpc_attribute_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyVpcAttributeOutput,
    crate::error::ModifyVpcAttributeError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyVpcAttributeError::unhandled)?;
    Err(crate::error::ModifyVpcAttributeError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_vpc_attribute_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyVpcAttributeOutput,
    crate::error::ModifyVpcAttributeError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_vpc_attribute_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_vpc_endpoint_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ModifyVpcEndpointOutput, crate::error::ModifyVpcEndpointError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyVpcEndpointError::unhandled)?;
    Err(crate::error::ModifyVpcEndpointError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_vpc_endpoint_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ModifyVpcEndpointOutput, crate::error::ModifyVpcEndpointError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_vpc_endpoint_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_vpc_endpoint(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ModifyVpcEndpointError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_vpc_endpoint_connection_notification_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyVpcEndpointConnectionNotificationOutput,
    crate::error::ModifyVpcEndpointConnectionNotificationError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyVpcEndpointConnectionNotificationError::unhandled)?;
    Err(crate::error::ModifyVpcEndpointConnectionNotificationError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_vpc_endpoint_connection_notification_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyVpcEndpointConnectionNotificationOutput,
    crate::error::ModifyVpcEndpointConnectionNotificationError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::modify_vpc_endpoint_connection_notification_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_vpc_endpoint_connection_notification(response.body().as_ref(), output).map_err(crate::error::ModifyVpcEndpointConnectionNotificationError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_vpc_endpoint_service_configuration_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyVpcEndpointServiceConfigurationOutput,
    crate::error::ModifyVpcEndpointServiceConfigurationError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyVpcEndpointServiceConfigurationError::unhandled)?;
    Err(crate::error::ModifyVpcEndpointServiceConfigurationError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_vpc_endpoint_service_configuration_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyVpcEndpointServiceConfigurationOutput,
    crate::error::ModifyVpcEndpointServiceConfigurationError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::modify_vpc_endpoint_service_configuration_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_vpc_endpoint_service_configuration(response.body().as_ref(), output).map_err(crate::error::ModifyVpcEndpointServiceConfigurationError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_vpc_endpoint_service_permissions_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyVpcEndpointServicePermissionsOutput,
    crate::error::ModifyVpcEndpointServicePermissionsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyVpcEndpointServicePermissionsError::unhandled)?;
    Err(crate::error::ModifyVpcEndpointServicePermissionsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_vpc_endpoint_service_permissions_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyVpcEndpointServicePermissionsOutput,
    crate::error::ModifyVpcEndpointServicePermissionsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::modify_vpc_endpoint_service_permissions_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_vpc_endpoint_service_permissions(response.body().as_ref(), output).map_err(crate::error::ModifyVpcEndpointServicePermissionsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_vpc_peering_connection_options_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyVpcPeeringConnectionOptionsOutput,
    crate::error::ModifyVpcPeeringConnectionOptionsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyVpcPeeringConnectionOptionsError::unhandled)?;
    Err(crate::error::ModifyVpcPeeringConnectionOptionsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_vpc_peering_connection_options_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyVpcPeeringConnectionOptionsOutput,
    crate::error::ModifyVpcPeeringConnectionOptionsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::modify_vpc_peering_connection_options_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_vpc_peering_connection_options(response.body().as_ref(), output).map_err(crate::error::ModifyVpcPeeringConnectionOptionsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_vpc_tenancy_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ModifyVpcTenancyOutput, crate::error::ModifyVpcTenancyError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyVpcTenancyError::unhandled)?;
    Err(crate::error::ModifyVpcTenancyError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_vpc_tenancy_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ModifyVpcTenancyOutput, crate::error::ModifyVpcTenancyError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_vpc_tenancy_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_vpc_tenancy(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ModifyVpcTenancyError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_vpn_connection_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyVpnConnectionOutput,
    crate::error::ModifyVpnConnectionError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyVpnConnectionError::unhandled)?;
    Err(crate::error::ModifyVpnConnectionError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_vpn_connection_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyVpnConnectionOutput,
    crate::error::ModifyVpnConnectionError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_vpn_connection_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_vpn_connection(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ModifyVpnConnectionError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_vpn_connection_options_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyVpnConnectionOptionsOutput,
    crate::error::ModifyVpnConnectionOptionsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyVpnConnectionOptionsError::unhandled)?;
    Err(crate::error::ModifyVpnConnectionOptionsError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_vpn_connection_options_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyVpnConnectionOptionsOutput,
    crate::error::ModifyVpnConnectionOptionsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_vpn_connection_options_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_vpn_connection_options(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ModifyVpnConnectionOptionsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_vpn_tunnel_certificate_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyVpnTunnelCertificateOutput,
    crate::error::ModifyVpnTunnelCertificateError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyVpnTunnelCertificateError::unhandled)?;
    Err(crate::error::ModifyVpnTunnelCertificateError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_vpn_tunnel_certificate_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyVpnTunnelCertificateOutput,
    crate::error::ModifyVpnTunnelCertificateError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_vpn_tunnel_certificate_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_vpn_tunnel_certificate(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ModifyVpnTunnelCertificateError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_vpn_tunnel_options_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyVpnTunnelOptionsOutput,
    crate::error::ModifyVpnTunnelOptionsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ModifyVpnTunnelOptionsError::unhandled)?;
    Err(crate::error::ModifyVpnTunnelOptionsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_modify_vpn_tunnel_options_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ModifyVpnTunnelOptionsOutput,
    crate::error::ModifyVpnTunnelOptionsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::modify_vpn_tunnel_options_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_modify_vpn_tunnel_options(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ModifyVpnTunnelOptionsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_monitor_instances_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::MonitorInstancesOutput, crate::error::MonitorInstancesError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::MonitorInstancesError::unhandled)?;
    Err(crate::error::MonitorInstancesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_monitor_instances_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::MonitorInstancesOutput, crate::error::MonitorInstancesError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::monitor_instances_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_monitor_instances(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::MonitorInstancesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_move_address_to_vpc_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::MoveAddressToVpcOutput, crate::error::MoveAddressToVpcError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::MoveAddressToVpcError::unhandled)?;
    Err(crate::error::MoveAddressToVpcError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_move_address_to_vpc_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::MoveAddressToVpcOutput, crate::error::MoveAddressToVpcError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::move_address_to_vpc_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_move_address_to_vpc(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::MoveAddressToVpcError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_provision_byoip_cidr_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ProvisionByoipCidrOutput,
    crate::error::ProvisionByoipCidrError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ProvisionByoipCidrError::unhandled)?;
    Err(crate::error::ProvisionByoipCidrError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_provision_byoip_cidr_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ProvisionByoipCidrOutput,
    crate::error::ProvisionByoipCidrError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::provision_byoip_cidr_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_provision_byoip_cidr(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ProvisionByoipCidrError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_purchase_host_reservation_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::PurchaseHostReservationOutput,
    crate::error::PurchaseHostReservationError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::PurchaseHostReservationError::unhandled)?;
    Err(crate::error::PurchaseHostReservationError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_purchase_host_reservation_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::PurchaseHostReservationOutput,
    crate::error::PurchaseHostReservationError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::purchase_host_reservation_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_purchase_host_reservation(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::PurchaseHostReservationError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_purchase_reserved_instances_offering_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::PurchaseReservedInstancesOfferingOutput,
    crate::error::PurchaseReservedInstancesOfferingError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::PurchaseReservedInstancesOfferingError::unhandled)?;
    Err(crate::error::PurchaseReservedInstancesOfferingError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_purchase_reserved_instances_offering_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::PurchaseReservedInstancesOfferingOutput,
    crate::error::PurchaseReservedInstancesOfferingError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::purchase_reserved_instances_offering_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_purchase_reserved_instances_offering(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::PurchaseReservedInstancesOfferingError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_purchase_scheduled_instances_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::PurchaseScheduledInstancesOutput,
    crate::error::PurchaseScheduledInstancesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::PurchaseScheduledInstancesError::unhandled)?;
    Err(crate::error::PurchaseScheduledInstancesError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_purchase_scheduled_instances_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::PurchaseScheduledInstancesOutput,
    crate::error::PurchaseScheduledInstancesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::purchase_scheduled_instances_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_purchase_scheduled_instances(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::PurchaseScheduledInstancesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_reboot_instances_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::RebootInstancesOutput, crate::error::RebootInstancesError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::RebootInstancesError::unhandled)?;
    Err(crate::error::RebootInstancesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_reboot_instances_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::RebootInstancesOutput, crate::error::RebootInstancesError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::reboot_instances_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_register_image_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::RegisterImageOutput, crate::error::RegisterImageError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::RegisterImageError::unhandled)?;
    Err(crate::error::RegisterImageError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_register_image_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::RegisterImageOutput, crate::error::RegisterImageError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::register_image_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_register_image(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::RegisterImageError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_register_instance_event_notification_attributes_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RegisterInstanceEventNotificationAttributesOutput,
    crate::error::RegisterInstanceEventNotificationAttributesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::RegisterInstanceEventNotificationAttributesError::unhandled)?;
    Err(crate::error::RegisterInstanceEventNotificationAttributesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_register_instance_event_notification_attributes_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RegisterInstanceEventNotificationAttributesOutput,
    crate::error::RegisterInstanceEventNotificationAttributesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::register_instance_event_notification_attributes_output::Builder::default(
            );
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_register_instance_event_notification_attributes(response.body().as_ref(), output).map_err(crate::error::RegisterInstanceEventNotificationAttributesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_register_transit_gateway_multicast_group_members_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RegisterTransitGatewayMulticastGroupMembersOutput,
    crate::error::RegisterTransitGatewayMulticastGroupMembersError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::RegisterTransitGatewayMulticastGroupMembersError::unhandled)?;
    Err(crate::error::RegisterTransitGatewayMulticastGroupMembersError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_register_transit_gateway_multicast_group_members_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RegisterTransitGatewayMulticastGroupMembersOutput,
    crate::error::RegisterTransitGatewayMulticastGroupMembersError,
> {
    Ok({
        #[allow(unused_mut)]let mut output = crate::output::register_transit_gateway_multicast_group_members_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_register_transit_gateway_multicast_group_members(response.body().as_ref(), output).map_err(crate::error::RegisterTransitGatewayMulticastGroupMembersError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_register_transit_gateway_multicast_group_sources_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RegisterTransitGatewayMulticastGroupSourcesOutput,
    crate::error::RegisterTransitGatewayMulticastGroupSourcesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::RegisterTransitGatewayMulticastGroupSourcesError::unhandled)?;
    Err(crate::error::RegisterTransitGatewayMulticastGroupSourcesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_register_transit_gateway_multicast_group_sources_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RegisterTransitGatewayMulticastGroupSourcesOutput,
    crate::error::RegisterTransitGatewayMulticastGroupSourcesError,
> {
    Ok({
        #[allow(unused_mut)]let mut output = crate::output::register_transit_gateway_multicast_group_sources_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_register_transit_gateway_multicast_group_sources(response.body().as_ref(), output).map_err(crate::error::RegisterTransitGatewayMulticastGroupSourcesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_reject_transit_gateway_multicast_domain_associations_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RejectTransitGatewayMulticastDomainAssociationsOutput,
    crate::error::RejectTransitGatewayMulticastDomainAssociationsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::RejectTransitGatewayMulticastDomainAssociationsError::unhandled)?;
    Err(crate::error::RejectTransitGatewayMulticastDomainAssociationsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_reject_transit_gateway_multicast_domain_associations_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RejectTransitGatewayMulticastDomainAssociationsOutput,
    crate::error::RejectTransitGatewayMulticastDomainAssociationsError,
> {
    Ok({
        #[allow(unused_mut)]let mut output = crate::output::reject_transit_gateway_multicast_domain_associations_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_reject_transit_gateway_multicast_domain_associations(response.body().as_ref(), output).map_err(crate::error::RejectTransitGatewayMulticastDomainAssociationsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_reject_transit_gateway_peering_attachment_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RejectTransitGatewayPeeringAttachmentOutput,
    crate::error::RejectTransitGatewayPeeringAttachmentError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::RejectTransitGatewayPeeringAttachmentError::unhandled)?;
    Err(crate::error::RejectTransitGatewayPeeringAttachmentError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_reject_transit_gateway_peering_attachment_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RejectTransitGatewayPeeringAttachmentOutput,
    crate::error::RejectTransitGatewayPeeringAttachmentError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::reject_transit_gateway_peering_attachment_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_reject_transit_gateway_peering_attachment(response.body().as_ref(), output).map_err(crate::error::RejectTransitGatewayPeeringAttachmentError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_reject_transit_gateway_vpc_attachment_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RejectTransitGatewayVpcAttachmentOutput,
    crate::error::RejectTransitGatewayVpcAttachmentError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::RejectTransitGatewayVpcAttachmentError::unhandled)?;
    Err(crate::error::RejectTransitGatewayVpcAttachmentError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_reject_transit_gateway_vpc_attachment_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RejectTransitGatewayVpcAttachmentOutput,
    crate::error::RejectTransitGatewayVpcAttachmentError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::reject_transit_gateway_vpc_attachment_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_reject_transit_gateway_vpc_attachment(response.body().as_ref(), output).map_err(crate::error::RejectTransitGatewayVpcAttachmentError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_reject_vpc_endpoint_connections_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RejectVpcEndpointConnectionsOutput,
    crate::error::RejectVpcEndpointConnectionsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::RejectVpcEndpointConnectionsError::unhandled)?;
    Err(crate::error::RejectVpcEndpointConnectionsError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_reject_vpc_endpoint_connections_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RejectVpcEndpointConnectionsOutput,
    crate::error::RejectVpcEndpointConnectionsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::reject_vpc_endpoint_connections_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_reject_vpc_endpoint_connections(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::RejectVpcEndpointConnectionsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_reject_vpc_peering_connection_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RejectVpcPeeringConnectionOutput,
    crate::error::RejectVpcPeeringConnectionError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::RejectVpcPeeringConnectionError::unhandled)?;
    Err(crate::error::RejectVpcPeeringConnectionError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_reject_vpc_peering_connection_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RejectVpcPeeringConnectionOutput,
    crate::error::RejectVpcPeeringConnectionError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::reject_vpc_peering_connection_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_reject_vpc_peering_connection(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::RejectVpcPeeringConnectionError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_release_address_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ReleaseAddressOutput, crate::error::ReleaseAddressError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ReleaseAddressError::unhandled)?;
    Err(crate::error::ReleaseAddressError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_release_address_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ReleaseAddressOutput, crate::error::ReleaseAddressError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::release_address_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_release_hosts_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ReleaseHostsOutput, crate::error::ReleaseHostsError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ReleaseHostsError::unhandled)?;
    Err(crate::error::ReleaseHostsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_release_hosts_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ReleaseHostsOutput, crate::error::ReleaseHostsError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::release_hosts_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_release_hosts(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ReleaseHostsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_replace_iam_instance_profile_association_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ReplaceIamInstanceProfileAssociationOutput,
    crate::error::ReplaceIamInstanceProfileAssociationError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ReplaceIamInstanceProfileAssociationError::unhandled)?;
    Err(crate::error::ReplaceIamInstanceProfileAssociationError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_replace_iam_instance_profile_association_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ReplaceIamInstanceProfileAssociationOutput,
    crate::error::ReplaceIamInstanceProfileAssociationError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::replace_iam_instance_profile_association_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_replace_iam_instance_profile_association(response.body().as_ref(), output).map_err(crate::error::ReplaceIamInstanceProfileAssociationError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_replace_network_acl_association_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ReplaceNetworkAclAssociationOutput,
    crate::error::ReplaceNetworkAclAssociationError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ReplaceNetworkAclAssociationError::unhandled)?;
    Err(crate::error::ReplaceNetworkAclAssociationError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_replace_network_acl_association_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ReplaceNetworkAclAssociationOutput,
    crate::error::ReplaceNetworkAclAssociationError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::replace_network_acl_association_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_replace_network_acl_association(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ReplaceNetworkAclAssociationError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_replace_network_acl_entry_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ReplaceNetworkAclEntryOutput,
    crate::error::ReplaceNetworkAclEntryError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ReplaceNetworkAclEntryError::unhandled)?;
    Err(crate::error::ReplaceNetworkAclEntryError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_replace_network_acl_entry_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ReplaceNetworkAclEntryOutput,
    crate::error::ReplaceNetworkAclEntryError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::replace_network_acl_entry_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_replace_route_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ReplaceRouteOutput, crate::error::ReplaceRouteError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ReplaceRouteError::unhandled)?;
    Err(crate::error::ReplaceRouteError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_replace_route_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ReplaceRouteOutput, crate::error::ReplaceRouteError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::replace_route_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_replace_route_table_association_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ReplaceRouteTableAssociationOutput,
    crate::error::ReplaceRouteTableAssociationError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ReplaceRouteTableAssociationError::unhandled)?;
    Err(crate::error::ReplaceRouteTableAssociationError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_replace_route_table_association_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ReplaceRouteTableAssociationOutput,
    crate::error::ReplaceRouteTableAssociationError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::replace_route_table_association_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_replace_route_table_association(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ReplaceRouteTableAssociationError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_replace_transit_gateway_route_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ReplaceTransitGatewayRouteOutput,
    crate::error::ReplaceTransitGatewayRouteError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ReplaceTransitGatewayRouteError::unhandled)?;
    Err(crate::error::ReplaceTransitGatewayRouteError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_replace_transit_gateway_route_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ReplaceTransitGatewayRouteOutput,
    crate::error::ReplaceTransitGatewayRouteError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::replace_transit_gateway_route_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_replace_transit_gateway_route(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ReplaceTransitGatewayRouteError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_report_instance_status_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ReportInstanceStatusOutput,
    crate::error::ReportInstanceStatusError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ReportInstanceStatusError::unhandled)?;
    Err(crate::error::ReportInstanceStatusError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_report_instance_status_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ReportInstanceStatusOutput,
    crate::error::ReportInstanceStatusError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::report_instance_status_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_request_spot_fleet_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::RequestSpotFleetOutput, crate::error::RequestSpotFleetError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::RequestSpotFleetError::unhandled)?;
    Err(crate::error::RequestSpotFleetError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_request_spot_fleet_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::RequestSpotFleetOutput, crate::error::RequestSpotFleetError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::request_spot_fleet_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_request_spot_fleet(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::RequestSpotFleetError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_request_spot_instances_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RequestSpotInstancesOutput,
    crate::error::RequestSpotInstancesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::RequestSpotInstancesError::unhandled)?;
    Err(crate::error::RequestSpotInstancesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_request_spot_instances_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RequestSpotInstancesOutput,
    crate::error::RequestSpotInstancesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::request_spot_instances_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_request_spot_instances(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::RequestSpotInstancesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_reset_address_attribute_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ResetAddressAttributeOutput,
    crate::error::ResetAddressAttributeError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ResetAddressAttributeError::unhandled)?;
    Err(crate::error::ResetAddressAttributeError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_reset_address_attribute_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ResetAddressAttributeOutput,
    crate::error::ResetAddressAttributeError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::reset_address_attribute_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_reset_address_attribute(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ResetAddressAttributeError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_reset_ebs_default_kms_key_id_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ResetEbsDefaultKmsKeyIdOutput,
    crate::error::ResetEbsDefaultKmsKeyIdError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ResetEbsDefaultKmsKeyIdError::unhandled)?;
    Err(crate::error::ResetEbsDefaultKmsKeyIdError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_reset_ebs_default_kms_key_id_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ResetEbsDefaultKmsKeyIdOutput,
    crate::error::ResetEbsDefaultKmsKeyIdError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::reset_ebs_default_kms_key_id_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_reset_ebs_default_kms_key_id(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ResetEbsDefaultKmsKeyIdError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_reset_fpga_image_attribute_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ResetFpgaImageAttributeOutput,
    crate::error::ResetFpgaImageAttributeError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ResetFpgaImageAttributeError::unhandled)?;
    Err(crate::error::ResetFpgaImageAttributeError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_reset_fpga_image_attribute_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ResetFpgaImageAttributeOutput,
    crate::error::ResetFpgaImageAttributeError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::reset_fpga_image_attribute_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_reset_fpga_image_attribute(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ResetFpgaImageAttributeError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_reset_image_attribute_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ResetImageAttributeOutput,
    crate::error::ResetImageAttributeError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ResetImageAttributeError::unhandled)?;
    Err(crate::error::ResetImageAttributeError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_reset_image_attribute_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ResetImageAttributeOutput,
    crate::error::ResetImageAttributeError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::reset_image_attribute_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_reset_instance_attribute_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ResetInstanceAttributeOutput,
    crate::error::ResetInstanceAttributeError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ResetInstanceAttributeError::unhandled)?;
    Err(crate::error::ResetInstanceAttributeError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_reset_instance_attribute_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ResetInstanceAttributeOutput,
    crate::error::ResetInstanceAttributeError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::reset_instance_attribute_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_reset_network_interface_attribute_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ResetNetworkInterfaceAttributeOutput,
    crate::error::ResetNetworkInterfaceAttributeError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ResetNetworkInterfaceAttributeError::unhandled)?;
    Err(crate::error::ResetNetworkInterfaceAttributeError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_reset_network_interface_attribute_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ResetNetworkInterfaceAttributeOutput,
    crate::error::ResetNetworkInterfaceAttributeError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::reset_network_interface_attribute_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_reset_snapshot_attribute_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ResetSnapshotAttributeOutput,
    crate::error::ResetSnapshotAttributeError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::ResetSnapshotAttributeError::unhandled)?;
    Err(crate::error::ResetSnapshotAttributeError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_reset_snapshot_attribute_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ResetSnapshotAttributeOutput,
    crate::error::ResetSnapshotAttributeError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::reset_snapshot_attribute_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_restore_address_to_classic_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RestoreAddressToClassicOutput,
    crate::error::RestoreAddressToClassicError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::RestoreAddressToClassicError::unhandled)?;
    Err(crate::error::RestoreAddressToClassicError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_restore_address_to_classic_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RestoreAddressToClassicOutput,
    crate::error::RestoreAddressToClassicError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::restore_address_to_classic_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_restore_address_to_classic(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::RestoreAddressToClassicError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_restore_managed_prefix_list_version_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RestoreManagedPrefixListVersionOutput,
    crate::error::RestoreManagedPrefixListVersionError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::RestoreManagedPrefixListVersionError::unhandled)?;
    Err(crate::error::RestoreManagedPrefixListVersionError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_restore_managed_prefix_list_version_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RestoreManagedPrefixListVersionOutput,
    crate::error::RestoreManagedPrefixListVersionError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::restore_managed_prefix_list_version_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_restore_managed_prefix_list_version(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::RestoreManagedPrefixListVersionError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_revoke_client_vpn_ingress_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RevokeClientVpnIngressOutput,
    crate::error::RevokeClientVpnIngressError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::RevokeClientVpnIngressError::unhandled)?;
    Err(crate::error::RevokeClientVpnIngressError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_revoke_client_vpn_ingress_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RevokeClientVpnIngressOutput,
    crate::error::RevokeClientVpnIngressError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::revoke_client_vpn_ingress_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_revoke_client_vpn_ingress(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::RevokeClientVpnIngressError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_revoke_security_group_egress_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RevokeSecurityGroupEgressOutput,
    crate::error::RevokeSecurityGroupEgressError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::RevokeSecurityGroupEgressError::unhandled)?;
    Err(crate::error::RevokeSecurityGroupEgressError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_revoke_security_group_egress_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RevokeSecurityGroupEgressOutput,
    crate::error::RevokeSecurityGroupEgressError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::revoke_security_group_egress_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_revoke_security_group_egress(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::RevokeSecurityGroupEgressError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_revoke_security_group_ingress_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RevokeSecurityGroupIngressOutput,
    crate::error::RevokeSecurityGroupIngressError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::RevokeSecurityGroupIngressError::unhandled)?;
    Err(crate::error::RevokeSecurityGroupIngressError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_revoke_security_group_ingress_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RevokeSecurityGroupIngressOutput,
    crate::error::RevokeSecurityGroupIngressError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::revoke_security_group_ingress_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_revoke_security_group_ingress(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::RevokeSecurityGroupIngressError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_run_instances_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::RunInstancesOutput, crate::error::RunInstancesError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::RunInstancesError::unhandled)?;
    Err(crate::error::RunInstancesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_run_instances_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::RunInstancesOutput, crate::error::RunInstancesError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::run_instances_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_run_instances(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::RunInstancesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_run_scheduled_instances_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RunScheduledInstancesOutput,
    crate::error::RunScheduledInstancesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::RunScheduledInstancesError::unhandled)?;
    Err(crate::error::RunScheduledInstancesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_run_scheduled_instances_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RunScheduledInstancesOutput,
    crate::error::RunScheduledInstancesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::run_scheduled_instances_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_run_scheduled_instances(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::RunScheduledInstancesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_search_local_gateway_routes_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::SearchLocalGatewayRoutesOutput,
    crate::error::SearchLocalGatewayRoutesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::SearchLocalGatewayRoutesError::unhandled)?;
    Err(crate::error::SearchLocalGatewayRoutesError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_search_local_gateway_routes_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::SearchLocalGatewayRoutesOutput,
    crate::error::SearchLocalGatewayRoutesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::search_local_gateway_routes_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_search_local_gateway_routes(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::SearchLocalGatewayRoutesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_search_transit_gateway_multicast_groups_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::SearchTransitGatewayMulticastGroupsOutput,
    crate::error::SearchTransitGatewayMulticastGroupsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::SearchTransitGatewayMulticastGroupsError::unhandled)?;
    Err(crate::error::SearchTransitGatewayMulticastGroupsError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_search_transit_gateway_multicast_groups_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::SearchTransitGatewayMulticastGroupsOutput,
    crate::error::SearchTransitGatewayMulticastGroupsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::search_transit_gateway_multicast_groups_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_search_transit_gateway_multicast_groups(response.body().as_ref(), output).map_err(crate::error::SearchTransitGatewayMulticastGroupsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_search_transit_gateway_routes_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::SearchTransitGatewayRoutesOutput,
    crate::error::SearchTransitGatewayRoutesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::SearchTransitGatewayRoutesError::unhandled)?;
    Err(crate::error::SearchTransitGatewayRoutesError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_search_transit_gateway_routes_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::SearchTransitGatewayRoutesOutput,
    crate::error::SearchTransitGatewayRoutesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::search_transit_gateway_routes_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_search_transit_gateway_routes(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::SearchTransitGatewayRoutesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_send_diagnostic_interrupt_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::SendDiagnosticInterruptOutput,
    crate::error::SendDiagnosticInterruptError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::SendDiagnosticInterruptError::unhandled)?;
    Err(crate::error::SendDiagnosticInterruptError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_send_diagnostic_interrupt_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::SendDiagnosticInterruptOutput,
    crate::error::SendDiagnosticInterruptError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::send_diagnostic_interrupt_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_instances_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StartInstancesOutput, crate::error::StartInstancesError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::StartInstancesError::unhandled)?;
    Err(crate::error::StartInstancesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_instances_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StartInstancesOutput, crate::error::StartInstancesError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::start_instances_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_start_instances(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::StartInstancesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_network_insights_analysis_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::StartNetworkInsightsAnalysisOutput,
    crate::error::StartNetworkInsightsAnalysisError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::StartNetworkInsightsAnalysisError::unhandled)?;
    Err(crate::error::StartNetworkInsightsAnalysisError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_network_insights_analysis_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::StartNetworkInsightsAnalysisOutput,
    crate::error::StartNetworkInsightsAnalysisError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::start_network_insights_analysis_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_start_network_insights_analysis(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::StartNetworkInsightsAnalysisError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_vpc_endpoint_service_private_dns_verification_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::StartVpcEndpointServicePrivateDnsVerificationOutput,
    crate::error::StartVpcEndpointServicePrivateDnsVerificationError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::StartVpcEndpointServicePrivateDnsVerificationError::unhandled)?;
    Err(crate::error::StartVpcEndpointServicePrivateDnsVerificationError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_vpc_endpoint_service_private_dns_verification_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::StartVpcEndpointServicePrivateDnsVerificationOutput,
    crate::error::StartVpcEndpointServicePrivateDnsVerificationError,
> {
    Ok({
        #[allow(unused_mut)]let mut output = crate::output::start_vpc_endpoint_service_private_dns_verification_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_start_vpc_endpoint_service_private_dns_verification(response.body().as_ref(), output).map_err(crate::error::StartVpcEndpointServicePrivateDnsVerificationError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_instances_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StopInstancesOutput, crate::error::StopInstancesError> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::StopInstancesError::unhandled)?;
    Err(crate::error::StopInstancesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_instances_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StopInstancesOutput, crate::error::StopInstancesError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::stop_instances_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_stop_instances(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::StopInstancesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_terminate_client_vpn_connections_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::TerminateClientVpnConnectionsOutput,
    crate::error::TerminateClientVpnConnectionsError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::TerminateClientVpnConnectionsError::unhandled)?;
    Err(crate::error::TerminateClientVpnConnectionsError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_terminate_client_vpn_connections_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::TerminateClientVpnConnectionsOutput,
    crate::error::TerminateClientVpnConnectionsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::terminate_client_vpn_connections_output::Builder::default();
        let _ = response;
        output =
            crate::xml_deser::deser_operation_crate_operation_terminate_client_vpn_connections(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::TerminateClientVpnConnectionsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_terminate_instances_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::TerminateInstancesOutput,
    crate::error::TerminateInstancesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::TerminateInstancesError::unhandled)?;
    Err(crate::error::TerminateInstancesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_terminate_instances_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::TerminateInstancesOutput,
    crate::error::TerminateInstancesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::terminate_instances_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_terminate_instances(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::TerminateInstancesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_unassign_ipv6_addresses_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::UnassignIpv6AddressesOutput,
    crate::error::UnassignIpv6AddressesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::UnassignIpv6AddressesError::unhandled)?;
    Err(crate::error::UnassignIpv6AddressesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_unassign_ipv6_addresses_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::UnassignIpv6AddressesOutput,
    crate::error::UnassignIpv6AddressesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::unassign_ipv6_addresses_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_unassign_ipv6_addresses(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::UnassignIpv6AddressesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_unassign_private_ip_addresses_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::UnassignPrivateIpAddressesOutput,
    crate::error::UnassignPrivateIpAddressesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::UnassignPrivateIpAddressesError::unhandled)?;
    Err(crate::error::UnassignPrivateIpAddressesError::generic(
        generic,
    ))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_unassign_private_ip_addresses_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::UnassignPrivateIpAddressesOutput,
    crate::error::UnassignPrivateIpAddressesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::unassign_private_ip_addresses_output::Builder::default();
        let _ = response;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_unmonitor_instances_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::UnmonitorInstancesOutput,
    crate::error::UnmonitorInstancesError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::UnmonitorInstancesError::unhandled)?;
    Err(crate::error::UnmonitorInstancesError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_unmonitor_instances_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::UnmonitorInstancesOutput,
    crate::error::UnmonitorInstancesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::unmonitor_instances_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_unmonitor_instances(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::UnmonitorInstancesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_security_group_rule_descriptions_egress_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::UpdateSecurityGroupRuleDescriptionsEgressOutput,
    crate::error::UpdateSecurityGroupRuleDescriptionsEgressError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::UpdateSecurityGroupRuleDescriptionsEgressError::unhandled)?;
    Err(crate::error::UpdateSecurityGroupRuleDescriptionsEgressError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_security_group_rule_descriptions_egress_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::UpdateSecurityGroupRuleDescriptionsEgressOutput,
    crate::error::UpdateSecurityGroupRuleDescriptionsEgressError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::update_security_group_rule_descriptions_egress_output::Builder::default(
            );
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_update_security_group_rule_descriptions_egress(response.body().as_ref(), output).map_err(crate::error::UpdateSecurityGroupRuleDescriptionsEgressError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_security_group_rule_descriptions_ingress_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::UpdateSecurityGroupRuleDescriptionsIngressOutput,
    crate::error::UpdateSecurityGroupRuleDescriptionsIngressError,
> {
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::UpdateSecurityGroupRuleDescriptionsIngressError::unhandled)?;
    Err(crate::error::UpdateSecurityGroupRuleDescriptionsIngressError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_security_group_rule_descriptions_ingress_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::UpdateSecurityGroupRuleDescriptionsIngressOutput,
    crate::error::UpdateSecurityGroupRuleDescriptionsIngressError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::update_security_group_rule_descriptions_ingress_output::Builder::default(
            );
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_update_security_group_rule_descriptions_ingress(response.body().as_ref(), output).map_err(crate::error::UpdateSecurityGroupRuleDescriptionsIngressError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_withdraw_byoip_cidr_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::WithdrawByoipCidrOutput, crate::error::WithdrawByoipCidrError>
{
    let generic = crate::xml_deser::parse_http_generic_error(response)
        .map_err(crate::error::WithdrawByoipCidrError::unhandled)?;
    Err(crate::error::WithdrawByoipCidrError::generic(generic))
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_withdraw_byoip_cidr_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::WithdrawByoipCidrOutput, crate::error::WithdrawByoipCidrError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::withdraw_byoip_cidr_output::Builder::default();
        let _ = response;
        output = crate::xml_deser::deser_operation_crate_operation_withdraw_byoip_cidr(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::WithdrawByoipCidrError::unhandled)?;
        output.build()
    })
}