aws-sdk-networkmanager 0.24.0

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
pub(crate) fn deser_header_accept_attachment_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_1 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_1.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_1.len()
        )))
    } else {
        let mut var_1 = var_1;
        Ok(var_1.pop())
    }
}

pub(crate) fn deser_header_accept_attachment_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_2 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_2.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_2.len()
        )))
    } else {
        let mut var_2 = var_2;
        Ok(var_2.pop())
    }
}

pub(crate) fn deser_header_associate_connect_peer_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_3 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_3.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_3.len()
        )))
    } else {
        let mut var_3 = var_3;
        Ok(var_3.pop())
    }
}

pub(crate) fn deser_header_associate_connect_peer_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_4 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_4.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_4.len()
        )))
    } else {
        let mut var_4 = var_4;
        Ok(var_4.pop())
    }
}

pub(crate) fn deser_header_associate_customer_gateway_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_5 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_5.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_5.len()
        )))
    } else {
        let mut var_5 = var_5;
        Ok(var_5.pop())
    }
}

pub(crate) fn deser_header_associate_customer_gateway_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_6 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_6.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_6.len()
        )))
    } else {
        let mut var_6 = var_6;
        Ok(var_6.pop())
    }
}

pub(crate) fn deser_header_associate_link_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_7 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_7.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_7.len()
        )))
    } else {
        let mut var_7 = var_7;
        Ok(var_7.pop())
    }
}

pub(crate) fn deser_header_associate_link_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_8 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_8.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_8.len()
        )))
    } else {
        let mut var_8 = var_8;
        Ok(var_8.pop())
    }
}

pub(crate) fn deser_header_associate_transit_gateway_connect_peer_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_9 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_9.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_9.len()
        )))
    } else {
        let mut var_9 = var_9;
        Ok(var_9.pop())
    }
}

pub(crate) fn deser_header_associate_transit_gateway_connect_peer_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_10 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_10.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_10.len()
        )))
    } else {
        let mut var_10 = var_10;
        Ok(var_10.pop())
    }
}

pub(crate) fn deser_header_create_connect_attachment_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_11 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_11.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_11.len()
        )))
    } else {
        let mut var_11 = var_11;
        Ok(var_11.pop())
    }
}

pub(crate) fn deser_header_create_connect_attachment_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_12 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_12.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_12.len()
        )))
    } else {
        let mut var_12 = var_12;
        Ok(var_12.pop())
    }
}

pub(crate) fn deser_header_create_connection_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_13 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_13.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_13.len()
        )))
    } else {
        let mut var_13 = var_13;
        Ok(var_13.pop())
    }
}

pub(crate) fn deser_header_create_connection_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_14 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_14.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_14.len()
        )))
    } else {
        let mut var_14 = var_14;
        Ok(var_14.pop())
    }
}

pub(crate) fn deser_header_create_connect_peer_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_15 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_15.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_15.len()
        )))
    } else {
        let mut var_15 = var_15;
        Ok(var_15.pop())
    }
}

pub(crate) fn deser_header_create_connect_peer_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_16 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_16.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_16.len()
        )))
    } else {
        let mut var_16 = var_16;
        Ok(var_16.pop())
    }
}

pub(crate) fn deser_header_create_core_network_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_17 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_17.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_17.len()
        )))
    } else {
        let mut var_17 = var_17;
        Ok(var_17.pop())
    }
}

pub(crate) fn deser_header_create_core_network_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_18 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_18.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_18.len()
        )))
    } else {
        let mut var_18 = var_18;
        Ok(var_18.pop())
    }
}

pub(crate) fn deser_header_create_device_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_19 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_19.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_19.len()
        )))
    } else {
        let mut var_19 = var_19;
        Ok(var_19.pop())
    }
}

pub(crate) fn deser_header_create_device_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_20 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_20.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_20.len()
        )))
    } else {
        let mut var_20 = var_20;
        Ok(var_20.pop())
    }
}

pub(crate) fn deser_header_create_global_network_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_21 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_21.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_21.len()
        )))
    } else {
        let mut var_21 = var_21;
        Ok(var_21.pop())
    }
}

pub(crate) fn deser_header_create_global_network_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_22 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_22.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_22.len()
        )))
    } else {
        let mut var_22 = var_22;
        Ok(var_22.pop())
    }
}

pub(crate) fn deser_header_create_link_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_23 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_23.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_23.len()
        )))
    } else {
        let mut var_23 = var_23;
        Ok(var_23.pop())
    }
}

pub(crate) fn deser_header_create_link_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_24 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_24.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_24.len()
        )))
    } else {
        let mut var_24 = var_24;
        Ok(var_24.pop())
    }
}

pub(crate) fn deser_header_create_site_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_25 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_25.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_25.len()
        )))
    } else {
        let mut var_25 = var_25;
        Ok(var_25.pop())
    }
}

pub(crate) fn deser_header_create_site_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_26 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_26.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_26.len()
        )))
    } else {
        let mut var_26 = var_26;
        Ok(var_26.pop())
    }
}

pub(crate) fn deser_header_create_site_to_site_vpn_attachment_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_27 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_27.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_27.len()
        )))
    } else {
        let mut var_27 = var_27;
        Ok(var_27.pop())
    }
}

pub(crate) fn deser_header_create_site_to_site_vpn_attachment_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_28 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_28.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_28.len()
        )))
    } else {
        let mut var_28 = var_28;
        Ok(var_28.pop())
    }
}

pub(crate) fn deser_header_create_transit_gateway_peering_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_29 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_29.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_29.len()
        )))
    } else {
        let mut var_29 = var_29;
        Ok(var_29.pop())
    }
}

pub(crate) fn deser_header_create_transit_gateway_peering_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_30 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_30.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_30.len()
        )))
    } else {
        let mut var_30 = var_30;
        Ok(var_30.pop())
    }
}

pub(crate) fn deser_header_create_transit_gateway_route_table_attachment_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_31 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_31.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_31.len()
        )))
    } else {
        let mut var_31 = var_31;
        Ok(var_31.pop())
    }
}

pub(crate) fn deser_header_create_transit_gateway_route_table_attachment_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_32 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_32.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_32.len()
        )))
    } else {
        let mut var_32 = var_32;
        Ok(var_32.pop())
    }
}

pub(crate) fn deser_header_create_vpc_attachment_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_33 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_33.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_33.len()
        )))
    } else {
        let mut var_33 = var_33;
        Ok(var_33.pop())
    }
}

pub(crate) fn deser_header_create_vpc_attachment_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_34 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_34.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_34.len()
        )))
    } else {
        let mut var_34 = var_34;
        Ok(var_34.pop())
    }
}

pub(crate) fn deser_header_delete_attachment_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_35 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_35.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_35.len()
        )))
    } else {
        let mut var_35 = var_35;
        Ok(var_35.pop())
    }
}

pub(crate) fn deser_header_delete_attachment_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_36 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_36.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_36.len()
        )))
    } else {
        let mut var_36 = var_36;
        Ok(var_36.pop())
    }
}

pub(crate) fn deser_header_delete_connection_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_37 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_37.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_37.len()
        )))
    } else {
        let mut var_37 = var_37;
        Ok(var_37.pop())
    }
}

pub(crate) fn deser_header_delete_connection_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_38 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_38.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_38.len()
        )))
    } else {
        let mut var_38 = var_38;
        Ok(var_38.pop())
    }
}

pub(crate) fn deser_header_delete_connect_peer_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_39 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_39.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_39.len()
        )))
    } else {
        let mut var_39 = var_39;
        Ok(var_39.pop())
    }
}

pub(crate) fn deser_header_delete_connect_peer_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_40 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_40.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_40.len()
        )))
    } else {
        let mut var_40 = var_40;
        Ok(var_40.pop())
    }
}

pub(crate) fn deser_header_delete_core_network_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_41 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_41.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_41.len()
        )))
    } else {
        let mut var_41 = var_41;
        Ok(var_41.pop())
    }
}

pub(crate) fn deser_header_delete_core_network_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_42 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_42.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_42.len()
        )))
    } else {
        let mut var_42 = var_42;
        Ok(var_42.pop())
    }
}

pub(crate) fn deser_header_delete_core_network_policy_version_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_43 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_43.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_43.len()
        )))
    } else {
        let mut var_43 = var_43;
        Ok(var_43.pop())
    }
}

pub(crate) fn deser_header_delete_core_network_policy_version_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_44 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_44.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_44.len()
        )))
    } else {
        let mut var_44 = var_44;
        Ok(var_44.pop())
    }
}

pub(crate) fn deser_header_delete_device_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_45 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_45.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_45.len()
        )))
    } else {
        let mut var_45 = var_45;
        Ok(var_45.pop())
    }
}

pub(crate) fn deser_header_delete_device_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_46 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_46.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_46.len()
        )))
    } else {
        let mut var_46 = var_46;
        Ok(var_46.pop())
    }
}

pub(crate) fn deser_header_delete_global_network_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_47 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_47.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_47.len()
        )))
    } else {
        let mut var_47 = var_47;
        Ok(var_47.pop())
    }
}

pub(crate) fn deser_header_delete_global_network_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_48 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_48.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_48.len()
        )))
    } else {
        let mut var_48 = var_48;
        Ok(var_48.pop())
    }
}

pub(crate) fn deser_header_delete_link_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_49 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_49.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_49.len()
        )))
    } else {
        let mut var_49 = var_49;
        Ok(var_49.pop())
    }
}

pub(crate) fn deser_header_delete_link_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_50 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_50.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_50.len()
        )))
    } else {
        let mut var_50 = var_50;
        Ok(var_50.pop())
    }
}

pub(crate) fn deser_header_delete_peering_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_51 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_51.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_51.len()
        )))
    } else {
        let mut var_51 = var_51;
        Ok(var_51.pop())
    }
}

pub(crate) fn deser_header_delete_peering_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_52 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_52.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_52.len()
        )))
    } else {
        let mut var_52 = var_52;
        Ok(var_52.pop())
    }
}

pub(crate) fn deser_header_delete_resource_policy_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_53 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_53.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_53.len()
        )))
    } else {
        let mut var_53 = var_53;
        Ok(var_53.pop())
    }
}

pub(crate) fn deser_header_delete_resource_policy_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_54 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_54.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_54.len()
        )))
    } else {
        let mut var_54 = var_54;
        Ok(var_54.pop())
    }
}

pub(crate) fn deser_header_delete_site_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_55 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_55.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_55.len()
        )))
    } else {
        let mut var_55 = var_55;
        Ok(var_55.pop())
    }
}

pub(crate) fn deser_header_delete_site_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_56 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_56.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_56.len()
        )))
    } else {
        let mut var_56 = var_56;
        Ok(var_56.pop())
    }
}

pub(crate) fn deser_header_deregister_transit_gateway_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_57 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_57.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_57.len()
        )))
    } else {
        let mut var_57 = var_57;
        Ok(var_57.pop())
    }
}

pub(crate) fn deser_header_deregister_transit_gateway_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_58 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_58.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_58.len()
        )))
    } else {
        let mut var_58 = var_58;
        Ok(var_58.pop())
    }
}

pub(crate) fn deser_header_describe_global_networks_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_59 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_59.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_59.len()
        )))
    } else {
        let mut var_59 = var_59;
        Ok(var_59.pop())
    }
}

pub(crate) fn deser_header_describe_global_networks_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_60 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_60.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_60.len()
        )))
    } else {
        let mut var_60 = var_60;
        Ok(var_60.pop())
    }
}

pub(crate) fn deser_header_disassociate_connect_peer_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_61 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_61.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_61.len()
        )))
    } else {
        let mut var_61 = var_61;
        Ok(var_61.pop())
    }
}

pub(crate) fn deser_header_disassociate_connect_peer_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_62 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_62.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_62.len()
        )))
    } else {
        let mut var_62 = var_62;
        Ok(var_62.pop())
    }
}

pub(crate) fn deser_header_disassociate_customer_gateway_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_63 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_63.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_63.len()
        )))
    } else {
        let mut var_63 = var_63;
        Ok(var_63.pop())
    }
}

pub(crate) fn deser_header_disassociate_customer_gateway_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_64 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_64.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_64.len()
        )))
    } else {
        let mut var_64 = var_64;
        Ok(var_64.pop())
    }
}

pub(crate) fn deser_header_disassociate_link_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_65 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_65.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_65.len()
        )))
    } else {
        let mut var_65 = var_65;
        Ok(var_65.pop())
    }
}

pub(crate) fn deser_header_disassociate_link_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_66 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_66.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_66.len()
        )))
    } else {
        let mut var_66 = var_66;
        Ok(var_66.pop())
    }
}

pub(crate) fn deser_header_disassociate_transit_gateway_connect_peer_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_67 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_67.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_67.len()
        )))
    } else {
        let mut var_67 = var_67;
        Ok(var_67.pop())
    }
}

pub(crate) fn deser_header_disassociate_transit_gateway_connect_peer_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_68 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_68.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_68.len()
        )))
    } else {
        let mut var_68 = var_68;
        Ok(var_68.pop())
    }
}

pub(crate) fn deser_header_execute_core_network_change_set_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_69 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_69.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_69.len()
        )))
    } else {
        let mut var_69 = var_69;
        Ok(var_69.pop())
    }
}

pub(crate) fn deser_header_execute_core_network_change_set_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_70 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_70.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_70.len()
        )))
    } else {
        let mut var_70 = var_70;
        Ok(var_70.pop())
    }
}

pub(crate) fn deser_header_get_connect_attachment_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_71 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_71.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_71.len()
        )))
    } else {
        let mut var_71 = var_71;
        Ok(var_71.pop())
    }
}

pub(crate) fn deser_header_get_connect_attachment_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_72 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_72.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_72.len()
        )))
    } else {
        let mut var_72 = var_72;
        Ok(var_72.pop())
    }
}

pub(crate) fn deser_header_get_connections_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_73 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_73.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_73.len()
        )))
    } else {
        let mut var_73 = var_73;
        Ok(var_73.pop())
    }
}

pub(crate) fn deser_header_get_connections_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_74 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_74.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_74.len()
        )))
    } else {
        let mut var_74 = var_74;
        Ok(var_74.pop())
    }
}

pub(crate) fn deser_header_get_connect_peer_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_75 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_75.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_75.len()
        )))
    } else {
        let mut var_75 = var_75;
        Ok(var_75.pop())
    }
}

pub(crate) fn deser_header_get_connect_peer_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_76 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_76.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_76.len()
        )))
    } else {
        let mut var_76 = var_76;
        Ok(var_76.pop())
    }
}

pub(crate) fn deser_header_get_connect_peer_associations_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_77 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_77.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_77.len()
        )))
    } else {
        let mut var_77 = var_77;
        Ok(var_77.pop())
    }
}

pub(crate) fn deser_header_get_connect_peer_associations_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_78 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_78.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_78.len()
        )))
    } else {
        let mut var_78 = var_78;
        Ok(var_78.pop())
    }
}

pub(crate) fn deser_header_get_core_network_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_79 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_79.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_79.len()
        )))
    } else {
        let mut var_79 = var_79;
        Ok(var_79.pop())
    }
}

pub(crate) fn deser_header_get_core_network_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_80 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_80.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_80.len()
        )))
    } else {
        let mut var_80 = var_80;
        Ok(var_80.pop())
    }
}

pub(crate) fn deser_header_get_core_network_change_events_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_81 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_81.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_81.len()
        )))
    } else {
        let mut var_81 = var_81;
        Ok(var_81.pop())
    }
}

pub(crate) fn deser_header_get_core_network_change_events_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_82 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_82.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_82.len()
        )))
    } else {
        let mut var_82 = var_82;
        Ok(var_82.pop())
    }
}

pub(crate) fn deser_header_get_core_network_change_set_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_83 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_83.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_83.len()
        )))
    } else {
        let mut var_83 = var_83;
        Ok(var_83.pop())
    }
}

pub(crate) fn deser_header_get_core_network_change_set_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_84 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_84.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_84.len()
        )))
    } else {
        let mut var_84 = var_84;
        Ok(var_84.pop())
    }
}

pub(crate) fn deser_header_get_core_network_policy_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_85 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_85.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_85.len()
        )))
    } else {
        let mut var_85 = var_85;
        Ok(var_85.pop())
    }
}

pub(crate) fn deser_header_get_core_network_policy_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_86 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_86.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_86.len()
        )))
    } else {
        let mut var_86 = var_86;
        Ok(var_86.pop())
    }
}

pub(crate) fn deser_header_get_customer_gateway_associations_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_87 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_87.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_87.len()
        )))
    } else {
        let mut var_87 = var_87;
        Ok(var_87.pop())
    }
}

pub(crate) fn deser_header_get_customer_gateway_associations_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_88 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_88.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_88.len()
        )))
    } else {
        let mut var_88 = var_88;
        Ok(var_88.pop())
    }
}

pub(crate) fn deser_header_get_devices_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_89 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_89.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_89.len()
        )))
    } else {
        let mut var_89 = var_89;
        Ok(var_89.pop())
    }
}

pub(crate) fn deser_header_get_devices_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_90 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_90.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_90.len()
        )))
    } else {
        let mut var_90 = var_90;
        Ok(var_90.pop())
    }
}

pub(crate) fn deser_header_get_link_associations_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_91 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_91.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_91.len()
        )))
    } else {
        let mut var_91 = var_91;
        Ok(var_91.pop())
    }
}

pub(crate) fn deser_header_get_link_associations_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_92 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_92.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_92.len()
        )))
    } else {
        let mut var_92 = var_92;
        Ok(var_92.pop())
    }
}

pub(crate) fn deser_header_get_links_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_93 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_93.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_93.len()
        )))
    } else {
        let mut var_93 = var_93;
        Ok(var_93.pop())
    }
}

pub(crate) fn deser_header_get_links_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_94 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_94.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_94.len()
        )))
    } else {
        let mut var_94 = var_94;
        Ok(var_94.pop())
    }
}

pub(crate) fn deser_header_get_network_resource_counts_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_95 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_95.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_95.len()
        )))
    } else {
        let mut var_95 = var_95;
        Ok(var_95.pop())
    }
}

pub(crate) fn deser_header_get_network_resource_counts_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_96 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_96.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_96.len()
        )))
    } else {
        let mut var_96 = var_96;
        Ok(var_96.pop())
    }
}

pub(crate) fn deser_header_get_network_resource_relationships_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_97 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_97.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_97.len()
        )))
    } else {
        let mut var_97 = var_97;
        Ok(var_97.pop())
    }
}

pub(crate) fn deser_header_get_network_resource_relationships_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_98 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_98.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_98.len()
        )))
    } else {
        let mut var_98 = var_98;
        Ok(var_98.pop())
    }
}

pub(crate) fn deser_header_get_network_resources_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_99 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_99.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_99.len()
        )))
    } else {
        let mut var_99 = var_99;
        Ok(var_99.pop())
    }
}

pub(crate) fn deser_header_get_network_resources_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_100 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_100.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_100.len()
        )))
    } else {
        let mut var_100 = var_100;
        Ok(var_100.pop())
    }
}

pub(crate) fn deser_header_get_network_routes_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_101 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_101.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_101.len()
        )))
    } else {
        let mut var_101 = var_101;
        Ok(var_101.pop())
    }
}

pub(crate) fn deser_header_get_network_routes_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_102 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_102.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_102.len()
        )))
    } else {
        let mut var_102 = var_102;
        Ok(var_102.pop())
    }
}

pub(crate) fn deser_header_get_network_telemetry_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_103 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_103.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_103.len()
        )))
    } else {
        let mut var_103 = var_103;
        Ok(var_103.pop())
    }
}

pub(crate) fn deser_header_get_network_telemetry_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_104 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_104.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_104.len()
        )))
    } else {
        let mut var_104 = var_104;
        Ok(var_104.pop())
    }
}

pub(crate) fn deser_header_get_resource_policy_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_105 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_105.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_105.len()
        )))
    } else {
        let mut var_105 = var_105;
        Ok(var_105.pop())
    }
}

pub(crate) fn deser_header_get_resource_policy_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_106 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_106.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_106.len()
        )))
    } else {
        let mut var_106 = var_106;
        Ok(var_106.pop())
    }
}

pub(crate) fn deser_header_get_route_analysis_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_107 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_107.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_107.len()
        )))
    } else {
        let mut var_107 = var_107;
        Ok(var_107.pop())
    }
}

pub(crate) fn deser_header_get_route_analysis_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_108 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_108.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_108.len()
        )))
    } else {
        let mut var_108 = var_108;
        Ok(var_108.pop())
    }
}

pub(crate) fn deser_header_get_sites_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_109 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_109.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_109.len()
        )))
    } else {
        let mut var_109 = var_109;
        Ok(var_109.pop())
    }
}

pub(crate) fn deser_header_get_sites_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_110 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_110.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_110.len()
        )))
    } else {
        let mut var_110 = var_110;
        Ok(var_110.pop())
    }
}

pub(crate) fn deser_header_get_site_to_site_vpn_attachment_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_111 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_111.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_111.len()
        )))
    } else {
        let mut var_111 = var_111;
        Ok(var_111.pop())
    }
}

pub(crate) fn deser_header_get_site_to_site_vpn_attachment_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_112 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_112.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_112.len()
        )))
    } else {
        let mut var_112 = var_112;
        Ok(var_112.pop())
    }
}

pub(crate) fn deser_header_get_transit_gateway_connect_peer_associations_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_113 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_113.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_113.len()
        )))
    } else {
        let mut var_113 = var_113;
        Ok(var_113.pop())
    }
}

pub(crate) fn deser_header_get_transit_gateway_connect_peer_associations_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_114 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_114.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_114.len()
        )))
    } else {
        let mut var_114 = var_114;
        Ok(var_114.pop())
    }
}

pub(crate) fn deser_header_get_transit_gateway_peering_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_115 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_115.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_115.len()
        )))
    } else {
        let mut var_115 = var_115;
        Ok(var_115.pop())
    }
}

pub(crate) fn deser_header_get_transit_gateway_peering_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_116 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_116.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_116.len()
        )))
    } else {
        let mut var_116 = var_116;
        Ok(var_116.pop())
    }
}

pub(crate) fn deser_header_get_transit_gateway_registrations_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_117 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_117.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_117.len()
        )))
    } else {
        let mut var_117 = var_117;
        Ok(var_117.pop())
    }
}

pub(crate) fn deser_header_get_transit_gateway_registrations_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_118 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_118.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_118.len()
        )))
    } else {
        let mut var_118 = var_118;
        Ok(var_118.pop())
    }
}

pub(crate) fn deser_header_get_transit_gateway_route_table_attachment_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_119 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_119.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_119.len()
        )))
    } else {
        let mut var_119 = var_119;
        Ok(var_119.pop())
    }
}

pub(crate) fn deser_header_get_transit_gateway_route_table_attachment_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_120 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_120.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_120.len()
        )))
    } else {
        let mut var_120 = var_120;
        Ok(var_120.pop())
    }
}

pub(crate) fn deser_header_get_vpc_attachment_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_121 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_121.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_121.len()
        )))
    } else {
        let mut var_121 = var_121;
        Ok(var_121.pop())
    }
}

pub(crate) fn deser_header_get_vpc_attachment_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_122 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_122.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_122.len()
        )))
    } else {
        let mut var_122 = var_122;
        Ok(var_122.pop())
    }
}

pub(crate) fn deser_header_list_attachments_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_123 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_123.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_123.len()
        )))
    } else {
        let mut var_123 = var_123;
        Ok(var_123.pop())
    }
}

pub(crate) fn deser_header_list_attachments_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_124 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_124.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_124.len()
        )))
    } else {
        let mut var_124 = var_124;
        Ok(var_124.pop())
    }
}

pub(crate) fn deser_header_list_connect_peers_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_125 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_125.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_125.len()
        )))
    } else {
        let mut var_125 = var_125;
        Ok(var_125.pop())
    }
}

pub(crate) fn deser_header_list_connect_peers_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_126 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_126.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_126.len()
        )))
    } else {
        let mut var_126 = var_126;
        Ok(var_126.pop())
    }
}

pub(crate) fn deser_header_list_core_network_policy_versions_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_127 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_127.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_127.len()
        )))
    } else {
        let mut var_127 = var_127;
        Ok(var_127.pop())
    }
}

pub(crate) fn deser_header_list_core_network_policy_versions_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_128 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_128.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_128.len()
        )))
    } else {
        let mut var_128 = var_128;
        Ok(var_128.pop())
    }
}

pub(crate) fn deser_header_list_core_networks_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_129 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_129.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_129.len()
        )))
    } else {
        let mut var_129 = var_129;
        Ok(var_129.pop())
    }
}

pub(crate) fn deser_header_list_core_networks_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_130 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_130.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_130.len()
        )))
    } else {
        let mut var_130 = var_130;
        Ok(var_130.pop())
    }
}

pub(crate) fn deser_header_list_peerings_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_131 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_131.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_131.len()
        )))
    } else {
        let mut var_131 = var_131;
        Ok(var_131.pop())
    }
}

pub(crate) fn deser_header_list_peerings_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_132 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_132.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_132.len()
        )))
    } else {
        let mut var_132 = var_132;
        Ok(var_132.pop())
    }
}

pub(crate) fn deser_header_list_tags_for_resource_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_133 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_133.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_133.len()
        )))
    } else {
        let mut var_133 = var_133;
        Ok(var_133.pop())
    }
}

pub(crate) fn deser_header_list_tags_for_resource_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_134 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_134.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_134.len()
        )))
    } else {
        let mut var_134 = var_134;
        Ok(var_134.pop())
    }
}

pub(crate) fn deser_header_put_core_network_policy_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_135 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_135.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_135.len()
        )))
    } else {
        let mut var_135 = var_135;
        Ok(var_135.pop())
    }
}

pub(crate) fn deser_header_put_core_network_policy_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_136 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_136.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_136.len()
        )))
    } else {
        let mut var_136 = var_136;
        Ok(var_136.pop())
    }
}

pub(crate) fn deser_header_put_resource_policy_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_137 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_137.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_137.len()
        )))
    } else {
        let mut var_137 = var_137;
        Ok(var_137.pop())
    }
}

pub(crate) fn deser_header_put_resource_policy_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_138 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_138.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_138.len()
        )))
    } else {
        let mut var_138 = var_138;
        Ok(var_138.pop())
    }
}

pub(crate) fn deser_header_register_transit_gateway_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_139 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_139.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_139.len()
        )))
    } else {
        let mut var_139 = var_139;
        Ok(var_139.pop())
    }
}

pub(crate) fn deser_header_register_transit_gateway_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_140 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_140.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_140.len()
        )))
    } else {
        let mut var_140 = var_140;
        Ok(var_140.pop())
    }
}

pub(crate) fn deser_header_reject_attachment_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_141 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_141.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_141.len()
        )))
    } else {
        let mut var_141 = var_141;
        Ok(var_141.pop())
    }
}

pub(crate) fn deser_header_reject_attachment_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_142 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_142.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_142.len()
        )))
    } else {
        let mut var_142 = var_142;
        Ok(var_142.pop())
    }
}

pub(crate) fn deser_header_restore_core_network_policy_version_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_143 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_143.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_143.len()
        )))
    } else {
        let mut var_143 = var_143;
        Ok(var_143.pop())
    }
}

pub(crate) fn deser_header_restore_core_network_policy_version_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_144 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_144.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_144.len()
        )))
    } else {
        let mut var_144 = var_144;
        Ok(var_144.pop())
    }
}

pub(crate) fn deser_header_start_organization_service_access_update_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_145 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_145.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_145.len()
        )))
    } else {
        let mut var_145 = var_145;
        Ok(var_145.pop())
    }
}

pub(crate) fn deser_header_start_organization_service_access_update_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_146 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_146.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_146.len()
        )))
    } else {
        let mut var_146 = var_146;
        Ok(var_146.pop())
    }
}

pub(crate) fn deser_header_start_route_analysis_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_147 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_147.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_147.len()
        )))
    } else {
        let mut var_147 = var_147;
        Ok(var_147.pop())
    }
}

pub(crate) fn deser_header_start_route_analysis_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_148 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_148.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_148.len()
        )))
    } else {
        let mut var_148 = var_148;
        Ok(var_148.pop())
    }
}

pub(crate) fn deser_header_tag_resource_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_149 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_149.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_149.len()
        )))
    } else {
        let mut var_149 = var_149;
        Ok(var_149.pop())
    }
}

pub(crate) fn deser_header_tag_resource_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_150 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_150.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_150.len()
        )))
    } else {
        let mut var_150 = var_150;
        Ok(var_150.pop())
    }
}

pub(crate) fn deser_header_untag_resource_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_151 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_151.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_151.len()
        )))
    } else {
        let mut var_151 = var_151;
        Ok(var_151.pop())
    }
}

pub(crate) fn deser_header_untag_resource_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_152 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_152.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_152.len()
        )))
    } else {
        let mut var_152 = var_152;
        Ok(var_152.pop())
    }
}

pub(crate) fn deser_header_update_connection_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_153 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_153.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_153.len()
        )))
    } else {
        let mut var_153 = var_153;
        Ok(var_153.pop())
    }
}

pub(crate) fn deser_header_update_connection_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_154 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_154.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_154.len()
        )))
    } else {
        let mut var_154 = var_154;
        Ok(var_154.pop())
    }
}

pub(crate) fn deser_header_update_core_network_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_155 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_155.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_155.len()
        )))
    } else {
        let mut var_155 = var_155;
        Ok(var_155.pop())
    }
}

pub(crate) fn deser_header_update_core_network_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_156 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_156.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_156.len()
        )))
    } else {
        let mut var_156 = var_156;
        Ok(var_156.pop())
    }
}

pub(crate) fn deser_header_update_device_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_157 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_157.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_157.len()
        )))
    } else {
        let mut var_157 = var_157;
        Ok(var_157.pop())
    }
}

pub(crate) fn deser_header_update_device_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_158 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_158.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_158.len()
        )))
    } else {
        let mut var_158 = var_158;
        Ok(var_158.pop())
    }
}

pub(crate) fn deser_header_update_global_network_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_159 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_159.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_159.len()
        )))
    } else {
        let mut var_159 = var_159;
        Ok(var_159.pop())
    }
}

pub(crate) fn deser_header_update_global_network_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_160 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_160.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_160.len()
        )))
    } else {
        let mut var_160 = var_160;
        Ok(var_160.pop())
    }
}

pub(crate) fn deser_header_update_link_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_161 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_161.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_161.len()
        )))
    } else {
        let mut var_161 = var_161;
        Ok(var_161.pop())
    }
}

pub(crate) fn deser_header_update_link_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_162 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_162.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_162.len()
        )))
    } else {
        let mut var_162 = var_162;
        Ok(var_162.pop())
    }
}

pub(crate) fn deser_header_update_network_resource_metadata_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_163 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_163.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_163.len()
        )))
    } else {
        let mut var_163 = var_163;
        Ok(var_163.pop())
    }
}

pub(crate) fn deser_header_update_network_resource_metadata_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_164 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_164.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_164.len()
        )))
    } else {
        let mut var_164 = var_164;
        Ok(var_164.pop())
    }
}

pub(crate) fn deser_header_update_site_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_165 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_165.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_165.len()
        )))
    } else {
        let mut var_165 = var_165;
        Ok(var_165.pop())
    }
}

pub(crate) fn deser_header_update_site_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_166 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_166.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_166.len()
        )))
    } else {
        let mut var_166 = var_166;
        Ok(var_166.pop())
    }
}

pub(crate) fn deser_header_update_vpc_attachment_internal_server_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_167 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_167.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_167.len()
        )))
    } else {
        let mut var_167 = var_167;
        Ok(var_167.pop())
    }
}

pub(crate) fn deser_header_update_vpc_attachment_throttling_exception_retry_after_seconds(
    header_map: &http::HeaderMap,
) -> std::result::Result<std::option::Option<i32>, aws_smithy_http::header::ParseError> {
    let headers = header_map.get_all("Retry-After").iter();
    let var_168 = aws_smithy_http::header::read_many_primitive::<i32>(headers)?;
    if var_168.len() > 1 {
        Err(aws_smithy_http::header::ParseError::new(format!(
            "expected one item but found {}",
            var_168.len()
        )))
    } else {
        let mut var_168 = var_168;
        Ok(var_168.pop())
    }
}