#[allow(clippy::unnecessary_wraps)]
pub fn parse_accept_input_device_transfer_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::AcceptInputDeviceTransferOutput,
crate::error::AcceptInputDeviceTransferError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::AcceptInputDeviceTransferError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::AcceptInputDeviceTransferError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::AcceptInputDeviceTransferError {
meta: generic,
kind: crate::error::AcceptInputDeviceTransferErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AcceptInputDeviceTransferError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::AcceptInputDeviceTransferError {
meta: generic,
kind: crate::error::AcceptInputDeviceTransferErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AcceptInputDeviceTransferError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::AcceptInputDeviceTransferError {
meta: generic,
kind: crate::error::AcceptInputDeviceTransferErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AcceptInputDeviceTransferError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ForbiddenException" => crate::error::AcceptInputDeviceTransferError {
meta: generic,
kind: crate::error::AcceptInputDeviceTransferErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AcceptInputDeviceTransferError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::AcceptInputDeviceTransferError {
meta: generic,
kind: crate::error::AcceptInputDeviceTransferErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AcceptInputDeviceTransferError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::AcceptInputDeviceTransferError {
meta: generic,
kind: crate::error::AcceptInputDeviceTransferErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AcceptInputDeviceTransferError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::AcceptInputDeviceTransferError {
meta: generic,
kind: crate::error::AcceptInputDeviceTransferErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AcceptInputDeviceTransferError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::AcceptInputDeviceTransferError {
meta: generic,
kind: crate::error::AcceptInputDeviceTransferErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AcceptInputDeviceTransferError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"UnprocessableEntityException" => crate::error::AcceptInputDeviceTransferError {
meta: generic,
kind: crate::error::AcceptInputDeviceTransferErrorKind::UnprocessableEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::unprocessable_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_unprocessable_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AcceptInputDeviceTransferError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::AcceptInputDeviceTransferError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_accept_input_device_transfer_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::AcceptInputDeviceTransferOutput,
crate::error::AcceptInputDeviceTransferError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::accept_input_device_transfer_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_batch_delete_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::BatchDeleteOutput, crate::error::BatchDeleteError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::BatchDeleteError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::BatchDeleteError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::BatchDeleteError {
meta: generic,
kind: crate::error::BatchDeleteErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchDeleteError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::BatchDeleteError {
meta: generic,
kind: crate::error::BatchDeleteErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchDeleteError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::BatchDeleteError {
meta: generic,
kind: crate::error::BatchDeleteErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchDeleteError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ForbiddenException" => crate::error::BatchDeleteError {
meta: generic,
kind: crate::error::BatchDeleteErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchDeleteError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::BatchDeleteError {
meta: generic,
kind: crate::error::BatchDeleteErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchDeleteError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::BatchDeleteError {
meta: generic,
kind: crate::error::BatchDeleteErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchDeleteError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::BatchDeleteError {
meta: generic,
kind: crate::error::BatchDeleteErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchDeleteError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::BatchDeleteError {
meta: generic,
kind: crate::error::BatchDeleteErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchDeleteError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::BatchDeleteError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_batch_delete_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::BatchDeleteOutput, crate::error::BatchDeleteError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::batch_delete_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_batch_delete(
response.body().as_ref(),
output,
)
.map_err(crate::error::BatchDeleteError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_batch_start_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::BatchStartOutput, crate::error::BatchStartError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::BatchStartError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::BatchStartError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::BatchStartError {
meta: generic,
kind: crate::error::BatchStartErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchStartError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::BatchStartError {
meta: generic,
kind: crate::error::BatchStartErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchStartError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::BatchStartError {
meta: generic,
kind: crate::error::BatchStartErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchStartError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ForbiddenException" => crate::error::BatchStartError {
meta: generic,
kind: crate::error::BatchStartErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchStartError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::BatchStartError {
meta: generic,
kind: crate::error::BatchStartErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchStartError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::BatchStartError {
meta: generic,
kind: crate::error::BatchStartErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchStartError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::BatchStartError {
meta: generic,
kind: crate::error::BatchStartErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchStartError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::BatchStartError {
meta: generic,
kind: crate::error::BatchStartErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchStartError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::BatchStartError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_batch_start_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::BatchStartOutput, crate::error::BatchStartError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::batch_start_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_batch_start(
response.body().as_ref(),
output,
)
.map_err(crate::error::BatchStartError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_batch_stop_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::BatchStopOutput, crate::error::BatchStopError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::BatchStopError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::BatchStopError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::BatchStopError {
meta: generic,
kind: crate::error::BatchStopErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchStopError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::BatchStopError {
meta: generic,
kind: crate::error::BatchStopErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchStopError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::BatchStopError {
meta: generic,
kind: crate::error::BatchStopErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchStopError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ForbiddenException" => crate::error::BatchStopError {
meta: generic,
kind: crate::error::BatchStopErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchStopError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::BatchStopError {
meta: generic,
kind: crate::error::BatchStopErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchStopError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::BatchStopError {
meta: generic,
kind: crate::error::BatchStopErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchStopError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::BatchStopError {
meta: generic,
kind: crate::error::BatchStopErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchStopError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::BatchStopError {
meta: generic,
kind: crate::error::BatchStopErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchStopError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::BatchStopError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_batch_stop_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::BatchStopOutput, crate::error::BatchStopError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::batch_stop_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_batch_stop(
response.body().as_ref(),
output,
)
.map_err(crate::error::BatchStopError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_batch_update_schedule_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::BatchUpdateScheduleOutput,
crate::error::BatchUpdateScheduleError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::BatchUpdateScheduleError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::BatchUpdateScheduleError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::BatchUpdateScheduleError {
meta: generic,
kind: crate::error::BatchUpdateScheduleErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchUpdateScheduleError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::BatchUpdateScheduleError {
meta: generic,
kind: crate::error::BatchUpdateScheduleErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchUpdateScheduleError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::BatchUpdateScheduleError {
meta: generic,
kind: crate::error::BatchUpdateScheduleErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchUpdateScheduleError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::BatchUpdateScheduleError {
meta: generic,
kind: crate::error::BatchUpdateScheduleErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchUpdateScheduleError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::BatchUpdateScheduleError {
meta: generic,
kind: crate::error::BatchUpdateScheduleErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchUpdateScheduleError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::BatchUpdateScheduleError {
meta: generic,
kind: crate::error::BatchUpdateScheduleErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchUpdateScheduleError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::BatchUpdateScheduleError {
meta: generic,
kind: crate::error::BatchUpdateScheduleErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchUpdateScheduleError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"UnprocessableEntityException" => crate::error::BatchUpdateScheduleError {
meta: generic,
kind: crate::error::BatchUpdateScheduleErrorKind::UnprocessableEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::unprocessable_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_unprocessable_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchUpdateScheduleError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::BatchUpdateScheduleError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_batch_update_schedule_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::BatchUpdateScheduleOutput,
crate::error::BatchUpdateScheduleError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::batch_update_schedule_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_batch_update_schedule(
response.body().as_ref(),
output,
)
.map_err(crate::error::BatchUpdateScheduleError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_cancel_input_device_transfer_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CancelInputDeviceTransferOutput,
crate::error::CancelInputDeviceTransferError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CancelInputDeviceTransferError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::CancelInputDeviceTransferError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::CancelInputDeviceTransferError {
meta: generic,
kind: crate::error::CancelInputDeviceTransferErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CancelInputDeviceTransferError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::CancelInputDeviceTransferError {
meta: generic,
kind: crate::error::CancelInputDeviceTransferErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CancelInputDeviceTransferError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::CancelInputDeviceTransferError {
meta: generic,
kind: crate::error::CancelInputDeviceTransferErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CancelInputDeviceTransferError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ForbiddenException" => crate::error::CancelInputDeviceTransferError {
meta: generic,
kind: crate::error::CancelInputDeviceTransferErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CancelInputDeviceTransferError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::CancelInputDeviceTransferError {
meta: generic,
kind: crate::error::CancelInputDeviceTransferErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CancelInputDeviceTransferError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::CancelInputDeviceTransferError {
meta: generic,
kind: crate::error::CancelInputDeviceTransferErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CancelInputDeviceTransferError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::CancelInputDeviceTransferError {
meta: generic,
kind: crate::error::CancelInputDeviceTransferErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CancelInputDeviceTransferError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::CancelInputDeviceTransferError {
meta: generic,
kind: crate::error::CancelInputDeviceTransferErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CancelInputDeviceTransferError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"UnprocessableEntityException" => crate::error::CancelInputDeviceTransferError {
meta: generic,
kind: crate::error::CancelInputDeviceTransferErrorKind::UnprocessableEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::unprocessable_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_unprocessable_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CancelInputDeviceTransferError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CancelInputDeviceTransferError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_cancel_input_device_transfer_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CancelInputDeviceTransferOutput,
crate::error::CancelInputDeviceTransferError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::cancel_input_device_transfer_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_claim_device_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ClaimDeviceOutput, crate::error::ClaimDeviceError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ClaimDeviceError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ClaimDeviceError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::ClaimDeviceError {
meta: generic,
kind: crate::error::ClaimDeviceErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ClaimDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::ClaimDeviceError {
meta: generic,
kind: crate::error::ClaimDeviceErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ClaimDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::ClaimDeviceError {
meta: generic,
kind: crate::error::ClaimDeviceErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ClaimDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::ClaimDeviceError {
meta: generic,
kind: crate::error::ClaimDeviceErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ClaimDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::ClaimDeviceError {
meta: generic,
kind: crate::error::ClaimDeviceErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ClaimDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::ClaimDeviceError {
meta: generic,
kind: crate::error::ClaimDeviceErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ClaimDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::ClaimDeviceError {
meta: generic,
kind: crate::error::ClaimDeviceErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ClaimDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"UnprocessableEntityException" => crate::error::ClaimDeviceError {
meta: generic,
kind: crate::error::ClaimDeviceErrorKind::UnprocessableEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::unprocessable_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_unprocessable_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ClaimDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ClaimDeviceError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_claim_device_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ClaimDeviceOutput, crate::error::ClaimDeviceError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::claim_device_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_channel_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateChannelOutput, crate::error::CreateChannelError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateChannelError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateChannelError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::CreateChannelError {
meta: generic,
kind: crate::error::CreateChannelErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::CreateChannelError {
meta: generic,
kind: crate::error::CreateChannelErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::CreateChannelError {
meta: generic,
kind: crate::error::CreateChannelErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ForbiddenException" => crate::error::CreateChannelError {
meta: generic,
kind: crate::error::CreateChannelErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::CreateChannelError {
meta: generic,
kind: crate::error::CreateChannelErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::CreateChannelError {
meta: generic,
kind: crate::error::CreateChannelErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::CreateChannelError {
meta: generic,
kind: crate::error::CreateChannelErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"UnprocessableEntityException" => crate::error::CreateChannelError {
meta: generic,
kind: crate::error::CreateChannelErrorKind::UnprocessableEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::unprocessable_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_unprocessable_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateChannelError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_channel_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateChannelOutput, crate::error::CreateChannelError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_channel_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_channel(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateChannelError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_input_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateInputOutput, crate::error::CreateInputError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateInputError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateInputError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::CreateInputError {
meta: generic,
kind: crate::error::CreateInputErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::CreateInputError {
meta: generic,
kind: crate::error::CreateInputErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::CreateInputError {
meta: generic,
kind: crate::error::CreateInputErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::CreateInputError {
meta: generic,
kind: crate::error::CreateInputErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::CreateInputError {
meta: generic,
kind: crate::error::CreateInputErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::CreateInputError {
meta: generic,
kind: crate::error::CreateInputErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateInputError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_input_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateInputOutput, crate::error::CreateInputError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_input_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_input(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateInputError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_input_security_group_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateInputSecurityGroupOutput,
crate::error::CreateInputSecurityGroupError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateInputSecurityGroupError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::CreateInputSecurityGroupError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::CreateInputSecurityGroupError {
meta: generic,
kind: crate::error::CreateInputSecurityGroupErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateInputSecurityGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::CreateInputSecurityGroupError {
meta: generic,
kind: crate::error::CreateInputSecurityGroupErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateInputSecurityGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::CreateInputSecurityGroupError {
meta: generic,
kind: crate::error::CreateInputSecurityGroupErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateInputSecurityGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::CreateInputSecurityGroupError {
meta: generic,
kind: crate::error::CreateInputSecurityGroupErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateInputSecurityGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::CreateInputSecurityGroupError {
meta: generic,
kind: crate::error::CreateInputSecurityGroupErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateInputSecurityGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::CreateInputSecurityGroupError {
meta: generic,
kind: crate::error::CreateInputSecurityGroupErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateInputSecurityGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateInputSecurityGroupError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_input_security_group_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateInputSecurityGroupOutput,
crate::error::CreateInputSecurityGroupError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_input_security_group_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_input_security_group(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateInputSecurityGroupError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_multiplex_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateMultiplexOutput, crate::error::CreateMultiplexError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateMultiplexError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateMultiplexError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::CreateMultiplexError {
meta: generic,
kind: crate::error::CreateMultiplexErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::CreateMultiplexError {
meta: generic,
kind: crate::error::CreateMultiplexErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::CreateMultiplexError {
meta: generic,
kind: crate::error::CreateMultiplexErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ForbiddenException" => crate::error::CreateMultiplexError {
meta: generic,
kind: crate::error::CreateMultiplexErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::CreateMultiplexError {
meta: generic,
kind: crate::error::CreateMultiplexErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::CreateMultiplexError {
meta: generic,
kind: crate::error::CreateMultiplexErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::CreateMultiplexError {
meta: generic,
kind: crate::error::CreateMultiplexErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"UnprocessableEntityException" => crate::error::CreateMultiplexError {
meta: generic,
kind: crate::error::CreateMultiplexErrorKind::UnprocessableEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::unprocessable_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_unprocessable_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateMultiplexError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_multiplex_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateMultiplexOutput, crate::error::CreateMultiplexError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_multiplex_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_multiplex(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateMultiplexError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_multiplex_program_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateMultiplexProgramOutput,
crate::error::CreateMultiplexProgramError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateMultiplexProgramError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::CreateMultiplexProgramError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::CreateMultiplexProgramError {
meta: generic,
kind: crate::error::CreateMultiplexProgramErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::CreateMultiplexProgramError {
meta: generic,
kind: crate::error::CreateMultiplexProgramErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::CreateMultiplexProgramError {
meta: generic,
kind: crate::error::CreateMultiplexProgramErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ForbiddenException" => crate::error::CreateMultiplexProgramError {
meta: generic,
kind: crate::error::CreateMultiplexProgramErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::CreateMultiplexProgramError {
meta: generic,
kind: crate::error::CreateMultiplexProgramErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::CreateMultiplexProgramError {
meta: generic,
kind: crate::error::CreateMultiplexProgramErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::CreateMultiplexProgramError {
meta: generic,
kind: crate::error::CreateMultiplexProgramErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"UnprocessableEntityException" => crate::error::CreateMultiplexProgramError {
meta: generic,
kind: crate::error::CreateMultiplexProgramErrorKind::UnprocessableEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::unprocessable_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_unprocessable_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateMultiplexProgramError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_multiplex_program_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateMultiplexProgramOutput,
crate::error::CreateMultiplexProgramError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_multiplex_program_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_multiplex_program(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateMultiplexProgramError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_partner_input_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreatePartnerInputOutput,
crate::error::CreatePartnerInputError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreatePartnerInputError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreatePartnerInputError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::CreatePartnerInputError {
meta: generic,
kind: crate::error::CreatePartnerInputErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreatePartnerInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::CreatePartnerInputError {
meta: generic,
kind: crate::error::CreatePartnerInputErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreatePartnerInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::CreatePartnerInputError {
meta: generic,
kind: crate::error::CreatePartnerInputErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreatePartnerInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::CreatePartnerInputError {
meta: generic,
kind: crate::error::CreatePartnerInputErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreatePartnerInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::CreatePartnerInputError {
meta: generic,
kind: crate::error::CreatePartnerInputErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreatePartnerInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::CreatePartnerInputError {
meta: generic,
kind: crate::error::CreatePartnerInputErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreatePartnerInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreatePartnerInputError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_partner_input_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreatePartnerInputOutput,
crate::error::CreatePartnerInputError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_partner_input_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_partner_input(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreatePartnerInputError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_tags_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateTagsOutput, crate::error::CreateTagsError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateTagsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateTagsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::CreateTagsError {
meta: generic,
kind: crate::error::CreateTagsErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateTagsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::CreateTagsError {
meta: generic,
kind: crate::error::CreateTagsErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateTagsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::CreateTagsError {
meta: generic,
kind: crate::error::CreateTagsErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateTagsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::CreateTagsError {
meta: generic,
kind: crate::error::CreateTagsErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateTagsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateTagsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_tags_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateTagsOutput, crate::error::CreateTagsError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_tags_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_channel_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteChannelOutput, crate::error::DeleteChannelError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteChannelError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteChannelError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::DeleteChannelError {
meta: generic,
kind: crate::error::DeleteChannelErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::DeleteChannelError {
meta: generic,
kind: crate::error::DeleteChannelErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::DeleteChannelError {
meta: generic,
kind: crate::error::DeleteChannelErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ForbiddenException" => crate::error::DeleteChannelError {
meta: generic,
kind: crate::error::DeleteChannelErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::DeleteChannelError {
meta: generic,
kind: crate::error::DeleteChannelErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::DeleteChannelError {
meta: generic,
kind: crate::error::DeleteChannelErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::DeleteChannelError {
meta: generic,
kind: crate::error::DeleteChannelErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::DeleteChannelError {
meta: generic,
kind: crate::error::DeleteChannelErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteChannelError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_channel_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteChannelOutput, crate::error::DeleteChannelError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_channel_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_delete_channel(
response.body().as_ref(),
output,
)
.map_err(crate::error::DeleteChannelError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_input_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteInputOutput, crate::error::DeleteInputError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteInputError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteInputError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::DeleteInputError {
meta: generic,
kind: crate::error::DeleteInputErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::DeleteInputError {
meta: generic,
kind: crate::error::DeleteInputErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::DeleteInputError {
meta: generic,
kind: crate::error::DeleteInputErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ForbiddenException" => crate::error::DeleteInputError {
meta: generic,
kind: crate::error::DeleteInputErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::DeleteInputError {
meta: generic,
kind: crate::error::DeleteInputErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::DeleteInputError {
meta: generic,
kind: crate::error::DeleteInputErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::DeleteInputError {
meta: generic,
kind: crate::error::DeleteInputErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::DeleteInputError {
meta: generic,
kind: crate::error::DeleteInputErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteInputError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_input_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteInputOutput, crate::error::DeleteInputError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_input_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_input_security_group_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteInputSecurityGroupOutput,
crate::error::DeleteInputSecurityGroupError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteInputSecurityGroupError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DeleteInputSecurityGroupError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::DeleteInputSecurityGroupError {
meta: generic,
kind: crate::error::DeleteInputSecurityGroupErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteInputSecurityGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::DeleteInputSecurityGroupError {
meta: generic,
kind: crate::error::DeleteInputSecurityGroupErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteInputSecurityGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::DeleteInputSecurityGroupError {
meta: generic,
kind: crate::error::DeleteInputSecurityGroupErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteInputSecurityGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::DeleteInputSecurityGroupError {
meta: generic,
kind: crate::error::DeleteInputSecurityGroupErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteInputSecurityGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::DeleteInputSecurityGroupError {
meta: generic,
kind: crate::error::DeleteInputSecurityGroupErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteInputSecurityGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::DeleteInputSecurityGroupError {
meta: generic,
kind: crate::error::DeleteInputSecurityGroupErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteInputSecurityGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::DeleteInputSecurityGroupError {
meta: generic,
kind: crate::error::DeleteInputSecurityGroupErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteInputSecurityGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteInputSecurityGroupError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_input_security_group_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteInputSecurityGroupOutput,
crate::error::DeleteInputSecurityGroupError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_input_security_group_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_multiplex_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteMultiplexOutput, crate::error::DeleteMultiplexError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteMultiplexError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteMultiplexError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::DeleteMultiplexError {
meta: generic,
kind: crate::error::DeleteMultiplexErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::DeleteMultiplexError {
meta: generic,
kind: crate::error::DeleteMultiplexErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::DeleteMultiplexError {
meta: generic,
kind: crate::error::DeleteMultiplexErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ForbiddenException" => crate::error::DeleteMultiplexError {
meta: generic,
kind: crate::error::DeleteMultiplexErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::DeleteMultiplexError {
meta: generic,
kind: crate::error::DeleteMultiplexErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::DeleteMultiplexError {
meta: generic,
kind: crate::error::DeleteMultiplexErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::DeleteMultiplexError {
meta: generic,
kind: crate::error::DeleteMultiplexErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::DeleteMultiplexError {
meta: generic,
kind: crate::error::DeleteMultiplexErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteMultiplexError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_multiplex_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteMultiplexOutput, crate::error::DeleteMultiplexError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_multiplex_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_delete_multiplex(
response.body().as_ref(),
output,
)
.map_err(crate::error::DeleteMultiplexError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_multiplex_program_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteMultiplexProgramOutput,
crate::error::DeleteMultiplexProgramError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteMultiplexProgramError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DeleteMultiplexProgramError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::DeleteMultiplexProgramError {
meta: generic,
kind: crate::error::DeleteMultiplexProgramErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::DeleteMultiplexProgramError {
meta: generic,
kind: crate::error::DeleteMultiplexProgramErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::DeleteMultiplexProgramError {
meta: generic,
kind: crate::error::DeleteMultiplexProgramErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ForbiddenException" => crate::error::DeleteMultiplexProgramError {
meta: generic,
kind: crate::error::DeleteMultiplexProgramErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::DeleteMultiplexProgramError {
meta: generic,
kind: crate::error::DeleteMultiplexProgramErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::DeleteMultiplexProgramError {
meta: generic,
kind: crate::error::DeleteMultiplexProgramErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::DeleteMultiplexProgramError {
meta: generic,
kind: crate::error::DeleteMultiplexProgramErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::DeleteMultiplexProgramError {
meta: generic,
kind: crate::error::DeleteMultiplexProgramErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteMultiplexProgramError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_multiplex_program_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteMultiplexProgramOutput,
crate::error::DeleteMultiplexProgramError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_multiplex_program_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_delete_multiplex_program(
response.body().as_ref(),
output,
)
.map_err(crate::error::DeleteMultiplexProgramError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_reservation_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteReservationOutput, crate::error::DeleteReservationError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteReservationError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteReservationError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::DeleteReservationError {
meta: generic,
kind: crate::error::DeleteReservationErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteReservationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::DeleteReservationError {
meta: generic,
kind: crate::error::DeleteReservationErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteReservationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::DeleteReservationError {
meta: generic,
kind: crate::error::DeleteReservationErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteReservationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ForbiddenException" => crate::error::DeleteReservationError {
meta: generic,
kind: crate::error::DeleteReservationErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteReservationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::DeleteReservationError {
meta: generic,
kind: crate::error::DeleteReservationErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteReservationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::DeleteReservationError {
meta: generic,
kind: crate::error::DeleteReservationErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteReservationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::DeleteReservationError {
meta: generic,
kind: crate::error::DeleteReservationErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteReservationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::DeleteReservationError {
meta: generic,
kind: crate::error::DeleteReservationErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteReservationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteReservationError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_reservation_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteReservationOutput, crate::error::DeleteReservationError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_reservation_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_delete_reservation(
response.body().as_ref(),
output,
)
.map_err(crate::error::DeleteReservationError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_schedule_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteScheduleOutput, crate::error::DeleteScheduleError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteScheduleError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteScheduleError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::DeleteScheduleError {
meta: generic,
kind: crate::error::DeleteScheduleErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteScheduleError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::DeleteScheduleError {
meta: generic,
kind: crate::error::DeleteScheduleErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteScheduleError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::DeleteScheduleError {
meta: generic,
kind: crate::error::DeleteScheduleErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteScheduleError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::DeleteScheduleError {
meta: generic,
kind: crate::error::DeleteScheduleErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteScheduleError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::DeleteScheduleError {
meta: generic,
kind: crate::error::DeleteScheduleErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteScheduleError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::DeleteScheduleError {
meta: generic,
kind: crate::error::DeleteScheduleErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteScheduleError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::DeleteScheduleError {
meta: generic,
kind: crate::error::DeleteScheduleErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteScheduleError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteScheduleError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_schedule_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteScheduleOutput, crate::error::DeleteScheduleError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_schedule_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_tags_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteTagsOutput, crate::error::DeleteTagsError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteTagsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteTagsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::DeleteTagsError {
meta: generic,
kind: crate::error::DeleteTagsErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteTagsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::DeleteTagsError {
meta: generic,
kind: crate::error::DeleteTagsErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteTagsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::DeleteTagsError {
meta: generic,
kind: crate::error::DeleteTagsErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteTagsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::DeleteTagsError {
meta: generic,
kind: crate::error::DeleteTagsErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteTagsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteTagsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_tags_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteTagsOutput, crate::error::DeleteTagsError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_tags_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_channel_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeChannelOutput, crate::error::DescribeChannelError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeChannelError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeChannelError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::DescribeChannelError {
meta: generic,
kind: crate::error::DescribeChannelErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::DescribeChannelError {
meta: generic,
kind: crate::error::DescribeChannelErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::DescribeChannelError {
meta: generic,
kind: crate::error::DescribeChannelErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::DescribeChannelError {
meta: generic,
kind: crate::error::DescribeChannelErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::DescribeChannelError {
meta: generic,
kind: crate::error::DescribeChannelErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::DescribeChannelError {
meta: generic,
kind: crate::error::DescribeChannelErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::DescribeChannelError {
meta: generic,
kind: crate::error::DescribeChannelErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeChannelError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_channel_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeChannelOutput, crate::error::DescribeChannelError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_channel_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_channel(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeChannelError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_input_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeInputOutput, crate::error::DescribeInputError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeInputError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeInputError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::DescribeInputError {
meta: generic,
kind: crate::error::DescribeInputErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::DescribeInputError {
meta: generic,
kind: crate::error::DescribeInputErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::DescribeInputError {
meta: generic,
kind: crate::error::DescribeInputErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::DescribeInputError {
meta: generic,
kind: crate::error::DescribeInputErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::DescribeInputError {
meta: generic,
kind: crate::error::DescribeInputErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::DescribeInputError {
meta: generic,
kind: crate::error::DescribeInputErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::DescribeInputError {
meta: generic,
kind: crate::error::DescribeInputErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeInputError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_input_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeInputOutput, crate::error::DescribeInputError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_input_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_input(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeInputError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_input_device_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeInputDeviceOutput,
crate::error::DescribeInputDeviceError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeInputDeviceError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeInputDeviceError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::DescribeInputDeviceError {
meta: generic,
kind: crate::error::DescribeInputDeviceErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::DescribeInputDeviceError {
meta: generic,
kind: crate::error::DescribeInputDeviceErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::DescribeInputDeviceError {
meta: generic,
kind: crate::error::DescribeInputDeviceErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::DescribeInputDeviceError {
meta: generic,
kind: crate::error::DescribeInputDeviceErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::DescribeInputDeviceError {
meta: generic,
kind: crate::error::DescribeInputDeviceErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::DescribeInputDeviceError {
meta: generic,
kind: crate::error::DescribeInputDeviceErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::DescribeInputDeviceError {
meta: generic,
kind: crate::error::DescribeInputDeviceErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeInputDeviceError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_input_device_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeInputDeviceOutput,
crate::error::DescribeInputDeviceError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_input_device_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_input_device(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeInputDeviceError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_input_device_thumbnail(
op_response: &mut aws_smithy_http::operation::Response,
) -> std::result::Result<
crate::output::DescribeInputDeviceThumbnailOutput,
crate::error::DescribeInputDeviceThumbnailError,
> {
#[allow(unused_variables)]
let (response, properties) = op_response.parts_mut();
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_input_device_thumbnail_output::Builder::default();
let _ = response;
output = output.set_body(
Some(crate::http_serde::deser_payload_describe_input_device_thumbnail_describe_input_device_thumbnail_output_body(response.body_mut())?)
);
output = output.set_content_length(
crate::http_serde::deser_header_describe_input_device_thumbnail_describe_input_device_thumbnail_output_content_length(response.headers())
.map_err(|_|crate::error::DescribeInputDeviceThumbnailError::unhandled("Failed to parse ContentLength from header `Content-Length"))?
);
output = output.set_content_type(
crate::http_serde::deser_header_describe_input_device_thumbnail_describe_input_device_thumbnail_output_content_type(response.headers())
.map_err(|_|crate::error::DescribeInputDeviceThumbnailError::unhandled("Failed to parse ContentType from header `Content-Type"))?
);
output = output.set_e_tag(
crate::http_serde::deser_header_describe_input_device_thumbnail_describe_input_device_thumbnail_output_e_tag(response.headers())
.map_err(|_|crate::error::DescribeInputDeviceThumbnailError::unhandled("Failed to parse ETag from header `ETag"))?
);
output = output.set_last_modified(
crate::http_serde::deser_header_describe_input_device_thumbnail_describe_input_device_thumbnail_output_last_modified(response.headers())
.map_err(|_|crate::error::DescribeInputDeviceThumbnailError::unhandled("Failed to parse LastModified from header `Last-Modified"))?
);
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_input_device_thumbnail_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeInputDeviceThumbnailOutput,
crate::error::DescribeInputDeviceThumbnailError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeInputDeviceThumbnailError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeInputDeviceThumbnailError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::DescribeInputDeviceThumbnailError {
meta: generic,
kind: crate::error::DescribeInputDeviceThumbnailErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeInputDeviceThumbnailError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::DescribeInputDeviceThumbnailError {
meta: generic,
kind: crate::error::DescribeInputDeviceThumbnailErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeInputDeviceThumbnailError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::DescribeInputDeviceThumbnailError {
meta: generic,
kind: crate::error::DescribeInputDeviceThumbnailErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeInputDeviceThumbnailError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::DescribeInputDeviceThumbnailError {
meta: generic,
kind: crate::error::DescribeInputDeviceThumbnailErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeInputDeviceThumbnailError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::DescribeInputDeviceThumbnailError {
meta: generic,
kind: crate::error::DescribeInputDeviceThumbnailErrorKind::InternalServerErrorException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeInputDeviceThumbnailError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"NotFoundException" => crate::error::DescribeInputDeviceThumbnailError {
meta: generic,
kind: crate::error::DescribeInputDeviceThumbnailErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeInputDeviceThumbnailError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::DescribeInputDeviceThumbnailError {
meta: generic,
kind: crate::error::DescribeInputDeviceThumbnailErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeInputDeviceThumbnailError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeInputDeviceThumbnailError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_input_security_group_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeInputSecurityGroupOutput,
crate::error::DescribeInputSecurityGroupError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeInputSecurityGroupError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeInputSecurityGroupError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::DescribeInputSecurityGroupError {
meta: generic,
kind: crate::error::DescribeInputSecurityGroupErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeInputSecurityGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::DescribeInputSecurityGroupError {
meta: generic,
kind: crate::error::DescribeInputSecurityGroupErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeInputSecurityGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::DescribeInputSecurityGroupError {
meta: generic,
kind: crate::error::DescribeInputSecurityGroupErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeInputSecurityGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::DescribeInputSecurityGroupError {
meta: generic,
kind: crate::error::DescribeInputSecurityGroupErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeInputSecurityGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::DescribeInputSecurityGroupError {
meta: generic,
kind: crate::error::DescribeInputSecurityGroupErrorKind::InternalServerErrorException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeInputSecurityGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"NotFoundException" => crate::error::DescribeInputSecurityGroupError {
meta: generic,
kind: crate::error::DescribeInputSecurityGroupErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeInputSecurityGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::DescribeInputSecurityGroupError {
meta: generic,
kind: crate::error::DescribeInputSecurityGroupErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeInputSecurityGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeInputSecurityGroupError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_input_security_group_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeInputSecurityGroupOutput,
crate::error::DescribeInputSecurityGroupError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_input_security_group_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_input_security_group(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeInputSecurityGroupError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_multiplex_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeMultiplexOutput, crate::error::DescribeMultiplexError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeMultiplexError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeMultiplexError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::DescribeMultiplexError {
meta: generic,
kind: crate::error::DescribeMultiplexErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::DescribeMultiplexError {
meta: generic,
kind: crate::error::DescribeMultiplexErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::DescribeMultiplexError {
meta: generic,
kind: crate::error::DescribeMultiplexErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::DescribeMultiplexError {
meta: generic,
kind: crate::error::DescribeMultiplexErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::DescribeMultiplexError {
meta: generic,
kind: crate::error::DescribeMultiplexErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::DescribeMultiplexError {
meta: generic,
kind: crate::error::DescribeMultiplexErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::DescribeMultiplexError {
meta: generic,
kind: crate::error::DescribeMultiplexErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeMultiplexError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_multiplex_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeMultiplexOutput, crate::error::DescribeMultiplexError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_multiplex_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_multiplex(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeMultiplexError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_multiplex_program_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeMultiplexProgramOutput,
crate::error::DescribeMultiplexProgramError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeMultiplexProgramError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeMultiplexProgramError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::DescribeMultiplexProgramError {
meta: generic,
kind: crate::error::DescribeMultiplexProgramErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::DescribeMultiplexProgramError {
meta: generic,
kind: crate::error::DescribeMultiplexProgramErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::DescribeMultiplexProgramError {
meta: generic,
kind: crate::error::DescribeMultiplexProgramErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::DescribeMultiplexProgramError {
meta: generic,
kind: crate::error::DescribeMultiplexProgramErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::DescribeMultiplexProgramError {
meta: generic,
kind: crate::error::DescribeMultiplexProgramErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::DescribeMultiplexProgramError {
meta: generic,
kind: crate::error::DescribeMultiplexProgramErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::DescribeMultiplexProgramError {
meta: generic,
kind: crate::error::DescribeMultiplexProgramErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeMultiplexProgramError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_multiplex_program_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeMultiplexProgramOutput,
crate::error::DescribeMultiplexProgramError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_multiplex_program_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_multiplex_program(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeMultiplexProgramError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_offering_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeOfferingOutput, crate::error::DescribeOfferingError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeOfferingError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeOfferingError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::DescribeOfferingError {
meta: generic,
kind: crate::error::DescribeOfferingErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeOfferingError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::DescribeOfferingError {
meta: generic,
kind: crate::error::DescribeOfferingErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeOfferingError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::DescribeOfferingError {
meta: generic,
kind: crate::error::DescribeOfferingErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeOfferingError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::DescribeOfferingError {
meta: generic,
kind: crate::error::DescribeOfferingErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeOfferingError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::DescribeOfferingError {
meta: generic,
kind: crate::error::DescribeOfferingErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeOfferingError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::DescribeOfferingError {
meta: generic,
kind: crate::error::DescribeOfferingErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeOfferingError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::DescribeOfferingError {
meta: generic,
kind: crate::error::DescribeOfferingErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeOfferingError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeOfferingError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_offering_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeOfferingOutput, crate::error::DescribeOfferingError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_offering_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_offering(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeOfferingError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_reservation_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeReservationOutput,
crate::error::DescribeReservationError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeReservationError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeReservationError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::DescribeReservationError {
meta: generic,
kind: crate::error::DescribeReservationErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeReservationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::DescribeReservationError {
meta: generic,
kind: crate::error::DescribeReservationErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeReservationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::DescribeReservationError {
meta: generic,
kind: crate::error::DescribeReservationErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeReservationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::DescribeReservationError {
meta: generic,
kind: crate::error::DescribeReservationErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeReservationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::DescribeReservationError {
meta: generic,
kind: crate::error::DescribeReservationErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeReservationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::DescribeReservationError {
meta: generic,
kind: crate::error::DescribeReservationErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeReservationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::DescribeReservationError {
meta: generic,
kind: crate::error::DescribeReservationErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeReservationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeReservationError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_reservation_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeReservationOutput,
crate::error::DescribeReservationError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_reservation_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_reservation(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeReservationError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_schedule_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeScheduleOutput, crate::error::DescribeScheduleError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeScheduleError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeScheduleError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::DescribeScheduleError {
meta: generic,
kind: crate::error::DescribeScheduleErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeScheduleError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::DescribeScheduleError {
meta: generic,
kind: crate::error::DescribeScheduleErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeScheduleError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::DescribeScheduleError {
meta: generic,
kind: crate::error::DescribeScheduleErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeScheduleError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::DescribeScheduleError {
meta: generic,
kind: crate::error::DescribeScheduleErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeScheduleError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::DescribeScheduleError {
meta: generic,
kind: crate::error::DescribeScheduleErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeScheduleError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::DescribeScheduleError {
meta: generic,
kind: crate::error::DescribeScheduleErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeScheduleError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::DescribeScheduleError {
meta: generic,
kind: crate::error::DescribeScheduleErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeScheduleError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeScheduleError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_schedule_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeScheduleOutput, crate::error::DescribeScheduleError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_schedule_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_schedule(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeScheduleError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_channels_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListChannelsOutput, crate::error::ListChannelsError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListChannelsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListChannelsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::ListChannelsError {
meta: generic,
kind: crate::error::ListChannelsErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListChannelsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::ListChannelsError {
meta: generic,
kind: crate::error::ListChannelsErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListChannelsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::ListChannelsError {
meta: generic,
kind: crate::error::ListChannelsErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListChannelsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::ListChannelsError {
meta: generic,
kind: crate::error::ListChannelsErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListChannelsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::ListChannelsError {
meta: generic,
kind: crate::error::ListChannelsErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListChannelsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::ListChannelsError {
meta: generic,
kind: crate::error::ListChannelsErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListChannelsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListChannelsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_channels_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListChannelsOutput, crate::error::ListChannelsError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_channels_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_channels(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListChannelsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_input_devices_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListInputDevicesOutput, crate::error::ListInputDevicesError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListInputDevicesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListInputDevicesError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::ListInputDevicesError {
meta: generic,
kind: crate::error::ListInputDevicesErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListInputDevicesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::ListInputDevicesError {
meta: generic,
kind: crate::error::ListInputDevicesErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListInputDevicesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::ListInputDevicesError {
meta: generic,
kind: crate::error::ListInputDevicesErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListInputDevicesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::ListInputDevicesError {
meta: generic,
kind: crate::error::ListInputDevicesErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListInputDevicesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::ListInputDevicesError {
meta: generic,
kind: crate::error::ListInputDevicesErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListInputDevicesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::ListInputDevicesError {
meta: generic,
kind: crate::error::ListInputDevicesErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListInputDevicesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListInputDevicesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_input_devices_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListInputDevicesOutput, crate::error::ListInputDevicesError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_input_devices_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_input_devices(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListInputDevicesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_input_device_transfers_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListInputDeviceTransfersOutput,
crate::error::ListInputDeviceTransfersError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListInputDeviceTransfersError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListInputDeviceTransfersError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::ListInputDeviceTransfersError {
meta: generic,
kind: crate::error::ListInputDeviceTransfersErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListInputDeviceTransfersError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::ListInputDeviceTransfersError {
meta: generic,
kind: crate::error::ListInputDeviceTransfersErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListInputDeviceTransfersError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::ListInputDeviceTransfersError {
meta: generic,
kind: crate::error::ListInputDeviceTransfersErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListInputDeviceTransfersError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::ListInputDeviceTransfersError {
meta: generic,
kind: crate::error::ListInputDeviceTransfersErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListInputDeviceTransfersError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::ListInputDeviceTransfersError {
meta: generic,
kind: crate::error::ListInputDeviceTransfersErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListInputDeviceTransfersError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::ListInputDeviceTransfersError {
meta: generic,
kind: crate::error::ListInputDeviceTransfersErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListInputDeviceTransfersError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"UnprocessableEntityException" => crate::error::ListInputDeviceTransfersError {
meta: generic,
kind: crate::error::ListInputDeviceTransfersErrorKind::UnprocessableEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::unprocessable_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_unprocessable_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListInputDeviceTransfersError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListInputDeviceTransfersError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_input_device_transfers_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListInputDeviceTransfersOutput,
crate::error::ListInputDeviceTransfersError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_input_device_transfers_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_input_device_transfers(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListInputDeviceTransfersError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_inputs_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListInputsOutput, crate::error::ListInputsError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListInputsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListInputsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::ListInputsError {
meta: generic,
kind: crate::error::ListInputsErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListInputsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::ListInputsError {
meta: generic,
kind: crate::error::ListInputsErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListInputsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::ListInputsError {
meta: generic,
kind: crate::error::ListInputsErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListInputsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::ListInputsError {
meta: generic,
kind: crate::error::ListInputsErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListInputsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::ListInputsError {
meta: generic,
kind: crate::error::ListInputsErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListInputsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::ListInputsError {
meta: generic,
kind: crate::error::ListInputsErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListInputsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListInputsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_inputs_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListInputsOutput, crate::error::ListInputsError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_inputs_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_inputs(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListInputsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_input_security_groups_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListInputSecurityGroupsOutput,
crate::error::ListInputSecurityGroupsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListInputSecurityGroupsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListInputSecurityGroupsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::ListInputSecurityGroupsError {
meta: generic,
kind: crate::error::ListInputSecurityGroupsErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListInputSecurityGroupsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::ListInputSecurityGroupsError {
meta: generic,
kind: crate::error::ListInputSecurityGroupsErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListInputSecurityGroupsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::ListInputSecurityGroupsError {
meta: generic,
kind: crate::error::ListInputSecurityGroupsErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListInputSecurityGroupsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::ListInputSecurityGroupsError {
meta: generic,
kind: crate::error::ListInputSecurityGroupsErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListInputSecurityGroupsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::ListInputSecurityGroupsError {
meta: generic,
kind: crate::error::ListInputSecurityGroupsErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListInputSecurityGroupsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::ListInputSecurityGroupsError {
meta: generic,
kind: crate::error::ListInputSecurityGroupsErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListInputSecurityGroupsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListInputSecurityGroupsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_input_security_groups_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListInputSecurityGroupsOutput,
crate::error::ListInputSecurityGroupsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_input_security_groups_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_input_security_groups(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListInputSecurityGroupsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_multiplexes_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListMultiplexesOutput, crate::error::ListMultiplexesError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListMultiplexesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListMultiplexesError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::ListMultiplexesError {
meta: generic,
kind: crate::error::ListMultiplexesErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListMultiplexesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::ListMultiplexesError {
meta: generic,
kind: crate::error::ListMultiplexesErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListMultiplexesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::ListMultiplexesError {
meta: generic,
kind: crate::error::ListMultiplexesErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListMultiplexesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::ListMultiplexesError {
meta: generic,
kind: crate::error::ListMultiplexesErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListMultiplexesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::ListMultiplexesError {
meta: generic,
kind: crate::error::ListMultiplexesErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListMultiplexesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::ListMultiplexesError {
meta: generic,
kind: crate::error::ListMultiplexesErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListMultiplexesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListMultiplexesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_multiplexes_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListMultiplexesOutput, crate::error::ListMultiplexesError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_multiplexes_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_multiplexes(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListMultiplexesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_multiplex_programs_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListMultiplexProgramsOutput,
crate::error::ListMultiplexProgramsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListMultiplexProgramsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListMultiplexProgramsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::ListMultiplexProgramsError {
meta: generic,
kind: crate::error::ListMultiplexProgramsErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListMultiplexProgramsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::ListMultiplexProgramsError {
meta: generic,
kind: crate::error::ListMultiplexProgramsErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListMultiplexProgramsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::ListMultiplexProgramsError {
meta: generic,
kind: crate::error::ListMultiplexProgramsErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListMultiplexProgramsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::ListMultiplexProgramsError {
meta: generic,
kind: crate::error::ListMultiplexProgramsErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListMultiplexProgramsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::ListMultiplexProgramsError {
meta: generic,
kind: crate::error::ListMultiplexProgramsErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListMultiplexProgramsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::ListMultiplexProgramsError {
meta: generic,
kind: crate::error::ListMultiplexProgramsErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListMultiplexProgramsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::ListMultiplexProgramsError {
meta: generic,
kind: crate::error::ListMultiplexProgramsErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListMultiplexProgramsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListMultiplexProgramsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_multiplex_programs_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListMultiplexProgramsOutput,
crate::error::ListMultiplexProgramsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_multiplex_programs_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_multiplex_programs(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListMultiplexProgramsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_offerings_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListOfferingsOutput, crate::error::ListOfferingsError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListOfferingsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListOfferingsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::ListOfferingsError {
meta: generic,
kind: crate::error::ListOfferingsErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListOfferingsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::ListOfferingsError {
meta: generic,
kind: crate::error::ListOfferingsErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListOfferingsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::ListOfferingsError {
meta: generic,
kind: crate::error::ListOfferingsErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListOfferingsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::ListOfferingsError {
meta: generic,
kind: crate::error::ListOfferingsErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListOfferingsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::ListOfferingsError {
meta: generic,
kind: crate::error::ListOfferingsErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListOfferingsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::ListOfferingsError {
meta: generic,
kind: crate::error::ListOfferingsErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListOfferingsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListOfferingsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_offerings_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListOfferingsOutput, crate::error::ListOfferingsError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_offerings_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_offerings(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListOfferingsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_reservations_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListReservationsOutput, crate::error::ListReservationsError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListReservationsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListReservationsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::ListReservationsError {
meta: generic,
kind: crate::error::ListReservationsErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListReservationsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::ListReservationsError {
meta: generic,
kind: crate::error::ListReservationsErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListReservationsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::ListReservationsError {
meta: generic,
kind: crate::error::ListReservationsErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListReservationsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::ListReservationsError {
meta: generic,
kind: crate::error::ListReservationsErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListReservationsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::ListReservationsError {
meta: generic,
kind: crate::error::ListReservationsErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListReservationsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::ListReservationsError {
meta: generic,
kind: crate::error::ListReservationsErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListReservationsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListReservationsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_reservations_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListReservationsOutput, crate::error::ListReservationsError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_reservations_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_reservations(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListReservationsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_tags_for_resource_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListTagsForResourceOutput,
crate::error::ListTagsForResourceError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListTagsForResourceError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListTagsForResourceError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadRequestException" => crate::error::ListTagsForResourceError {
meta: generic,
kind: crate::error::ListTagsForResourceErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTagsForResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::ListTagsForResourceError {
meta: generic,
kind: crate::error::ListTagsForResourceErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTagsForResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::ListTagsForResourceError {
meta: generic,
kind: crate::error::ListTagsForResourceErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTagsForResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::ListTagsForResourceError {
meta: generic,
kind: crate::error::ListTagsForResourceErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTagsForResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListTagsForResourceError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_tags_for_resource_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListTagsForResourceOutput,
crate::error::ListTagsForResourceError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_tags_for_resource_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_tags_for_resource(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListTagsForResourceError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_purchase_offering_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::PurchaseOfferingOutput, crate::error::PurchaseOfferingError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::PurchaseOfferingError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::PurchaseOfferingError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::PurchaseOfferingError {
meta: generic,
kind: crate::error::PurchaseOfferingErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PurchaseOfferingError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::PurchaseOfferingError {
meta: generic,
kind: crate::error::PurchaseOfferingErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PurchaseOfferingError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::PurchaseOfferingError {
meta: generic,
kind: crate::error::PurchaseOfferingErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PurchaseOfferingError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ForbiddenException" => crate::error::PurchaseOfferingError {
meta: generic,
kind: crate::error::PurchaseOfferingErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PurchaseOfferingError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::PurchaseOfferingError {
meta: generic,
kind: crate::error::PurchaseOfferingErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PurchaseOfferingError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::PurchaseOfferingError {
meta: generic,
kind: crate::error::PurchaseOfferingErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PurchaseOfferingError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::PurchaseOfferingError {
meta: generic,
kind: crate::error::PurchaseOfferingErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PurchaseOfferingError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::PurchaseOfferingError {
meta: generic,
kind: crate::error::PurchaseOfferingErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PurchaseOfferingError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::PurchaseOfferingError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_purchase_offering_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::PurchaseOfferingOutput, crate::error::PurchaseOfferingError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::purchase_offering_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_purchase_offering(
response.body().as_ref(),
output,
)
.map_err(crate::error::PurchaseOfferingError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_reboot_input_device_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::RebootInputDeviceOutput, crate::error::RebootInputDeviceError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::RebootInputDeviceError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::RebootInputDeviceError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::RebootInputDeviceError {
meta: generic,
kind: crate::error::RebootInputDeviceErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RebootInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::RebootInputDeviceError {
meta: generic,
kind: crate::error::RebootInputDeviceErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RebootInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::RebootInputDeviceError {
meta: generic,
kind: crate::error::RebootInputDeviceErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RebootInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::RebootInputDeviceError {
meta: generic,
kind: crate::error::RebootInputDeviceErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RebootInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::RebootInputDeviceError {
meta: generic,
kind: crate::error::RebootInputDeviceErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RebootInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::RebootInputDeviceError {
meta: generic,
kind: crate::error::RebootInputDeviceErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RebootInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::RebootInputDeviceError {
meta: generic,
kind: crate::error::RebootInputDeviceErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RebootInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"UnprocessableEntityException" => crate::error::RebootInputDeviceError {
meta: generic,
kind: crate::error::RebootInputDeviceErrorKind::UnprocessableEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::unprocessable_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_unprocessable_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RebootInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::RebootInputDeviceError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_reboot_input_device_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::RebootInputDeviceOutput, crate::error::RebootInputDeviceError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::reboot_input_device_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_reject_input_device_transfer_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::RejectInputDeviceTransferOutput,
crate::error::RejectInputDeviceTransferError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::RejectInputDeviceTransferError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::RejectInputDeviceTransferError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::RejectInputDeviceTransferError {
meta: generic,
kind: crate::error::RejectInputDeviceTransferErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RejectInputDeviceTransferError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::RejectInputDeviceTransferError {
meta: generic,
kind: crate::error::RejectInputDeviceTransferErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RejectInputDeviceTransferError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::RejectInputDeviceTransferError {
meta: generic,
kind: crate::error::RejectInputDeviceTransferErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RejectInputDeviceTransferError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ForbiddenException" => crate::error::RejectInputDeviceTransferError {
meta: generic,
kind: crate::error::RejectInputDeviceTransferErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RejectInputDeviceTransferError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::RejectInputDeviceTransferError {
meta: generic,
kind: crate::error::RejectInputDeviceTransferErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RejectInputDeviceTransferError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::RejectInputDeviceTransferError {
meta: generic,
kind: crate::error::RejectInputDeviceTransferErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RejectInputDeviceTransferError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::RejectInputDeviceTransferError {
meta: generic,
kind: crate::error::RejectInputDeviceTransferErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RejectInputDeviceTransferError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::RejectInputDeviceTransferError {
meta: generic,
kind: crate::error::RejectInputDeviceTransferErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RejectInputDeviceTransferError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"UnprocessableEntityException" => crate::error::RejectInputDeviceTransferError {
meta: generic,
kind: crate::error::RejectInputDeviceTransferErrorKind::UnprocessableEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::unprocessable_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_unprocessable_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RejectInputDeviceTransferError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::RejectInputDeviceTransferError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_reject_input_device_transfer_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::RejectInputDeviceTransferOutput,
crate::error::RejectInputDeviceTransferError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::reject_input_device_transfer_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_channel_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StartChannelOutput, crate::error::StartChannelError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StartChannelError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::StartChannelError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::StartChannelError {
meta: generic,
kind: crate::error::StartChannelErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::StartChannelError {
meta: generic,
kind: crate::error::StartChannelErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::StartChannelError {
meta: generic,
kind: crate::error::StartChannelErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ForbiddenException" => crate::error::StartChannelError {
meta: generic,
kind: crate::error::StartChannelErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::StartChannelError {
meta: generic,
kind: crate::error::StartChannelErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::StartChannelError {
meta: generic,
kind: crate::error::StartChannelErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::StartChannelError {
meta: generic,
kind: crate::error::StartChannelErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::StartChannelError {
meta: generic,
kind: crate::error::StartChannelErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::StartChannelError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_channel_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StartChannelOutput, crate::error::StartChannelError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::start_channel_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_start_channel(
response.body().as_ref(),
output,
)
.map_err(crate::error::StartChannelError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_input_device_maintenance_window_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::StartInputDeviceMaintenanceWindowOutput,
crate::error::StartInputDeviceMaintenanceWindowError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StartInputDeviceMaintenanceWindowError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::StartInputDeviceMaintenanceWindowError::unhandled(generic))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::StartInputDeviceMaintenanceWindowError { meta: generic, kind: crate::error::StartInputDeviceMaintenanceWindowErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartInputDeviceMaintenanceWindowError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"BadRequestException" => crate::error::StartInputDeviceMaintenanceWindowError { meta: generic, kind: crate::error::StartInputDeviceMaintenanceWindowErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartInputDeviceMaintenanceWindowError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ForbiddenException" => crate::error::StartInputDeviceMaintenanceWindowError { meta: generic, kind: crate::error::StartInputDeviceMaintenanceWindowErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartInputDeviceMaintenanceWindowError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"GatewayTimeoutException" => crate::error::StartInputDeviceMaintenanceWindowError { meta: generic, kind: crate::error::StartInputDeviceMaintenanceWindowErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartInputDeviceMaintenanceWindowError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"InternalServerErrorException" => crate::error::StartInputDeviceMaintenanceWindowError { meta: generic, kind: crate::error::StartInputDeviceMaintenanceWindowErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartInputDeviceMaintenanceWindowError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"NotFoundException" => crate::error::StartInputDeviceMaintenanceWindowError { meta: generic, kind: crate::error::StartInputDeviceMaintenanceWindowErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartInputDeviceMaintenanceWindowError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"TooManyRequestsException" => crate::error::StartInputDeviceMaintenanceWindowError { meta: generic, kind: crate::error::StartInputDeviceMaintenanceWindowErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartInputDeviceMaintenanceWindowError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"UnprocessableEntityException" => crate::error::StartInputDeviceMaintenanceWindowError { meta: generic, kind: crate::error::StartInputDeviceMaintenanceWindowErrorKind::UnprocessableEntityException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::unprocessable_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_unprocessable_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartInputDeviceMaintenanceWindowError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
_ => crate::error::StartInputDeviceMaintenanceWindowError::generic(generic)
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_input_device_maintenance_window_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::StartInputDeviceMaintenanceWindowOutput,
crate::error::StartInputDeviceMaintenanceWindowError,
> {
Ok({
#[allow(unused_mut)]
let mut output =
crate::output::start_input_device_maintenance_window_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_multiplex_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StartMultiplexOutput, crate::error::StartMultiplexError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StartMultiplexError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::StartMultiplexError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::StartMultiplexError {
meta: generic,
kind: crate::error::StartMultiplexErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::StartMultiplexError {
meta: generic,
kind: crate::error::StartMultiplexErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::StartMultiplexError {
meta: generic,
kind: crate::error::StartMultiplexErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ForbiddenException" => crate::error::StartMultiplexError {
meta: generic,
kind: crate::error::StartMultiplexErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::StartMultiplexError {
meta: generic,
kind: crate::error::StartMultiplexErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::StartMultiplexError {
meta: generic,
kind: crate::error::StartMultiplexErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::StartMultiplexError {
meta: generic,
kind: crate::error::StartMultiplexErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::StartMultiplexError {
meta: generic,
kind: crate::error::StartMultiplexErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::StartMultiplexError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_multiplex_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StartMultiplexOutput, crate::error::StartMultiplexError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::start_multiplex_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_start_multiplex(
response.body().as_ref(),
output,
)
.map_err(crate::error::StartMultiplexError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_channel_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StopChannelOutput, crate::error::StopChannelError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StopChannelError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::StopChannelError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::StopChannelError {
meta: generic,
kind: crate::error::StopChannelErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::StopChannelError {
meta: generic,
kind: crate::error::StopChannelErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::StopChannelError {
meta: generic,
kind: crate::error::StopChannelErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ForbiddenException" => crate::error::StopChannelError {
meta: generic,
kind: crate::error::StopChannelErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::StopChannelError {
meta: generic,
kind: crate::error::StopChannelErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::StopChannelError {
meta: generic,
kind: crate::error::StopChannelErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::StopChannelError {
meta: generic,
kind: crate::error::StopChannelErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::StopChannelError {
meta: generic,
kind: crate::error::StopChannelErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::StopChannelError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_channel_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StopChannelOutput, crate::error::StopChannelError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::stop_channel_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_stop_channel(
response.body().as_ref(),
output,
)
.map_err(crate::error::StopChannelError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_multiplex_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StopMultiplexOutput, crate::error::StopMultiplexError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StopMultiplexError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::StopMultiplexError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::StopMultiplexError {
meta: generic,
kind: crate::error::StopMultiplexErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::StopMultiplexError {
meta: generic,
kind: crate::error::StopMultiplexErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::StopMultiplexError {
meta: generic,
kind: crate::error::StopMultiplexErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ForbiddenException" => crate::error::StopMultiplexError {
meta: generic,
kind: crate::error::StopMultiplexErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::StopMultiplexError {
meta: generic,
kind: crate::error::StopMultiplexErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::StopMultiplexError {
meta: generic,
kind: crate::error::StopMultiplexErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::StopMultiplexError {
meta: generic,
kind: crate::error::StopMultiplexErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::StopMultiplexError {
meta: generic,
kind: crate::error::StopMultiplexErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::StopMultiplexError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_multiplex_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StopMultiplexOutput, crate::error::StopMultiplexError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::stop_multiplex_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_stop_multiplex(
response.body().as_ref(),
output,
)
.map_err(crate::error::StopMultiplexError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_transfer_input_device_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::TransferInputDeviceOutput,
crate::error::TransferInputDeviceError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::TransferInputDeviceError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::TransferInputDeviceError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::TransferInputDeviceError {
meta: generic,
kind: crate::error::TransferInputDeviceErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TransferInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::TransferInputDeviceError {
meta: generic,
kind: crate::error::TransferInputDeviceErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TransferInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::TransferInputDeviceError {
meta: generic,
kind: crate::error::TransferInputDeviceErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TransferInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ForbiddenException" => crate::error::TransferInputDeviceError {
meta: generic,
kind: crate::error::TransferInputDeviceErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TransferInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::TransferInputDeviceError {
meta: generic,
kind: crate::error::TransferInputDeviceErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TransferInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::TransferInputDeviceError {
meta: generic,
kind: crate::error::TransferInputDeviceErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TransferInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::TransferInputDeviceError {
meta: generic,
kind: crate::error::TransferInputDeviceErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TransferInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::TransferInputDeviceError {
meta: generic,
kind: crate::error::TransferInputDeviceErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TransferInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"UnprocessableEntityException" => crate::error::TransferInputDeviceError {
meta: generic,
kind: crate::error::TransferInputDeviceErrorKind::UnprocessableEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::unprocessable_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_unprocessable_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TransferInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::TransferInputDeviceError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_transfer_input_device_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::TransferInputDeviceOutput,
crate::error::TransferInputDeviceError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::transfer_input_device_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_channel_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateChannelOutput, crate::error::UpdateChannelError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateChannelError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UpdateChannelError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::UpdateChannelError {
meta: generic,
kind: crate::error::UpdateChannelErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::UpdateChannelError {
meta: generic,
kind: crate::error::UpdateChannelErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::UpdateChannelError {
meta: generic,
kind: crate::error::UpdateChannelErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ForbiddenException" => crate::error::UpdateChannelError {
meta: generic,
kind: crate::error::UpdateChannelErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::UpdateChannelError {
meta: generic,
kind: crate::error::UpdateChannelErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::UpdateChannelError {
meta: generic,
kind: crate::error::UpdateChannelErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"UnprocessableEntityException" => crate::error::UpdateChannelError {
meta: generic,
kind: crate::error::UpdateChannelErrorKind::UnprocessableEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::unprocessable_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_unprocessable_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateChannelError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateChannelError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_channel_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateChannelOutput, crate::error::UpdateChannelError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_channel_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_channel(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateChannelError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_channel_class_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateChannelClassOutput,
crate::error::UpdateChannelClassError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateChannelClassError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UpdateChannelClassError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::UpdateChannelClassError {
meta: generic,
kind: crate::error::UpdateChannelClassErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateChannelClassError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::UpdateChannelClassError {
meta: generic,
kind: crate::error::UpdateChannelClassErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateChannelClassError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::UpdateChannelClassError {
meta: generic,
kind: crate::error::UpdateChannelClassErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateChannelClassError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ForbiddenException" => crate::error::UpdateChannelClassError {
meta: generic,
kind: crate::error::UpdateChannelClassErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateChannelClassError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::UpdateChannelClassError {
meta: generic,
kind: crate::error::UpdateChannelClassErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateChannelClassError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::UpdateChannelClassError {
meta: generic,
kind: crate::error::UpdateChannelClassErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateChannelClassError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::UpdateChannelClassError {
meta: generic,
kind: crate::error::UpdateChannelClassErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateChannelClassError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::UpdateChannelClassError {
meta: generic,
kind: crate::error::UpdateChannelClassErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateChannelClassError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"UnprocessableEntityException" => crate::error::UpdateChannelClassError {
meta: generic,
kind: crate::error::UpdateChannelClassErrorKind::UnprocessableEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::unprocessable_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_unprocessable_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateChannelClassError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateChannelClassError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_channel_class_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateChannelClassOutput,
crate::error::UpdateChannelClassError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_channel_class_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_channel_class(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateChannelClassError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_input_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateInputOutput, crate::error::UpdateInputError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateInputError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UpdateInputError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::UpdateInputError {
meta: generic,
kind: crate::error::UpdateInputErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::UpdateInputError {
meta: generic,
kind: crate::error::UpdateInputErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::UpdateInputError {
meta: generic,
kind: crate::error::UpdateInputErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ForbiddenException" => crate::error::UpdateInputError {
meta: generic,
kind: crate::error::UpdateInputErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::UpdateInputError {
meta: generic,
kind: crate::error::UpdateInputErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::UpdateInputError {
meta: generic,
kind: crate::error::UpdateInputErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::UpdateInputError {
meta: generic,
kind: crate::error::UpdateInputErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateInputError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateInputError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_input_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateInputOutput, crate::error::UpdateInputError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_input_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_input(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateInputError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_input_device_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateInputDeviceOutput, crate::error::UpdateInputDeviceError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateInputDeviceError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UpdateInputDeviceError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::UpdateInputDeviceError {
meta: generic,
kind: crate::error::UpdateInputDeviceErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::UpdateInputDeviceError {
meta: generic,
kind: crate::error::UpdateInputDeviceErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ForbiddenException" => crate::error::UpdateInputDeviceError {
meta: generic,
kind: crate::error::UpdateInputDeviceErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::UpdateInputDeviceError {
meta: generic,
kind: crate::error::UpdateInputDeviceErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::UpdateInputDeviceError {
meta: generic,
kind: crate::error::UpdateInputDeviceErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::UpdateInputDeviceError {
meta: generic,
kind: crate::error::UpdateInputDeviceErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::UpdateInputDeviceError {
meta: generic,
kind: crate::error::UpdateInputDeviceErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"UnprocessableEntityException" => crate::error::UpdateInputDeviceError {
meta: generic,
kind: crate::error::UpdateInputDeviceErrorKind::UnprocessableEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::unprocessable_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_unprocessable_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateInputDeviceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateInputDeviceError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_input_device_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateInputDeviceOutput, crate::error::UpdateInputDeviceError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_input_device_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_input_device(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateInputDeviceError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_input_security_group_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateInputSecurityGroupOutput,
crate::error::UpdateInputSecurityGroupError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateInputSecurityGroupError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::UpdateInputSecurityGroupError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::UpdateInputSecurityGroupError {
meta: generic,
kind: crate::error::UpdateInputSecurityGroupErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateInputSecurityGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::UpdateInputSecurityGroupError {
meta: generic,
kind: crate::error::UpdateInputSecurityGroupErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateInputSecurityGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::UpdateInputSecurityGroupError {
meta: generic,
kind: crate::error::UpdateInputSecurityGroupErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateInputSecurityGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ForbiddenException" => crate::error::UpdateInputSecurityGroupError {
meta: generic,
kind: crate::error::UpdateInputSecurityGroupErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateInputSecurityGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::UpdateInputSecurityGroupError {
meta: generic,
kind: crate::error::UpdateInputSecurityGroupErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateInputSecurityGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::UpdateInputSecurityGroupError {
meta: generic,
kind: crate::error::UpdateInputSecurityGroupErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateInputSecurityGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::UpdateInputSecurityGroupError {
meta: generic,
kind: crate::error::UpdateInputSecurityGroupErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateInputSecurityGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateInputSecurityGroupError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_input_security_group_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateInputSecurityGroupOutput,
crate::error::UpdateInputSecurityGroupError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_input_security_group_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_input_security_group(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateInputSecurityGroupError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_multiplex_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateMultiplexOutput, crate::error::UpdateMultiplexError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateMultiplexError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UpdateMultiplexError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::UpdateMultiplexError {
meta: generic,
kind: crate::error::UpdateMultiplexErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::UpdateMultiplexError {
meta: generic,
kind: crate::error::UpdateMultiplexErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::UpdateMultiplexError {
meta: generic,
kind: crate::error::UpdateMultiplexErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ForbiddenException" => crate::error::UpdateMultiplexError {
meta: generic,
kind: crate::error::UpdateMultiplexErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::UpdateMultiplexError {
meta: generic,
kind: crate::error::UpdateMultiplexErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::UpdateMultiplexError {
meta: generic,
kind: crate::error::UpdateMultiplexErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::UpdateMultiplexError {
meta: generic,
kind: crate::error::UpdateMultiplexErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"UnprocessableEntityException" => crate::error::UpdateMultiplexError {
meta: generic,
kind: crate::error::UpdateMultiplexErrorKind::UnprocessableEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::unprocessable_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_unprocessable_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateMultiplexError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateMultiplexError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_multiplex_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateMultiplexOutput, crate::error::UpdateMultiplexError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_multiplex_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_multiplex(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateMultiplexError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_multiplex_program_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateMultiplexProgramOutput,
crate::error::UpdateMultiplexProgramError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateMultiplexProgramError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::UpdateMultiplexProgramError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::UpdateMultiplexProgramError {
meta: generic,
kind: crate::error::UpdateMultiplexProgramErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::UpdateMultiplexProgramError {
meta: generic,
kind: crate::error::UpdateMultiplexProgramErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::UpdateMultiplexProgramError {
meta: generic,
kind: crate::error::UpdateMultiplexProgramErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ForbiddenException" => crate::error::UpdateMultiplexProgramError {
meta: generic,
kind: crate::error::UpdateMultiplexProgramErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::UpdateMultiplexProgramError {
meta: generic,
kind: crate::error::UpdateMultiplexProgramErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::UpdateMultiplexProgramError {
meta: generic,
kind: crate::error::UpdateMultiplexProgramErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::UpdateMultiplexProgramError {
meta: generic,
kind: crate::error::UpdateMultiplexProgramErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"UnprocessableEntityException" => crate::error::UpdateMultiplexProgramError {
meta: generic,
kind: crate::error::UpdateMultiplexProgramErrorKind::UnprocessableEntityException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::unprocessable_entity_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_unprocessable_entity_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateMultiplexProgramError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateMultiplexProgramError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_multiplex_program_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateMultiplexProgramOutput,
crate::error::UpdateMultiplexProgramError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_multiplex_program_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_multiplex_program(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateMultiplexProgramError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_reservation_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateReservationOutput, crate::error::UpdateReservationError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateReservationError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UpdateReservationError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"BadGatewayException" => crate::error::UpdateReservationError {
meta: generic,
kind: crate::error::UpdateReservationErrorKind::BadGatewayException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_gateway_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_gateway_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateReservationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"BadRequestException" => crate::error::UpdateReservationError {
meta: generic,
kind: crate::error::UpdateReservationErrorKind::BadRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::bad_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_bad_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateReservationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::UpdateReservationError {
meta: generic,
kind: crate::error::UpdateReservationErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateReservationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ForbiddenException" => crate::error::UpdateReservationError {
meta: generic,
kind: crate::error::UpdateReservationErrorKind::ForbiddenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::forbidden_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_forbidden_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateReservationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"GatewayTimeoutException" => crate::error::UpdateReservationError {
meta: generic,
kind: crate::error::UpdateReservationErrorKind::GatewayTimeoutException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::gateway_timeout_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_gateway_timeout_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateReservationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InternalServerErrorException" => crate::error::UpdateReservationError {
meta: generic,
kind: crate::error::UpdateReservationErrorKind::InternalServerErrorException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::internal_server_error_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_internal_server_error_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateReservationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"NotFoundException" => crate::error::UpdateReservationError {
meta: generic,
kind: crate::error::UpdateReservationErrorKind::NotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateReservationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyRequestsException" => crate::error::UpdateReservationError {
meta: generic,
kind: crate::error::UpdateReservationErrorKind::TooManyRequestsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_requests_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_requests_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateReservationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateReservationError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_reservation_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateReservationOutput, crate::error::UpdateReservationError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_reservation_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_reservation(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateReservationError::unhandled)?;
output.build()
})
}