#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_batch_inference_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateBatchInferenceJobOutput,
crate::error::CreateBatchInferenceJobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateBatchInferenceJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::CreateBatchInferenceJobError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::CreateBatchInferenceJobError {
meta: generic,
kind: crate::error::CreateBatchInferenceJobErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateBatchInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateBatchInferenceJobError {
meta: generic,
kind: crate::error::CreateBatchInferenceJobErrorKind::LimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateBatchInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceAlreadyExistsException" => crate::error::CreateBatchInferenceJobError {
meta: generic,
kind: crate::error::CreateBatchInferenceJobErrorKind::ResourceAlreadyExistsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::resource_already_exists_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateBatchInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::CreateBatchInferenceJobError {
meta: generic,
kind: crate::error::CreateBatchInferenceJobErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateBatchInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateBatchInferenceJobError {
meta: generic,
kind: crate::error::CreateBatchInferenceJobErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateBatchInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyTagsException" => crate::error::CreateBatchInferenceJobError {
meta: generic,
kind: crate::error::CreateBatchInferenceJobErrorKind::TooManyTagsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_tags_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_tags_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateBatchInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateBatchInferenceJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_batch_inference_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateBatchInferenceJobOutput,
crate::error::CreateBatchInferenceJobError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_batch_inference_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_batch_inference_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateBatchInferenceJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_batch_segment_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateBatchSegmentJobOutput,
crate::error::CreateBatchSegmentJobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateBatchSegmentJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateBatchSegmentJobError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::CreateBatchSegmentJobError {
meta: generic,
kind: crate::error::CreateBatchSegmentJobErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateBatchSegmentJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateBatchSegmentJobError {
meta: generic,
kind: crate::error::CreateBatchSegmentJobErrorKind::LimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateBatchSegmentJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceAlreadyExistsException" => crate::error::CreateBatchSegmentJobError {
meta: generic,
kind: crate::error::CreateBatchSegmentJobErrorKind::ResourceAlreadyExistsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::resource_already_exists_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateBatchSegmentJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::CreateBatchSegmentJobError {
meta: generic,
kind: crate::error::CreateBatchSegmentJobErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateBatchSegmentJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateBatchSegmentJobError {
meta: generic,
kind: crate::error::CreateBatchSegmentJobErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateBatchSegmentJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyTagsException" => crate::error::CreateBatchSegmentJobError {
meta: generic,
kind: crate::error::CreateBatchSegmentJobErrorKind::TooManyTagsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_tags_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_tags_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateBatchSegmentJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateBatchSegmentJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_batch_segment_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateBatchSegmentJobOutput,
crate::error::CreateBatchSegmentJobError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_batch_segment_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_batch_segment_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateBatchSegmentJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_campaign_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateCampaignOutput, crate::error::CreateCampaignError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateCampaignError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateCampaignError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::CreateCampaignError {
meta: generic,
kind: crate::error::CreateCampaignErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateCampaignError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateCampaignError {
meta: generic,
kind: crate::error::CreateCampaignErrorKind::LimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateCampaignError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceAlreadyExistsException" => crate::error::CreateCampaignError {
meta: generic,
kind: crate::error::CreateCampaignErrorKind::ResourceAlreadyExistsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::resource_already_exists_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateCampaignError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::CreateCampaignError {
meta: generic,
kind: crate::error::CreateCampaignErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateCampaignError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateCampaignError {
meta: generic,
kind: crate::error::CreateCampaignErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateCampaignError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyTagsException" => crate::error::CreateCampaignError {
meta: generic,
kind: crate::error::CreateCampaignErrorKind::TooManyTagsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_tags_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_tags_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateCampaignError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateCampaignError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_campaign_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateCampaignOutput, crate::error::CreateCampaignError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_campaign_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_campaign(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateCampaignError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_dataset_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateDatasetOutput, crate::error::CreateDatasetError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateDatasetError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateDatasetError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::CreateDatasetError {
meta: generic,
kind: crate::error::CreateDatasetErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDatasetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateDatasetError {
meta: generic,
kind: crate::error::CreateDatasetErrorKind::LimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDatasetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceAlreadyExistsException" => crate::error::CreateDatasetError {
meta: generic,
kind: crate::error::CreateDatasetErrorKind::ResourceAlreadyExistsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::resource_already_exists_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDatasetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::CreateDatasetError {
meta: generic,
kind: crate::error::CreateDatasetErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDatasetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateDatasetError {
meta: generic,
kind: crate::error::CreateDatasetErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDatasetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyTagsException" => crate::error::CreateDatasetError {
meta: generic,
kind: crate::error::CreateDatasetErrorKind::TooManyTagsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_tags_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_tags_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDatasetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateDatasetError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_dataset_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateDatasetOutput, crate::error::CreateDatasetError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_dataset_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_dataset(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateDatasetError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_dataset_export_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateDatasetExportJobOutput,
crate::error::CreateDatasetExportJobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateDatasetExportJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::CreateDatasetExportJobError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::CreateDatasetExportJobError {
meta: generic,
kind: crate::error::CreateDatasetExportJobErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDatasetExportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateDatasetExportJobError {
meta: generic,
kind: crate::error::CreateDatasetExportJobErrorKind::LimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDatasetExportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceAlreadyExistsException" => crate::error::CreateDatasetExportJobError {
meta: generic,
kind: crate::error::CreateDatasetExportJobErrorKind::ResourceAlreadyExistsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::resource_already_exists_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDatasetExportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::CreateDatasetExportJobError {
meta: generic,
kind: crate::error::CreateDatasetExportJobErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDatasetExportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateDatasetExportJobError {
meta: generic,
kind: crate::error::CreateDatasetExportJobErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDatasetExportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyTagsException" => crate::error::CreateDatasetExportJobError {
meta: generic,
kind: crate::error::CreateDatasetExportJobErrorKind::TooManyTagsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_tags_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_tags_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDatasetExportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateDatasetExportJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_dataset_export_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateDatasetExportJobOutput,
crate::error::CreateDatasetExportJobError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_dataset_export_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_dataset_export_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateDatasetExportJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_dataset_group_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateDatasetGroupOutput,
crate::error::CreateDatasetGroupError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateDatasetGroupError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateDatasetGroupError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::CreateDatasetGroupError {
meta: generic,
kind: crate::error::CreateDatasetGroupErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDatasetGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateDatasetGroupError {
meta: generic,
kind: crate::error::CreateDatasetGroupErrorKind::LimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDatasetGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceAlreadyExistsException" => crate::error::CreateDatasetGroupError {
meta: generic,
kind: crate::error::CreateDatasetGroupErrorKind::ResourceAlreadyExistsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::resource_already_exists_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDatasetGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyTagsException" => crate::error::CreateDatasetGroupError {
meta: generic,
kind: crate::error::CreateDatasetGroupErrorKind::TooManyTagsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_tags_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_tags_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDatasetGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateDatasetGroupError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_dataset_group_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateDatasetGroupOutput,
crate::error::CreateDatasetGroupError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_dataset_group_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_dataset_group(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateDatasetGroupError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_dataset_import_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateDatasetImportJobOutput,
crate::error::CreateDatasetImportJobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateDatasetImportJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::CreateDatasetImportJobError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::CreateDatasetImportJobError {
meta: generic,
kind: crate::error::CreateDatasetImportJobErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDatasetImportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateDatasetImportJobError {
meta: generic,
kind: crate::error::CreateDatasetImportJobErrorKind::LimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDatasetImportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceAlreadyExistsException" => crate::error::CreateDatasetImportJobError {
meta: generic,
kind: crate::error::CreateDatasetImportJobErrorKind::ResourceAlreadyExistsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::resource_already_exists_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDatasetImportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::CreateDatasetImportJobError {
meta: generic,
kind: crate::error::CreateDatasetImportJobErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDatasetImportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateDatasetImportJobError {
meta: generic,
kind: crate::error::CreateDatasetImportJobErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDatasetImportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyTagsException" => crate::error::CreateDatasetImportJobError {
meta: generic,
kind: crate::error::CreateDatasetImportJobErrorKind::TooManyTagsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_tags_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_tags_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDatasetImportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateDatasetImportJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_dataset_import_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateDatasetImportJobOutput,
crate::error::CreateDatasetImportJobError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_dataset_import_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_dataset_import_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateDatasetImportJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_event_tracker_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateEventTrackerOutput,
crate::error::CreateEventTrackerError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateEventTrackerError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateEventTrackerError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::CreateEventTrackerError {
meta: generic,
kind: crate::error::CreateEventTrackerErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateEventTrackerError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateEventTrackerError {
meta: generic,
kind: crate::error::CreateEventTrackerErrorKind::LimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateEventTrackerError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceAlreadyExistsException" => crate::error::CreateEventTrackerError {
meta: generic,
kind: crate::error::CreateEventTrackerErrorKind::ResourceAlreadyExistsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::resource_already_exists_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateEventTrackerError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::CreateEventTrackerError {
meta: generic,
kind: crate::error::CreateEventTrackerErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateEventTrackerError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateEventTrackerError {
meta: generic,
kind: crate::error::CreateEventTrackerErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateEventTrackerError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyTagsException" => crate::error::CreateEventTrackerError {
meta: generic,
kind: crate::error::CreateEventTrackerErrorKind::TooManyTagsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_tags_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_tags_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateEventTrackerError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateEventTrackerError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_event_tracker_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateEventTrackerOutput,
crate::error::CreateEventTrackerError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_event_tracker_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_event_tracker(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateEventTrackerError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_filter_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateFilterOutput, crate::error::CreateFilterError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateFilterError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateFilterError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::CreateFilterError {
meta: generic,
kind: crate::error::CreateFilterErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateFilterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateFilterError {
meta: generic,
kind: crate::error::CreateFilterErrorKind::LimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateFilterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceAlreadyExistsException" => crate::error::CreateFilterError {
meta: generic,
kind: crate::error::CreateFilterErrorKind::ResourceAlreadyExistsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::resource_already_exists_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateFilterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateFilterError {
meta: generic,
kind: crate::error::CreateFilterErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateFilterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyTagsException" => crate::error::CreateFilterError {
meta: generic,
kind: crate::error::CreateFilterErrorKind::TooManyTagsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_tags_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_tags_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateFilterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateFilterError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_filter_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateFilterOutput, crate::error::CreateFilterError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_filter_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_filter(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateFilterError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_metric_attribution_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateMetricAttributionOutput,
crate::error::CreateMetricAttributionError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateMetricAttributionError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::CreateMetricAttributionError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::CreateMetricAttributionError {
meta: generic,
kind: crate::error::CreateMetricAttributionErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateMetricAttributionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateMetricAttributionError {
meta: generic,
kind: crate::error::CreateMetricAttributionErrorKind::LimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateMetricAttributionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceAlreadyExistsException" => crate::error::CreateMetricAttributionError {
meta: generic,
kind: crate::error::CreateMetricAttributionErrorKind::ResourceAlreadyExistsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::resource_already_exists_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateMetricAttributionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::CreateMetricAttributionError {
meta: generic,
kind: crate::error::CreateMetricAttributionErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateMetricAttributionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateMetricAttributionError {
meta: generic,
kind: crate::error::CreateMetricAttributionErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateMetricAttributionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateMetricAttributionError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_metric_attribution_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateMetricAttributionOutput,
crate::error::CreateMetricAttributionError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_metric_attribution_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_metric_attribution(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateMetricAttributionError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_recommender_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateRecommenderOutput, crate::error::CreateRecommenderError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateRecommenderError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateRecommenderError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::CreateRecommenderError {
meta: generic,
kind: crate::error::CreateRecommenderErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateRecommenderError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateRecommenderError {
meta: generic,
kind: crate::error::CreateRecommenderErrorKind::LimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateRecommenderError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceAlreadyExistsException" => crate::error::CreateRecommenderError {
meta: generic,
kind: crate::error::CreateRecommenderErrorKind::ResourceAlreadyExistsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::resource_already_exists_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateRecommenderError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::CreateRecommenderError {
meta: generic,
kind: crate::error::CreateRecommenderErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateRecommenderError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateRecommenderError {
meta: generic,
kind: crate::error::CreateRecommenderErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateRecommenderError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyTagsException" => crate::error::CreateRecommenderError {
meta: generic,
kind: crate::error::CreateRecommenderErrorKind::TooManyTagsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_tags_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_tags_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateRecommenderError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateRecommenderError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_recommender_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateRecommenderOutput, crate::error::CreateRecommenderError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_recommender_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_recommender(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateRecommenderError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_schema_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateSchemaOutput, crate::error::CreateSchemaError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateSchemaError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateSchemaError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::CreateSchemaError {
meta: generic,
kind: crate::error::CreateSchemaErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateSchemaError {
meta: generic,
kind: crate::error::CreateSchemaErrorKind::LimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceAlreadyExistsException" => crate::error::CreateSchemaError {
meta: generic,
kind: crate::error::CreateSchemaErrorKind::ResourceAlreadyExistsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::resource_already_exists_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateSchemaError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_schema_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateSchemaOutput, crate::error::CreateSchemaError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_schema_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_schema(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateSchemaError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_solution_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateSolutionOutput, crate::error::CreateSolutionError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateSolutionError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateSolutionError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::CreateSolutionError {
meta: generic,
kind: crate::error::CreateSolutionErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateSolutionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateSolutionError {
meta: generic,
kind: crate::error::CreateSolutionErrorKind::LimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateSolutionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceAlreadyExistsException" => crate::error::CreateSolutionError {
meta: generic,
kind: crate::error::CreateSolutionErrorKind::ResourceAlreadyExistsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::resource_already_exists_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateSolutionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::CreateSolutionError {
meta: generic,
kind: crate::error::CreateSolutionErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateSolutionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateSolutionError {
meta: generic,
kind: crate::error::CreateSolutionErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateSolutionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyTagsException" => crate::error::CreateSolutionError {
meta: generic,
kind: crate::error::CreateSolutionErrorKind::TooManyTagsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_tags_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_tags_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateSolutionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateSolutionError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_solution_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateSolutionOutput, crate::error::CreateSolutionError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_solution_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_solution(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateSolutionError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_solution_version_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateSolutionVersionOutput,
crate::error::CreateSolutionVersionError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateSolutionVersionError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateSolutionVersionError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::CreateSolutionVersionError {
meta: generic,
kind: crate::error::CreateSolutionVersionErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateSolutionVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateSolutionVersionError {
meta: generic,
kind: crate::error::CreateSolutionVersionErrorKind::LimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateSolutionVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceAlreadyExistsException" => crate::error::CreateSolutionVersionError {
meta: generic,
kind: crate::error::CreateSolutionVersionErrorKind::ResourceAlreadyExistsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::resource_already_exists_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateSolutionVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::CreateSolutionVersionError {
meta: generic,
kind: crate::error::CreateSolutionVersionErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateSolutionVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateSolutionVersionError {
meta: generic,
kind: crate::error::CreateSolutionVersionErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateSolutionVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyTagsException" => crate::error::CreateSolutionVersionError {
meta: generic,
kind: crate::error::CreateSolutionVersionErrorKind::TooManyTagsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_tags_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_tags_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateSolutionVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateSolutionVersionError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_solution_version_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateSolutionVersionOutput,
crate::error::CreateSolutionVersionError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_solution_version_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_solution_version(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateSolutionVersionError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_campaign_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteCampaignOutput, crate::error::DeleteCampaignError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteCampaignError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteCampaignError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DeleteCampaignError {
meta: generic,
kind: crate::error::DeleteCampaignErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteCampaignError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::DeleteCampaignError {
meta: generic,
kind: crate::error::DeleteCampaignErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteCampaignError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteCampaignError {
meta: generic,
kind: crate::error::DeleteCampaignErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteCampaignError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteCampaignError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_campaign_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteCampaignOutput, crate::error::DeleteCampaignError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_campaign_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_dataset_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteDatasetOutput, crate::error::DeleteDatasetError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteDatasetError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteDatasetError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DeleteDatasetError {
meta: generic,
kind: crate::error::DeleteDatasetErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteDatasetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::DeleteDatasetError {
meta: generic,
kind: crate::error::DeleteDatasetErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteDatasetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteDatasetError {
meta: generic,
kind: crate::error::DeleteDatasetErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteDatasetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteDatasetError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_dataset_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteDatasetOutput, crate::error::DeleteDatasetError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_dataset_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_dataset_group_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteDatasetGroupOutput,
crate::error::DeleteDatasetGroupError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteDatasetGroupError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteDatasetGroupError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DeleteDatasetGroupError {
meta: generic,
kind: crate::error::DeleteDatasetGroupErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteDatasetGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::DeleteDatasetGroupError {
meta: generic,
kind: crate::error::DeleteDatasetGroupErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteDatasetGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteDatasetGroupError {
meta: generic,
kind: crate::error::DeleteDatasetGroupErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteDatasetGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteDatasetGroupError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_dataset_group_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteDatasetGroupOutput,
crate::error::DeleteDatasetGroupError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_dataset_group_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_event_tracker_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteEventTrackerOutput,
crate::error::DeleteEventTrackerError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteEventTrackerError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteEventTrackerError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DeleteEventTrackerError {
meta: generic,
kind: crate::error::DeleteEventTrackerErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteEventTrackerError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::DeleteEventTrackerError {
meta: generic,
kind: crate::error::DeleteEventTrackerErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteEventTrackerError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteEventTrackerError {
meta: generic,
kind: crate::error::DeleteEventTrackerErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteEventTrackerError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteEventTrackerError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_event_tracker_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteEventTrackerOutput,
crate::error::DeleteEventTrackerError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_event_tracker_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_filter_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteFilterOutput, crate::error::DeleteFilterError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteFilterError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteFilterError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DeleteFilterError {
meta: generic,
kind: crate::error::DeleteFilterErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteFilterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::DeleteFilterError {
meta: generic,
kind: crate::error::DeleteFilterErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteFilterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteFilterError {
meta: generic,
kind: crate::error::DeleteFilterErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteFilterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteFilterError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_filter_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteFilterOutput, crate::error::DeleteFilterError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_filter_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_metric_attribution_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteMetricAttributionOutput,
crate::error::DeleteMetricAttributionError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteMetricAttributionError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DeleteMetricAttributionError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DeleteMetricAttributionError {
meta: generic,
kind: crate::error::DeleteMetricAttributionErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteMetricAttributionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::DeleteMetricAttributionError {
meta: generic,
kind: crate::error::DeleteMetricAttributionErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteMetricAttributionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteMetricAttributionError {
meta: generic,
kind: crate::error::DeleteMetricAttributionErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteMetricAttributionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteMetricAttributionError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_metric_attribution_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteMetricAttributionOutput,
crate::error::DeleteMetricAttributionError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_metric_attribution_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_recommender_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteRecommenderOutput, crate::error::DeleteRecommenderError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteRecommenderError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteRecommenderError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DeleteRecommenderError {
meta: generic,
kind: crate::error::DeleteRecommenderErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteRecommenderError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::DeleteRecommenderError {
meta: generic,
kind: crate::error::DeleteRecommenderErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteRecommenderError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteRecommenderError {
meta: generic,
kind: crate::error::DeleteRecommenderErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteRecommenderError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteRecommenderError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_recommender_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteRecommenderOutput, crate::error::DeleteRecommenderError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_recommender_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_schema_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteSchemaOutput, crate::error::DeleteSchemaError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteSchemaError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteSchemaError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DeleteSchemaError {
meta: generic,
kind: crate::error::DeleteSchemaErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::DeleteSchemaError {
meta: generic,
kind: crate::error::DeleteSchemaErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteSchemaError {
meta: generic,
kind: crate::error::DeleteSchemaErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteSchemaError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_schema_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteSchemaOutput, crate::error::DeleteSchemaError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_schema_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_solution_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteSolutionOutput, crate::error::DeleteSolutionError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteSolutionError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteSolutionError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DeleteSolutionError {
meta: generic,
kind: crate::error::DeleteSolutionErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteSolutionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::DeleteSolutionError {
meta: generic,
kind: crate::error::DeleteSolutionErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteSolutionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteSolutionError {
meta: generic,
kind: crate::error::DeleteSolutionErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteSolutionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteSolutionError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_solution_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteSolutionOutput, crate::error::DeleteSolutionError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_solution_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_algorithm_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeAlgorithmOutput, crate::error::DescribeAlgorithmError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeAlgorithmError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeAlgorithmError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DescribeAlgorithmError {
meta: generic,
kind: crate::error::DescribeAlgorithmErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeAlgorithmError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeAlgorithmError {
meta: generic,
kind: crate::error::DescribeAlgorithmErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeAlgorithmError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeAlgorithmError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_algorithm_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeAlgorithmOutput, crate::error::DescribeAlgorithmError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_algorithm_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_algorithm(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeAlgorithmError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_batch_inference_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeBatchInferenceJobOutput,
crate::error::DescribeBatchInferenceJobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeBatchInferenceJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeBatchInferenceJobError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DescribeBatchInferenceJobError {
meta: generic,
kind: crate::error::DescribeBatchInferenceJobErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeBatchInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeBatchInferenceJobError {
meta: generic,
kind: crate::error::DescribeBatchInferenceJobErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeBatchInferenceJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeBatchInferenceJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_batch_inference_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeBatchInferenceJobOutput,
crate::error::DescribeBatchInferenceJobError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_batch_inference_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_batch_inference_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeBatchInferenceJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_batch_segment_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeBatchSegmentJobOutput,
crate::error::DescribeBatchSegmentJobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeBatchSegmentJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeBatchSegmentJobError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DescribeBatchSegmentJobError {
meta: generic,
kind: crate::error::DescribeBatchSegmentJobErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeBatchSegmentJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeBatchSegmentJobError {
meta: generic,
kind: crate::error::DescribeBatchSegmentJobErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeBatchSegmentJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeBatchSegmentJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_batch_segment_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeBatchSegmentJobOutput,
crate::error::DescribeBatchSegmentJobError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_batch_segment_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_batch_segment_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeBatchSegmentJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_campaign_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeCampaignOutput, crate::error::DescribeCampaignError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeCampaignError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeCampaignError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DescribeCampaignError {
meta: generic,
kind: crate::error::DescribeCampaignErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeCampaignError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeCampaignError {
meta: generic,
kind: crate::error::DescribeCampaignErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeCampaignError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeCampaignError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_campaign_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeCampaignOutput, crate::error::DescribeCampaignError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_campaign_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_campaign(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeCampaignError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_dataset_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeDatasetOutput, crate::error::DescribeDatasetError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeDatasetError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeDatasetError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DescribeDatasetError {
meta: generic,
kind: crate::error::DescribeDatasetErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeDatasetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeDatasetError {
meta: generic,
kind: crate::error::DescribeDatasetErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeDatasetError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeDatasetError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_dataset_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeDatasetOutput, crate::error::DescribeDatasetError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_dataset_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_dataset(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeDatasetError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_dataset_export_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeDatasetExportJobOutput,
crate::error::DescribeDatasetExportJobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeDatasetExportJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeDatasetExportJobError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DescribeDatasetExportJobError {
meta: generic,
kind: crate::error::DescribeDatasetExportJobErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeDatasetExportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeDatasetExportJobError {
meta: generic,
kind: crate::error::DescribeDatasetExportJobErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeDatasetExportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeDatasetExportJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_dataset_export_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeDatasetExportJobOutput,
crate::error::DescribeDatasetExportJobError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_dataset_export_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_dataset_export_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeDatasetExportJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_dataset_group_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeDatasetGroupOutput,
crate::error::DescribeDatasetGroupError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeDatasetGroupError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeDatasetGroupError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DescribeDatasetGroupError {
meta: generic,
kind: crate::error::DescribeDatasetGroupErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeDatasetGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeDatasetGroupError {
meta: generic,
kind: crate::error::DescribeDatasetGroupErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeDatasetGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeDatasetGroupError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_dataset_group_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeDatasetGroupOutput,
crate::error::DescribeDatasetGroupError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_dataset_group_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_dataset_group(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeDatasetGroupError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_dataset_import_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeDatasetImportJobOutput,
crate::error::DescribeDatasetImportJobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeDatasetImportJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeDatasetImportJobError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DescribeDatasetImportJobError {
meta: generic,
kind: crate::error::DescribeDatasetImportJobErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeDatasetImportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeDatasetImportJobError {
meta: generic,
kind: crate::error::DescribeDatasetImportJobErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeDatasetImportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeDatasetImportJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_dataset_import_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeDatasetImportJobOutput,
crate::error::DescribeDatasetImportJobError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_dataset_import_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_dataset_import_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeDatasetImportJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_event_tracker_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeEventTrackerOutput,
crate::error::DescribeEventTrackerError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeEventTrackerError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeEventTrackerError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DescribeEventTrackerError {
meta: generic,
kind: crate::error::DescribeEventTrackerErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeEventTrackerError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeEventTrackerError {
meta: generic,
kind: crate::error::DescribeEventTrackerErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeEventTrackerError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeEventTrackerError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_event_tracker_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeEventTrackerOutput,
crate::error::DescribeEventTrackerError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_event_tracker_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_event_tracker(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeEventTrackerError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_feature_transformation_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeFeatureTransformationOutput,
crate::error::DescribeFeatureTransformationError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeFeatureTransformationError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeFeatureTransformationError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DescribeFeatureTransformationError {
meta: generic,
kind: crate::error::DescribeFeatureTransformationErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeFeatureTransformationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeFeatureTransformationError {
meta: generic,
kind: crate::error::DescribeFeatureTransformationErrorKind::ResourceNotFoundException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeFeatureTransformationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
_ => crate::error::DescribeFeatureTransformationError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_feature_transformation_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeFeatureTransformationOutput,
crate::error::DescribeFeatureTransformationError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_feature_transformation_output::Builder::default();
let _ = response;
output =
crate::json_deser::deser_operation_crate_operation_describe_feature_transformation(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeFeatureTransformationError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_filter_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeFilterOutput, crate::error::DescribeFilterError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeFilterError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeFilterError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DescribeFilterError {
meta: generic,
kind: crate::error::DescribeFilterErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeFilterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeFilterError {
meta: generic,
kind: crate::error::DescribeFilterErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeFilterError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeFilterError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_filter_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeFilterOutput, crate::error::DescribeFilterError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_filter_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_filter(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeFilterError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_metric_attribution_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeMetricAttributionOutput,
crate::error::DescribeMetricAttributionError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeMetricAttributionError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeMetricAttributionError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DescribeMetricAttributionError {
meta: generic,
kind: crate::error::DescribeMetricAttributionErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeMetricAttributionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeMetricAttributionError {
meta: generic,
kind: crate::error::DescribeMetricAttributionErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeMetricAttributionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeMetricAttributionError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_metric_attribution_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeMetricAttributionOutput,
crate::error::DescribeMetricAttributionError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_metric_attribution_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_metric_attribution(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeMetricAttributionError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_recipe_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeRecipeOutput, crate::error::DescribeRecipeError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeRecipeError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeRecipeError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DescribeRecipeError {
meta: generic,
kind: crate::error::DescribeRecipeErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeRecipeError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeRecipeError {
meta: generic,
kind: crate::error::DescribeRecipeErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeRecipeError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeRecipeError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_recipe_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeRecipeOutput, crate::error::DescribeRecipeError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_recipe_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_recipe(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeRecipeError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_recommender_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeRecommenderOutput,
crate::error::DescribeRecommenderError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeRecommenderError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeRecommenderError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DescribeRecommenderError {
meta: generic,
kind: crate::error::DescribeRecommenderErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeRecommenderError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeRecommenderError {
meta: generic,
kind: crate::error::DescribeRecommenderErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeRecommenderError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeRecommenderError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_recommender_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeRecommenderOutput,
crate::error::DescribeRecommenderError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_recommender_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_recommender(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeRecommenderError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_schema_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeSchemaOutput, crate::error::DescribeSchemaError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeSchemaError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeSchemaError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DescribeSchemaError {
meta: generic,
kind: crate::error::DescribeSchemaErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeSchemaError {
meta: generic,
kind: crate::error::DescribeSchemaErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeSchemaError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeSchemaError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_schema_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeSchemaOutput, crate::error::DescribeSchemaError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_schema_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_schema(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeSchemaError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_solution_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeSolutionOutput, crate::error::DescribeSolutionError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeSolutionError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeSolutionError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DescribeSolutionError {
meta: generic,
kind: crate::error::DescribeSolutionErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeSolutionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeSolutionError {
meta: generic,
kind: crate::error::DescribeSolutionErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeSolutionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeSolutionError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_solution_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeSolutionOutput, crate::error::DescribeSolutionError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_solution_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_solution(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeSolutionError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_solution_version_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeSolutionVersionOutput,
crate::error::DescribeSolutionVersionError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeSolutionVersionError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeSolutionVersionError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DescribeSolutionVersionError {
meta: generic,
kind: crate::error::DescribeSolutionVersionErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeSolutionVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeSolutionVersionError {
meta: generic,
kind: crate::error::DescribeSolutionVersionErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeSolutionVersionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeSolutionVersionError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_solution_version_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeSolutionVersionOutput,
crate::error::DescribeSolutionVersionError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_solution_version_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_solution_version(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeSolutionVersionError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_solution_metrics_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetSolutionMetricsOutput,
crate::error::GetSolutionMetricsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetSolutionMetricsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::GetSolutionMetricsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::GetSolutionMetricsError {
meta: generic,
kind: crate::error::GetSolutionMetricsErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetSolutionMetricsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::GetSolutionMetricsError {
meta: generic,
kind: crate::error::GetSolutionMetricsErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetSolutionMetricsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::GetSolutionMetricsError {
meta: generic,
kind: crate::error::GetSolutionMetricsErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetSolutionMetricsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetSolutionMetricsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_solution_metrics_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetSolutionMetricsOutput,
crate::error::GetSolutionMetricsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_solution_metrics_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_solution_metrics(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetSolutionMetricsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_batch_inference_jobs_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListBatchInferenceJobsOutput,
crate::error::ListBatchInferenceJobsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListBatchInferenceJobsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListBatchInferenceJobsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::ListBatchInferenceJobsError {
meta: generic,
kind: crate::error::ListBatchInferenceJobsErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListBatchInferenceJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListBatchInferenceJobsError {
meta: generic,
kind: crate::error::ListBatchInferenceJobsErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListBatchInferenceJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListBatchInferenceJobsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_batch_inference_jobs_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListBatchInferenceJobsOutput,
crate::error::ListBatchInferenceJobsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_batch_inference_jobs_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_batch_inference_jobs(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListBatchInferenceJobsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_batch_segment_jobs_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListBatchSegmentJobsOutput,
crate::error::ListBatchSegmentJobsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListBatchSegmentJobsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListBatchSegmentJobsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::ListBatchSegmentJobsError {
meta: generic,
kind: crate::error::ListBatchSegmentJobsErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListBatchSegmentJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListBatchSegmentJobsError {
meta: generic,
kind: crate::error::ListBatchSegmentJobsErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListBatchSegmentJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListBatchSegmentJobsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_batch_segment_jobs_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListBatchSegmentJobsOutput,
crate::error::ListBatchSegmentJobsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_batch_segment_jobs_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_batch_segment_jobs(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListBatchSegmentJobsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_campaigns_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListCampaignsOutput, crate::error::ListCampaignsError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListCampaignsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListCampaignsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::ListCampaignsError {
meta: generic,
kind: crate::error::ListCampaignsErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListCampaignsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListCampaignsError {
meta: generic,
kind: crate::error::ListCampaignsErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListCampaignsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListCampaignsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_campaigns_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListCampaignsOutput, crate::error::ListCampaignsError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_campaigns_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_campaigns(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListCampaignsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_dataset_export_jobs_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListDatasetExportJobsOutput,
crate::error::ListDatasetExportJobsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListDatasetExportJobsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListDatasetExportJobsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::ListDatasetExportJobsError {
meta: generic,
kind: crate::error::ListDatasetExportJobsErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDatasetExportJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListDatasetExportJobsError {
meta: generic,
kind: crate::error::ListDatasetExportJobsErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDatasetExportJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListDatasetExportJobsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_dataset_export_jobs_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListDatasetExportJobsOutput,
crate::error::ListDatasetExportJobsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_dataset_export_jobs_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_dataset_export_jobs(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListDatasetExportJobsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_dataset_groups_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListDatasetGroupsOutput, crate::error::ListDatasetGroupsError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListDatasetGroupsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListDatasetGroupsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidNextTokenException" => crate::error::ListDatasetGroupsError {
meta: generic,
kind: crate::error::ListDatasetGroupsErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDatasetGroupsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListDatasetGroupsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_dataset_groups_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListDatasetGroupsOutput, crate::error::ListDatasetGroupsError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_dataset_groups_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_dataset_groups(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListDatasetGroupsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_dataset_import_jobs_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListDatasetImportJobsOutput,
crate::error::ListDatasetImportJobsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListDatasetImportJobsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListDatasetImportJobsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::ListDatasetImportJobsError {
meta: generic,
kind: crate::error::ListDatasetImportJobsErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDatasetImportJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListDatasetImportJobsError {
meta: generic,
kind: crate::error::ListDatasetImportJobsErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDatasetImportJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListDatasetImportJobsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_dataset_import_jobs_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListDatasetImportJobsOutput,
crate::error::ListDatasetImportJobsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_dataset_import_jobs_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_dataset_import_jobs(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListDatasetImportJobsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_datasets_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListDatasetsOutput, crate::error::ListDatasetsError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListDatasetsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListDatasetsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::ListDatasetsError {
meta: generic,
kind: crate::error::ListDatasetsErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDatasetsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListDatasetsError {
meta: generic,
kind: crate::error::ListDatasetsErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDatasetsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListDatasetsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_datasets_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListDatasetsOutput, crate::error::ListDatasetsError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_datasets_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_datasets(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListDatasetsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_event_trackers_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListEventTrackersOutput, crate::error::ListEventTrackersError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListEventTrackersError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListEventTrackersError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::ListEventTrackersError {
meta: generic,
kind: crate::error::ListEventTrackersErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListEventTrackersError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListEventTrackersError {
meta: generic,
kind: crate::error::ListEventTrackersErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListEventTrackersError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListEventTrackersError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_event_trackers_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListEventTrackersOutput, crate::error::ListEventTrackersError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_event_trackers_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_event_trackers(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListEventTrackersError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_filters_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListFiltersOutput, crate::error::ListFiltersError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListFiltersError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListFiltersError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::ListFiltersError {
meta: generic,
kind: crate::error::ListFiltersErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListFiltersError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListFiltersError {
meta: generic,
kind: crate::error::ListFiltersErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListFiltersError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListFiltersError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_filters_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListFiltersOutput, crate::error::ListFiltersError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_filters_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_filters(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListFiltersError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_metric_attribution_metrics_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListMetricAttributionMetricsOutput,
crate::error::ListMetricAttributionMetricsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListMetricAttributionMetricsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListMetricAttributionMetricsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::ListMetricAttributionMetricsError {
meta: generic,
kind: crate::error::ListMetricAttributionMetricsErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListMetricAttributionMetricsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListMetricAttributionMetricsError {
meta: generic,
kind: crate::error::ListMetricAttributionMetricsErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListMetricAttributionMetricsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListMetricAttributionMetricsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_metric_attribution_metrics_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListMetricAttributionMetricsOutput,
crate::error::ListMetricAttributionMetricsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_metric_attribution_metrics_output::Builder::default();
let _ = response;
output =
crate::json_deser::deser_operation_crate_operation_list_metric_attribution_metrics(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListMetricAttributionMetricsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_metric_attributions_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListMetricAttributionsOutput,
crate::error::ListMetricAttributionsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListMetricAttributionsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListMetricAttributionsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::ListMetricAttributionsError {
meta: generic,
kind: crate::error::ListMetricAttributionsErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListMetricAttributionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListMetricAttributionsError {
meta: generic,
kind: crate::error::ListMetricAttributionsErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListMetricAttributionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListMetricAttributionsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_metric_attributions_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListMetricAttributionsOutput,
crate::error::ListMetricAttributionsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_metric_attributions_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_metric_attributions(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListMetricAttributionsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_recipes_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListRecipesOutput, crate::error::ListRecipesError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListRecipesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListRecipesError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::ListRecipesError {
meta: generic,
kind: crate::error::ListRecipesErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListRecipesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListRecipesError {
meta: generic,
kind: crate::error::ListRecipesErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListRecipesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListRecipesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_recipes_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListRecipesOutput, crate::error::ListRecipesError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_recipes_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_recipes(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListRecipesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_recommenders_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListRecommendersOutput, crate::error::ListRecommendersError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListRecommendersError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListRecommendersError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::ListRecommendersError {
meta: generic,
kind: crate::error::ListRecommendersErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListRecommendersError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListRecommendersError {
meta: generic,
kind: crate::error::ListRecommendersErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListRecommendersError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListRecommendersError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_recommenders_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListRecommendersOutput, crate::error::ListRecommendersError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_recommenders_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_recommenders(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListRecommendersError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_schemas_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListSchemasOutput, crate::error::ListSchemasError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListSchemasError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListSchemasError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidNextTokenException" => crate::error::ListSchemasError {
meta: generic,
kind: crate::error::ListSchemasErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListSchemasError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListSchemasError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_schemas_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListSchemasOutput, crate::error::ListSchemasError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_schemas_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_schemas(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListSchemasError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_solutions_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListSolutionsOutput, crate::error::ListSolutionsError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListSolutionsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListSolutionsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::ListSolutionsError {
meta: generic,
kind: crate::error::ListSolutionsErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListSolutionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListSolutionsError {
meta: generic,
kind: crate::error::ListSolutionsErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListSolutionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListSolutionsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_solutions_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListSolutionsOutput, crate::error::ListSolutionsError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_solutions_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_solutions(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListSolutionsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_solution_versions_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListSolutionVersionsOutput,
crate::error::ListSolutionVersionsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListSolutionVersionsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListSolutionVersionsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::ListSolutionVersionsError {
meta: generic,
kind: crate::error::ListSolutionVersionsErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListSolutionVersionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListSolutionVersionsError {
meta: generic,
kind: crate::error::ListSolutionVersionsErrorKind::InvalidNextTokenException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_next_token_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_next_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListSolutionVersionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListSolutionVersionsError {
meta: generic,
kind: crate::error::ListSolutionVersionsErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListSolutionVersionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListSolutionVersionsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_solution_versions_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListSolutionVersionsOutput,
crate::error::ListSolutionVersionsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_solution_versions_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_solution_versions(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListSolutionVersionsError::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 {
"InvalidInputException" => crate::error::ListTagsForResourceError {
meta: generic,
kind: crate::error::ListTagsForResourceErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_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
}),
},
"ResourceInUseException" => crate::error::ListTagsForResourceError {
meta: generic,
kind: crate::error::ListTagsForResourceErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_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
}),
},
"ResourceNotFoundException" => crate::error::ListTagsForResourceError {
meta: generic,
kind: crate::error::ListTagsForResourceErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_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_start_recommender_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StartRecommenderOutput, crate::error::StartRecommenderError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StartRecommenderError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::StartRecommenderError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::StartRecommenderError {
meta: generic,
kind: crate::error::StartRecommenderErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartRecommenderError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::StartRecommenderError {
meta: generic,
kind: crate::error::StartRecommenderErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartRecommenderError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::StartRecommenderError {
meta: generic,
kind: crate::error::StartRecommenderErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartRecommenderError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::StartRecommenderError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_recommender_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StartRecommenderOutput, crate::error::StartRecommenderError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::start_recommender_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_start_recommender(
response.body().as_ref(),
output,
)
.map_err(crate::error::StartRecommenderError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_recommender_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StopRecommenderOutput, crate::error::StopRecommenderError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StopRecommenderError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::StopRecommenderError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::StopRecommenderError {
meta: generic,
kind: crate::error::StopRecommenderErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopRecommenderError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::StopRecommenderError {
meta: generic,
kind: crate::error::StopRecommenderErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopRecommenderError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::StopRecommenderError {
meta: generic,
kind: crate::error::StopRecommenderErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopRecommenderError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::StopRecommenderError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_recommender_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StopRecommenderOutput, crate::error::StopRecommenderError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::stop_recommender_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_stop_recommender(
response.body().as_ref(),
output,
)
.map_err(crate::error::StopRecommenderError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_solution_version_creation_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::StopSolutionVersionCreationOutput,
crate::error::StopSolutionVersionCreationError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StopSolutionVersionCreationError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::StopSolutionVersionCreationError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::StopSolutionVersionCreationError {
meta: generic,
kind: crate::error::StopSolutionVersionCreationErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopSolutionVersionCreationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::StopSolutionVersionCreationError {
meta: generic,
kind: crate::error::StopSolutionVersionCreationErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopSolutionVersionCreationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::StopSolutionVersionCreationError {
meta: generic,
kind: crate::error::StopSolutionVersionCreationErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopSolutionVersionCreationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::StopSolutionVersionCreationError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_solution_version_creation_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::StopSolutionVersionCreationOutput,
crate::error::StopSolutionVersionCreationError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::stop_solution_version_creation_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_tag_resource_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::TagResourceOutput, crate::error::TagResourceError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::TagResourceError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::TagResourceError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::TagResourceError {
meta: generic,
kind: crate::error::TagResourceErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::TagResourceError {
meta: generic,
kind: crate::error::TagResourceErrorKind::LimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::TagResourceError {
meta: generic,
kind: crate::error::TagResourceErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::TagResourceError {
meta: generic,
kind: crate::error::TagResourceErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyTagsException" => crate::error::TagResourceError {
meta: generic,
kind: crate::error::TagResourceErrorKind::TooManyTagsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_tags_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_tags_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::TagResourceError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_tag_resource_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::TagResourceOutput, crate::error::TagResourceError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::tag_resource_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_untag_resource_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UntagResourceOutput, crate::error::UntagResourceError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UntagResourceError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UntagResourceError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::UntagResourceError {
meta: generic,
kind: crate::error::UntagResourceErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UntagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::UntagResourceError {
meta: generic,
kind: crate::error::UntagResourceErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UntagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UntagResourceError {
meta: generic,
kind: crate::error::UntagResourceErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UntagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyTagKeysException" => crate::error::UntagResourceError {
meta: generic,
kind: crate::error::UntagResourceErrorKind::TooManyTagKeysException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_tag_keys_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_tag_keys_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UntagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UntagResourceError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_untag_resource_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UntagResourceOutput, crate::error::UntagResourceError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::untag_resource_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_campaign_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateCampaignOutput, crate::error::UpdateCampaignError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateCampaignError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UpdateCampaignError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::UpdateCampaignError {
meta: generic,
kind: crate::error::UpdateCampaignErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateCampaignError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::UpdateCampaignError {
meta: generic,
kind: crate::error::UpdateCampaignErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateCampaignError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpdateCampaignError {
meta: generic,
kind: crate::error::UpdateCampaignErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateCampaignError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateCampaignError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_campaign_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateCampaignOutput, crate::error::UpdateCampaignError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_campaign_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_campaign(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateCampaignError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_metric_attribution_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateMetricAttributionOutput,
crate::error::UpdateMetricAttributionError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateMetricAttributionError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::UpdateMetricAttributionError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::UpdateMetricAttributionError {
meta: generic,
kind: crate::error::UpdateMetricAttributionErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateMetricAttributionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceAlreadyExistsException" => crate::error::UpdateMetricAttributionError {
meta: generic,
kind: crate::error::UpdateMetricAttributionErrorKind::ResourceAlreadyExistsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::resource_already_exists_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateMetricAttributionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::UpdateMetricAttributionError {
meta: generic,
kind: crate::error::UpdateMetricAttributionErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateMetricAttributionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpdateMetricAttributionError {
meta: generic,
kind: crate::error::UpdateMetricAttributionErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateMetricAttributionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateMetricAttributionError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_metric_attribution_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateMetricAttributionOutput,
crate::error::UpdateMetricAttributionError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_metric_attribution_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_metric_attribution(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateMetricAttributionError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_recommender_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateRecommenderOutput, crate::error::UpdateRecommenderError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateRecommenderError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UpdateRecommenderError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::UpdateRecommenderError {
meta: generic,
kind: crate::error::UpdateRecommenderErrorKind::InvalidInputException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_input_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_input_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateRecommenderError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::UpdateRecommenderError {
meta: generic,
kind: crate::error::UpdateRecommenderErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateRecommenderError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpdateRecommenderError {
meta: generic,
kind: crate::error::UpdateRecommenderErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateRecommenderError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateRecommenderError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_recommender_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateRecommenderOutput, crate::error::UpdateRecommenderError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_recommender_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_recommender(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateRecommenderError::unhandled)?;
output.build()
})
}