#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_auto_predictor_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateAutoPredictorOutput,
crate::error::CreateAutoPredictorError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateAutoPredictorError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateAutoPredictorError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::CreateAutoPredictorError {
meta: generic,
kind: crate::error::CreateAutoPredictorErrorKind::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::CreateAutoPredictorError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateAutoPredictorError {
meta: generic,
kind: crate::error::CreateAutoPredictorErrorKind::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::CreateAutoPredictorError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceAlreadyExistsException" => crate::error::CreateAutoPredictorError {
meta: generic,
kind: crate::error::CreateAutoPredictorErrorKind::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::CreateAutoPredictorError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::CreateAutoPredictorError {
meta: generic,
kind: crate::error::CreateAutoPredictorErrorKind::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::CreateAutoPredictorError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateAutoPredictorError {
meta: generic,
kind: crate::error::CreateAutoPredictorErrorKind::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::CreateAutoPredictorError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateAutoPredictorError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_auto_predictor_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateAutoPredictorOutput,
crate::error::CreateAutoPredictorError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_auto_predictor_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_auto_predictor(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateAutoPredictorError::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
}),
},
_ => 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_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
}),
},
"ResourceInUseException" => crate::error::CreateDatasetGroupError {
meta: generic,
kind: crate::error::CreateDatasetGroupErrorKind::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::CreateDatasetGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateDatasetGroupError {
meta: generic,
kind: crate::error::CreateDatasetGroupErrorKind::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::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
}),
},
_ => 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_explainability_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateExplainabilityOutput,
crate::error::CreateExplainabilityError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateExplainabilityError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateExplainabilityError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::CreateExplainabilityError {
meta: generic,
kind: crate::error::CreateExplainabilityErrorKind::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::CreateExplainabilityError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateExplainabilityError {
meta: generic,
kind: crate::error::CreateExplainabilityErrorKind::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::CreateExplainabilityError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceAlreadyExistsException" => crate::error::CreateExplainabilityError {
meta: generic,
kind: crate::error::CreateExplainabilityErrorKind::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::CreateExplainabilityError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::CreateExplainabilityError {
meta: generic,
kind: crate::error::CreateExplainabilityErrorKind::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::CreateExplainabilityError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateExplainabilityError {
meta: generic,
kind: crate::error::CreateExplainabilityErrorKind::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::CreateExplainabilityError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateExplainabilityError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_explainability_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateExplainabilityOutput,
crate::error::CreateExplainabilityError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_explainability_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_explainability(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateExplainabilityError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_explainability_export_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateExplainabilityExportOutput,
crate::error::CreateExplainabilityExportError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateExplainabilityExportError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::CreateExplainabilityExportError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::CreateExplainabilityExportError {
meta: generic,
kind: crate::error::CreateExplainabilityExportErrorKind::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::CreateExplainabilityExportError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateExplainabilityExportError {
meta: generic,
kind: crate::error::CreateExplainabilityExportErrorKind::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::CreateExplainabilityExportError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceAlreadyExistsException" => crate::error::CreateExplainabilityExportError {
meta: generic,
kind: crate::error::CreateExplainabilityExportErrorKind::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::CreateExplainabilityExportError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ResourceInUseException" => crate::error::CreateExplainabilityExportError {
meta: generic,
kind: crate::error::CreateExplainabilityExportErrorKind::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::CreateExplainabilityExportError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateExplainabilityExportError {
meta: generic,
kind: crate::error::CreateExplainabilityExportErrorKind::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::CreateExplainabilityExportError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateExplainabilityExportError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_explainability_export_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateExplainabilityExportOutput,
crate::error::CreateExplainabilityExportError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_explainability_export_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_explainability_export(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateExplainabilityExportError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_forecast_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateForecastOutput, crate::error::CreateForecastError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateForecastError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateForecastError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::CreateForecastError {
meta: generic,
kind: crate::error::CreateForecastErrorKind::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::CreateForecastError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateForecastError {
meta: generic,
kind: crate::error::CreateForecastErrorKind::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::CreateForecastError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceAlreadyExistsException" => crate::error::CreateForecastError {
meta: generic,
kind: crate::error::CreateForecastErrorKind::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::CreateForecastError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::CreateForecastError {
meta: generic,
kind: crate::error::CreateForecastErrorKind::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::CreateForecastError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateForecastError {
meta: generic,
kind: crate::error::CreateForecastErrorKind::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::CreateForecastError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateForecastError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_forecast_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateForecastOutput, crate::error::CreateForecastError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_forecast_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_forecast(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateForecastError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_forecast_export_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateForecastExportJobOutput,
crate::error::CreateForecastExportJobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateForecastExportJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::CreateForecastExportJobError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::CreateForecastExportJobError {
meta: generic,
kind: crate::error::CreateForecastExportJobErrorKind::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::CreateForecastExportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateForecastExportJobError {
meta: generic,
kind: crate::error::CreateForecastExportJobErrorKind::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::CreateForecastExportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceAlreadyExistsException" => crate::error::CreateForecastExportJobError {
meta: generic,
kind: crate::error::CreateForecastExportJobErrorKind::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::CreateForecastExportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::CreateForecastExportJobError {
meta: generic,
kind: crate::error::CreateForecastExportJobErrorKind::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::CreateForecastExportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateForecastExportJobError {
meta: generic,
kind: crate::error::CreateForecastExportJobErrorKind::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::CreateForecastExportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateForecastExportJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_forecast_export_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateForecastExportJobOutput,
crate::error::CreateForecastExportJobError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_forecast_export_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_forecast_export_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateForecastExportJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_monitor_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateMonitorOutput, crate::error::CreateMonitorError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateMonitorError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateMonitorError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::CreateMonitorError {
meta: generic,
kind: crate::error::CreateMonitorErrorKind::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::CreateMonitorError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateMonitorError {
meta: generic,
kind: crate::error::CreateMonitorErrorKind::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::CreateMonitorError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceAlreadyExistsException" => crate::error::CreateMonitorError {
meta: generic,
kind: crate::error::CreateMonitorErrorKind::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::CreateMonitorError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::CreateMonitorError {
meta: generic,
kind: crate::error::CreateMonitorErrorKind::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::CreateMonitorError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateMonitorError {
meta: generic,
kind: crate::error::CreateMonitorErrorKind::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::CreateMonitorError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateMonitorError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_monitor_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateMonitorOutput, crate::error::CreateMonitorError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_monitor_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_monitor(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateMonitorError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_predictor_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreatePredictorOutput, crate::error::CreatePredictorError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreatePredictorError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreatePredictorError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::CreatePredictorError {
meta: generic,
kind: crate::error::CreatePredictorErrorKind::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::CreatePredictorError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreatePredictorError {
meta: generic,
kind: crate::error::CreatePredictorErrorKind::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::CreatePredictorError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceAlreadyExistsException" => crate::error::CreatePredictorError {
meta: generic,
kind: crate::error::CreatePredictorErrorKind::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::CreatePredictorError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::CreatePredictorError {
meta: generic,
kind: crate::error::CreatePredictorErrorKind::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::CreatePredictorError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreatePredictorError {
meta: generic,
kind: crate::error::CreatePredictorErrorKind::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::CreatePredictorError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreatePredictorError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_predictor_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreatePredictorOutput, crate::error::CreatePredictorError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_predictor_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_predictor(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreatePredictorError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_predictor_backtest_export_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreatePredictorBacktestExportJobOutput,
crate::error::CreatePredictorBacktestExportJobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreatePredictorBacktestExportJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::CreatePredictorBacktestExportJobError::unhandled(generic))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::CreatePredictorBacktestExportJobError { meta: generic, kind: crate::error::CreatePredictorBacktestExportJobErrorKind::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::CreatePredictorBacktestExportJobError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"LimitExceededException" => crate::error::CreatePredictorBacktestExportJobError { meta: generic, kind: crate::error::CreatePredictorBacktestExportJobErrorKind::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::CreatePredictorBacktestExportJobError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ResourceAlreadyExistsException" => crate::error::CreatePredictorBacktestExportJobError { meta: generic, kind: crate::error::CreatePredictorBacktestExportJobErrorKind::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::CreatePredictorBacktestExportJobError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ResourceInUseException" => crate::error::CreatePredictorBacktestExportJobError { meta: generic, kind: crate::error::CreatePredictorBacktestExportJobErrorKind::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::CreatePredictorBacktestExportJobError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ResourceNotFoundException" => crate::error::CreatePredictorBacktestExportJobError { meta: generic, kind: crate::error::CreatePredictorBacktestExportJobErrorKind::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::CreatePredictorBacktestExportJobError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
_ => crate::error::CreatePredictorBacktestExportJobError::generic(generic)
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_predictor_backtest_export_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreatePredictorBacktestExportJobOutput,
crate::error::CreatePredictorBacktestExportJobError,
> {
Ok({
#[allow(unused_mut)]
let mut output =
crate::output::create_predictor_backtest_export_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_predictor_backtest_export_job(response.body().as_ref(), output).map_err(crate::error::CreatePredictorBacktestExportJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_what_if_analysis_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateWhatIfAnalysisOutput,
crate::error::CreateWhatIfAnalysisError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateWhatIfAnalysisError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateWhatIfAnalysisError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::CreateWhatIfAnalysisError {
meta: generic,
kind: crate::error::CreateWhatIfAnalysisErrorKind::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::CreateWhatIfAnalysisError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateWhatIfAnalysisError {
meta: generic,
kind: crate::error::CreateWhatIfAnalysisErrorKind::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::CreateWhatIfAnalysisError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceAlreadyExistsException" => crate::error::CreateWhatIfAnalysisError {
meta: generic,
kind: crate::error::CreateWhatIfAnalysisErrorKind::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::CreateWhatIfAnalysisError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::CreateWhatIfAnalysisError {
meta: generic,
kind: crate::error::CreateWhatIfAnalysisErrorKind::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::CreateWhatIfAnalysisError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateWhatIfAnalysisError {
meta: generic,
kind: crate::error::CreateWhatIfAnalysisErrorKind::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::CreateWhatIfAnalysisError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateWhatIfAnalysisError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_what_if_analysis_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateWhatIfAnalysisOutput,
crate::error::CreateWhatIfAnalysisError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_what_if_analysis_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_what_if_analysis(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateWhatIfAnalysisError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_what_if_forecast_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateWhatIfForecastOutput,
crate::error::CreateWhatIfForecastError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateWhatIfForecastError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateWhatIfForecastError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::CreateWhatIfForecastError {
meta: generic,
kind: crate::error::CreateWhatIfForecastErrorKind::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::CreateWhatIfForecastError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateWhatIfForecastError {
meta: generic,
kind: crate::error::CreateWhatIfForecastErrorKind::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::CreateWhatIfForecastError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceAlreadyExistsException" => crate::error::CreateWhatIfForecastError {
meta: generic,
kind: crate::error::CreateWhatIfForecastErrorKind::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::CreateWhatIfForecastError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::CreateWhatIfForecastError {
meta: generic,
kind: crate::error::CreateWhatIfForecastErrorKind::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::CreateWhatIfForecastError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateWhatIfForecastError {
meta: generic,
kind: crate::error::CreateWhatIfForecastErrorKind::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::CreateWhatIfForecastError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateWhatIfForecastError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_what_if_forecast_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateWhatIfForecastOutput,
crate::error::CreateWhatIfForecastError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_what_if_forecast_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_what_if_forecast(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateWhatIfForecastError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_what_if_forecast_export_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateWhatIfForecastExportOutput,
crate::error::CreateWhatIfForecastExportError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateWhatIfForecastExportError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::CreateWhatIfForecastExportError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::CreateWhatIfForecastExportError {
meta: generic,
kind: crate::error::CreateWhatIfForecastExportErrorKind::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::CreateWhatIfForecastExportError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateWhatIfForecastExportError {
meta: generic,
kind: crate::error::CreateWhatIfForecastExportErrorKind::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::CreateWhatIfForecastExportError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceAlreadyExistsException" => crate::error::CreateWhatIfForecastExportError {
meta: generic,
kind: crate::error::CreateWhatIfForecastExportErrorKind::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::CreateWhatIfForecastExportError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ResourceInUseException" => crate::error::CreateWhatIfForecastExportError {
meta: generic,
kind: crate::error::CreateWhatIfForecastExportErrorKind::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::CreateWhatIfForecastExportError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CreateWhatIfForecastExportError {
meta: generic,
kind: crate::error::CreateWhatIfForecastExportErrorKind::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::CreateWhatIfForecastExportError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateWhatIfForecastExportError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_what_if_forecast_export_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateWhatIfForecastExportOutput,
crate::error::CreateWhatIfForecastExportError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_what_if_forecast_export_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_what_if_forecast_export(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateWhatIfForecastExportError::unhandled)?;
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_dataset_import_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteDatasetImportJobOutput,
crate::error::DeleteDatasetImportJobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteDatasetImportJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DeleteDatasetImportJobError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DeleteDatasetImportJobError {
meta: generic,
kind: crate::error::DeleteDatasetImportJobErrorKind::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::DeleteDatasetImportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::DeleteDatasetImportJobError {
meta: generic,
kind: crate::error::DeleteDatasetImportJobErrorKind::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::DeleteDatasetImportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteDatasetImportJobError {
meta: generic,
kind: crate::error::DeleteDatasetImportJobErrorKind::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::DeleteDatasetImportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteDatasetImportJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_dataset_import_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteDatasetImportJobOutput,
crate::error::DeleteDatasetImportJobError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_dataset_import_job_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_explainability_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteExplainabilityOutput,
crate::error::DeleteExplainabilityError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteExplainabilityError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteExplainabilityError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DeleteExplainabilityError {
meta: generic,
kind: crate::error::DeleteExplainabilityErrorKind::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::DeleteExplainabilityError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::DeleteExplainabilityError {
meta: generic,
kind: crate::error::DeleteExplainabilityErrorKind::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::DeleteExplainabilityError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteExplainabilityError {
meta: generic,
kind: crate::error::DeleteExplainabilityErrorKind::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::DeleteExplainabilityError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteExplainabilityError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_explainability_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteExplainabilityOutput,
crate::error::DeleteExplainabilityError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_explainability_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_explainability_export_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteExplainabilityExportOutput,
crate::error::DeleteExplainabilityExportError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteExplainabilityExportError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DeleteExplainabilityExportError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DeleteExplainabilityExportError {
meta: generic,
kind: crate::error::DeleteExplainabilityExportErrorKind::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::DeleteExplainabilityExportError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::DeleteExplainabilityExportError {
meta: generic,
kind: crate::error::DeleteExplainabilityExportErrorKind::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::DeleteExplainabilityExportError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteExplainabilityExportError {
meta: generic,
kind: crate::error::DeleteExplainabilityExportErrorKind::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::DeleteExplainabilityExportError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteExplainabilityExportError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_explainability_export_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteExplainabilityExportOutput,
crate::error::DeleteExplainabilityExportError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_explainability_export_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_forecast_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteForecastOutput, crate::error::DeleteForecastError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteForecastError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteForecastError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DeleteForecastError {
meta: generic,
kind: crate::error::DeleteForecastErrorKind::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::DeleteForecastError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::DeleteForecastError {
meta: generic,
kind: crate::error::DeleteForecastErrorKind::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::DeleteForecastError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteForecastError {
meta: generic,
kind: crate::error::DeleteForecastErrorKind::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::DeleteForecastError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteForecastError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_forecast_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteForecastOutput, crate::error::DeleteForecastError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_forecast_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_forecast_export_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteForecastExportJobOutput,
crate::error::DeleteForecastExportJobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteForecastExportJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DeleteForecastExportJobError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DeleteForecastExportJobError {
meta: generic,
kind: crate::error::DeleteForecastExportJobErrorKind::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::DeleteForecastExportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::DeleteForecastExportJobError {
meta: generic,
kind: crate::error::DeleteForecastExportJobErrorKind::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::DeleteForecastExportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteForecastExportJobError {
meta: generic,
kind: crate::error::DeleteForecastExportJobErrorKind::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::DeleteForecastExportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteForecastExportJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_forecast_export_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteForecastExportJobOutput,
crate::error::DeleteForecastExportJobError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_forecast_export_job_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_monitor_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteMonitorOutput, crate::error::DeleteMonitorError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteMonitorError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteMonitorError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DeleteMonitorError {
meta: generic,
kind: crate::error::DeleteMonitorErrorKind::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::DeleteMonitorError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::DeleteMonitorError {
meta: generic,
kind: crate::error::DeleteMonitorErrorKind::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::DeleteMonitorError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteMonitorError {
meta: generic,
kind: crate::error::DeleteMonitorErrorKind::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::DeleteMonitorError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteMonitorError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_monitor_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteMonitorOutput, crate::error::DeleteMonitorError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_monitor_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_predictor_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeletePredictorOutput, crate::error::DeletePredictorError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeletePredictorError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeletePredictorError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DeletePredictorError {
meta: generic,
kind: crate::error::DeletePredictorErrorKind::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::DeletePredictorError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::DeletePredictorError {
meta: generic,
kind: crate::error::DeletePredictorErrorKind::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::DeletePredictorError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeletePredictorError {
meta: generic,
kind: crate::error::DeletePredictorErrorKind::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::DeletePredictorError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeletePredictorError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_predictor_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeletePredictorOutput, crate::error::DeletePredictorError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_predictor_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_predictor_backtest_export_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeletePredictorBacktestExportJobOutput,
crate::error::DeletePredictorBacktestExportJobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeletePredictorBacktestExportJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DeletePredictorBacktestExportJobError::unhandled(generic))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DeletePredictorBacktestExportJobError {
meta: generic,
kind: crate::error::DeletePredictorBacktestExportJobErrorKind::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::DeletePredictorBacktestExportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::DeletePredictorBacktestExportJobError {
meta: generic,
kind: crate::error::DeletePredictorBacktestExportJobErrorKind::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::DeletePredictorBacktestExportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ResourceNotFoundException" => crate::error::DeletePredictorBacktestExportJobError {
meta: generic,
kind:
crate::error::DeletePredictorBacktestExportJobErrorKind::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::DeletePredictorBacktestExportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
_ => crate::error::DeletePredictorBacktestExportJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_predictor_backtest_export_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeletePredictorBacktestExportJobOutput,
crate::error::DeletePredictorBacktestExportJobError,
> {
Ok({
#[allow(unused_mut)]
let mut output =
crate::output::delete_predictor_backtest_export_job_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_resource_tree_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteResourceTreeOutput,
crate::error::DeleteResourceTreeError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteResourceTreeError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteResourceTreeError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DeleteResourceTreeError {
meta: generic,
kind: crate::error::DeleteResourceTreeErrorKind::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::DeleteResourceTreeError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::DeleteResourceTreeError {
meta: generic,
kind: crate::error::DeleteResourceTreeErrorKind::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::DeleteResourceTreeError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteResourceTreeError {
meta: generic,
kind: crate::error::DeleteResourceTreeErrorKind::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::DeleteResourceTreeError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteResourceTreeError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_resource_tree_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteResourceTreeOutput,
crate::error::DeleteResourceTreeError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_resource_tree_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_what_if_analysis_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteWhatIfAnalysisOutput,
crate::error::DeleteWhatIfAnalysisError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteWhatIfAnalysisError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteWhatIfAnalysisError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DeleteWhatIfAnalysisError {
meta: generic,
kind: crate::error::DeleteWhatIfAnalysisErrorKind::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::DeleteWhatIfAnalysisError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::DeleteWhatIfAnalysisError {
meta: generic,
kind: crate::error::DeleteWhatIfAnalysisErrorKind::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::DeleteWhatIfAnalysisError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteWhatIfAnalysisError {
meta: generic,
kind: crate::error::DeleteWhatIfAnalysisErrorKind::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::DeleteWhatIfAnalysisError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteWhatIfAnalysisError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_what_if_analysis_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteWhatIfAnalysisOutput,
crate::error::DeleteWhatIfAnalysisError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_what_if_analysis_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_what_if_forecast_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteWhatIfForecastOutput,
crate::error::DeleteWhatIfForecastError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteWhatIfForecastError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteWhatIfForecastError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DeleteWhatIfForecastError {
meta: generic,
kind: crate::error::DeleteWhatIfForecastErrorKind::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::DeleteWhatIfForecastError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::DeleteWhatIfForecastError {
meta: generic,
kind: crate::error::DeleteWhatIfForecastErrorKind::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::DeleteWhatIfForecastError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteWhatIfForecastError {
meta: generic,
kind: crate::error::DeleteWhatIfForecastErrorKind::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::DeleteWhatIfForecastError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteWhatIfForecastError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_what_if_forecast_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteWhatIfForecastOutput,
crate::error::DeleteWhatIfForecastError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_what_if_forecast_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_what_if_forecast_export_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteWhatIfForecastExportOutput,
crate::error::DeleteWhatIfForecastExportError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteWhatIfForecastExportError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DeleteWhatIfForecastExportError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DeleteWhatIfForecastExportError {
meta: generic,
kind: crate::error::DeleteWhatIfForecastExportErrorKind::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::DeleteWhatIfForecastExportError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::DeleteWhatIfForecastExportError {
meta: generic,
kind: crate::error::DeleteWhatIfForecastExportErrorKind::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::DeleteWhatIfForecastExportError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteWhatIfForecastExportError {
meta: generic,
kind: crate::error::DeleteWhatIfForecastExportErrorKind::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::DeleteWhatIfForecastExportError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteWhatIfForecastExportError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_what_if_forecast_export_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteWhatIfForecastExportOutput,
crate::error::DeleteWhatIfForecastExportError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_what_if_forecast_export_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_auto_predictor_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeAutoPredictorOutput,
crate::error::DescribeAutoPredictorError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeAutoPredictorError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeAutoPredictorError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DescribeAutoPredictorError {
meta: generic,
kind: crate::error::DescribeAutoPredictorErrorKind::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::DescribeAutoPredictorError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeAutoPredictorError {
meta: generic,
kind: crate::error::DescribeAutoPredictorErrorKind::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::DescribeAutoPredictorError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeAutoPredictorError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_auto_predictor_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeAutoPredictorOutput,
crate::error::DescribeAutoPredictorError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_auto_predictor_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_auto_predictor(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeAutoPredictorError::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_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_explainability_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeExplainabilityOutput,
crate::error::DescribeExplainabilityError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeExplainabilityError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeExplainabilityError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DescribeExplainabilityError {
meta: generic,
kind: crate::error::DescribeExplainabilityErrorKind::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::DescribeExplainabilityError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeExplainabilityError {
meta: generic,
kind: crate::error::DescribeExplainabilityErrorKind::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::DescribeExplainabilityError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeExplainabilityError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_explainability_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeExplainabilityOutput,
crate::error::DescribeExplainabilityError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_explainability_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_explainability(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeExplainabilityError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_explainability_export_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeExplainabilityExportOutput,
crate::error::DescribeExplainabilityExportError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeExplainabilityExportError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeExplainabilityExportError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DescribeExplainabilityExportError {
meta: generic,
kind: crate::error::DescribeExplainabilityExportErrorKind::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::DescribeExplainabilityExportError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeExplainabilityExportError {
meta: generic,
kind: crate::error::DescribeExplainabilityExportErrorKind::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::DescribeExplainabilityExportError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeExplainabilityExportError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_explainability_export_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeExplainabilityExportOutput,
crate::error::DescribeExplainabilityExportError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_explainability_export_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_explainability_export(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeExplainabilityExportError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_forecast_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeForecastOutput, crate::error::DescribeForecastError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeForecastError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeForecastError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DescribeForecastError {
meta: generic,
kind: crate::error::DescribeForecastErrorKind::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::DescribeForecastError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeForecastError {
meta: generic,
kind: crate::error::DescribeForecastErrorKind::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::DescribeForecastError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeForecastError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_forecast_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeForecastOutput, crate::error::DescribeForecastError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_forecast_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_forecast(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeForecastError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_forecast_export_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeForecastExportJobOutput,
crate::error::DescribeForecastExportJobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeForecastExportJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeForecastExportJobError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DescribeForecastExportJobError {
meta: generic,
kind: crate::error::DescribeForecastExportJobErrorKind::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::DescribeForecastExportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeForecastExportJobError {
meta: generic,
kind: crate::error::DescribeForecastExportJobErrorKind::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::DescribeForecastExportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeForecastExportJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_forecast_export_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeForecastExportJobOutput,
crate::error::DescribeForecastExportJobError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_forecast_export_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_forecast_export_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeForecastExportJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_monitor_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeMonitorOutput, crate::error::DescribeMonitorError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeMonitorError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeMonitorError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DescribeMonitorError {
meta: generic,
kind: crate::error::DescribeMonitorErrorKind::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::DescribeMonitorError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeMonitorError {
meta: generic,
kind: crate::error::DescribeMonitorErrorKind::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::DescribeMonitorError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeMonitorError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_monitor_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeMonitorOutput, crate::error::DescribeMonitorError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_monitor_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_monitor(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeMonitorError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_predictor_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribePredictorOutput, crate::error::DescribePredictorError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribePredictorError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribePredictorError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DescribePredictorError {
meta: generic,
kind: crate::error::DescribePredictorErrorKind::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::DescribePredictorError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribePredictorError {
meta: generic,
kind: crate::error::DescribePredictorErrorKind::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::DescribePredictorError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribePredictorError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_predictor_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribePredictorOutput, crate::error::DescribePredictorError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_predictor_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_predictor(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribePredictorError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_predictor_backtest_export_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribePredictorBacktestExportJobOutput,
crate::error::DescribePredictorBacktestExportJobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribePredictorBacktestExportJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribePredictorBacktestExportJobError::unhandled(generic))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DescribePredictorBacktestExportJobError {
meta: generic,
kind: crate::error::DescribePredictorBacktestExportJobErrorKind::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::DescribePredictorBacktestExportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ResourceNotFoundException" => crate::error::DescribePredictorBacktestExportJobError {
meta: generic,
kind:
crate::error::DescribePredictorBacktestExportJobErrorKind::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::DescribePredictorBacktestExportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
_ => crate::error::DescribePredictorBacktestExportJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_predictor_backtest_export_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribePredictorBacktestExportJobOutput,
crate::error::DescribePredictorBacktestExportJobError,
> {
Ok({
#[allow(unused_mut)]
let mut output =
crate::output::describe_predictor_backtest_export_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_predictor_backtest_export_job(response.body().as_ref(), output).map_err(crate::error::DescribePredictorBacktestExportJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_what_if_analysis_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeWhatIfAnalysisOutput,
crate::error::DescribeWhatIfAnalysisError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeWhatIfAnalysisError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeWhatIfAnalysisError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DescribeWhatIfAnalysisError {
meta: generic,
kind: crate::error::DescribeWhatIfAnalysisErrorKind::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::DescribeWhatIfAnalysisError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeWhatIfAnalysisError {
meta: generic,
kind: crate::error::DescribeWhatIfAnalysisErrorKind::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::DescribeWhatIfAnalysisError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeWhatIfAnalysisError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_what_if_analysis_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeWhatIfAnalysisOutput,
crate::error::DescribeWhatIfAnalysisError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_what_if_analysis_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_what_if_analysis(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeWhatIfAnalysisError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_what_if_forecast_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeWhatIfForecastOutput,
crate::error::DescribeWhatIfForecastError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeWhatIfForecastError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeWhatIfForecastError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DescribeWhatIfForecastError {
meta: generic,
kind: crate::error::DescribeWhatIfForecastErrorKind::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::DescribeWhatIfForecastError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeWhatIfForecastError {
meta: generic,
kind: crate::error::DescribeWhatIfForecastErrorKind::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::DescribeWhatIfForecastError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeWhatIfForecastError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_what_if_forecast_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeWhatIfForecastOutput,
crate::error::DescribeWhatIfForecastError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_what_if_forecast_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_what_if_forecast(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeWhatIfForecastError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_what_if_forecast_export_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeWhatIfForecastExportOutput,
crate::error::DescribeWhatIfForecastExportError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeWhatIfForecastExportError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeWhatIfForecastExportError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::DescribeWhatIfForecastExportError {
meta: generic,
kind: crate::error::DescribeWhatIfForecastExportErrorKind::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::DescribeWhatIfForecastExportError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeWhatIfForecastExportError {
meta: generic,
kind: crate::error::DescribeWhatIfForecastExportErrorKind::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::DescribeWhatIfForecastExportError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeWhatIfForecastExportError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_what_if_forecast_export_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeWhatIfForecastExportOutput,
crate::error::DescribeWhatIfForecastExportError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_what_if_forecast_export_output::Builder::default();
let _ = response;
output =
crate::json_deser::deser_operation_crate_operation_describe_what_if_forecast_export(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeWhatIfForecastExportError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_accuracy_metrics_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetAccuracyMetricsOutput,
crate::error::GetAccuracyMetricsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetAccuracyMetricsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::GetAccuracyMetricsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::GetAccuracyMetricsError {
meta: generic,
kind: crate::error::GetAccuracyMetricsErrorKind::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::GetAccuracyMetricsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::GetAccuracyMetricsError {
meta: generic,
kind: crate::error::GetAccuracyMetricsErrorKind::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::GetAccuracyMetricsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::GetAccuracyMetricsError {
meta: generic,
kind: crate::error::GetAccuracyMetricsErrorKind::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::GetAccuracyMetricsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetAccuracyMetricsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_accuracy_metrics_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetAccuracyMetricsOutput,
crate::error::GetAccuracyMetricsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_accuracy_metrics_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_accuracy_metrics(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetAccuracyMetricsError::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 {
"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_explainabilities_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListExplainabilitiesOutput,
crate::error::ListExplainabilitiesError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListExplainabilitiesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListExplainabilitiesError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::ListExplainabilitiesError {
meta: generic,
kind: crate::error::ListExplainabilitiesErrorKind::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::ListExplainabilitiesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListExplainabilitiesError {
meta: generic,
kind: crate::error::ListExplainabilitiesErrorKind::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::ListExplainabilitiesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListExplainabilitiesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_explainabilities_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListExplainabilitiesOutput,
crate::error::ListExplainabilitiesError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_explainabilities_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_explainabilities(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListExplainabilitiesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_explainability_exports_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListExplainabilityExportsOutput,
crate::error::ListExplainabilityExportsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListExplainabilityExportsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListExplainabilityExportsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::ListExplainabilityExportsError {
meta: generic,
kind: crate::error::ListExplainabilityExportsErrorKind::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::ListExplainabilityExportsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListExplainabilityExportsError {
meta: generic,
kind: crate::error::ListExplainabilityExportsErrorKind::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::ListExplainabilityExportsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListExplainabilityExportsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_explainability_exports_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListExplainabilityExportsOutput,
crate::error::ListExplainabilityExportsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_explainability_exports_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_explainability_exports(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListExplainabilityExportsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_forecast_export_jobs_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListForecastExportJobsOutput,
crate::error::ListForecastExportJobsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListForecastExportJobsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListForecastExportJobsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::ListForecastExportJobsError {
meta: generic,
kind: crate::error::ListForecastExportJobsErrorKind::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::ListForecastExportJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListForecastExportJobsError {
meta: generic,
kind: crate::error::ListForecastExportJobsErrorKind::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::ListForecastExportJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListForecastExportJobsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_forecast_export_jobs_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListForecastExportJobsOutput,
crate::error::ListForecastExportJobsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_forecast_export_jobs_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_forecast_export_jobs(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListForecastExportJobsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_forecasts_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListForecastsOutput, crate::error::ListForecastsError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListForecastsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListForecastsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::ListForecastsError {
meta: generic,
kind: crate::error::ListForecastsErrorKind::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::ListForecastsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListForecastsError {
meta: generic,
kind: crate::error::ListForecastsErrorKind::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::ListForecastsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListForecastsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_forecasts_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListForecastsOutput, crate::error::ListForecastsError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_forecasts_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_forecasts(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListForecastsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_monitor_evaluations_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListMonitorEvaluationsOutput,
crate::error::ListMonitorEvaluationsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListMonitorEvaluationsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListMonitorEvaluationsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::ListMonitorEvaluationsError {
meta: generic,
kind: crate::error::ListMonitorEvaluationsErrorKind::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::ListMonitorEvaluationsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListMonitorEvaluationsError {
meta: generic,
kind: crate::error::ListMonitorEvaluationsErrorKind::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::ListMonitorEvaluationsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListMonitorEvaluationsError {
meta: generic,
kind: crate::error::ListMonitorEvaluationsErrorKind::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::ListMonitorEvaluationsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListMonitorEvaluationsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_monitor_evaluations_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListMonitorEvaluationsOutput,
crate::error::ListMonitorEvaluationsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_monitor_evaluations_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_monitor_evaluations(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListMonitorEvaluationsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_monitors_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListMonitorsOutput, crate::error::ListMonitorsError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListMonitorsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListMonitorsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::ListMonitorsError {
meta: generic,
kind: crate::error::ListMonitorsErrorKind::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::ListMonitorsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListMonitorsError {
meta: generic,
kind: crate::error::ListMonitorsErrorKind::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::ListMonitorsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListMonitorsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_monitors_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListMonitorsOutput, crate::error::ListMonitorsError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_monitors_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_monitors(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListMonitorsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_predictor_backtest_export_jobs_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListPredictorBacktestExportJobsOutput,
crate::error::ListPredictorBacktestExportJobsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListPredictorBacktestExportJobsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListPredictorBacktestExportJobsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::ListPredictorBacktestExportJobsError {
meta: generic,
kind: crate::error::ListPredictorBacktestExportJobsErrorKind::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::ListPredictorBacktestExportJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListPredictorBacktestExportJobsError {
meta: generic,
kind: crate::error::ListPredictorBacktestExportJobsErrorKind::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::ListPredictorBacktestExportJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
_ => crate::error::ListPredictorBacktestExportJobsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_predictor_backtest_export_jobs_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListPredictorBacktestExportJobsOutput,
crate::error::ListPredictorBacktestExportJobsError,
> {
Ok({
#[allow(unused_mut)]
let mut output =
crate::output::list_predictor_backtest_export_jobs_output::Builder::default();
let _ = response;
output =
crate::json_deser::deser_operation_crate_operation_list_predictor_backtest_export_jobs(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListPredictorBacktestExportJobsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_predictors_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListPredictorsOutput, crate::error::ListPredictorsError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListPredictorsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListPredictorsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::ListPredictorsError {
meta: generic,
kind: crate::error::ListPredictorsErrorKind::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::ListPredictorsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListPredictorsError {
meta: generic,
kind: crate::error::ListPredictorsErrorKind::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::ListPredictorsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListPredictorsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_predictors_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListPredictorsOutput, crate::error::ListPredictorsError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_predictors_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_predictors(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListPredictorsError::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
}),
},
"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_list_what_if_analyses_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListWhatIfAnalysesOutput,
crate::error::ListWhatIfAnalysesError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListWhatIfAnalysesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListWhatIfAnalysesError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::ListWhatIfAnalysesError {
meta: generic,
kind: crate::error::ListWhatIfAnalysesErrorKind::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::ListWhatIfAnalysesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListWhatIfAnalysesError {
meta: generic,
kind: crate::error::ListWhatIfAnalysesErrorKind::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::ListWhatIfAnalysesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListWhatIfAnalysesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_what_if_analyses_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListWhatIfAnalysesOutput,
crate::error::ListWhatIfAnalysesError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_what_if_analyses_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_what_if_analyses(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListWhatIfAnalysesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_what_if_forecast_exports_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListWhatIfForecastExportsOutput,
crate::error::ListWhatIfForecastExportsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListWhatIfForecastExportsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListWhatIfForecastExportsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::ListWhatIfForecastExportsError {
meta: generic,
kind: crate::error::ListWhatIfForecastExportsErrorKind::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::ListWhatIfForecastExportsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListWhatIfForecastExportsError {
meta: generic,
kind: crate::error::ListWhatIfForecastExportsErrorKind::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::ListWhatIfForecastExportsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListWhatIfForecastExportsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_what_if_forecast_exports_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListWhatIfForecastExportsOutput,
crate::error::ListWhatIfForecastExportsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_what_if_forecast_exports_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_what_if_forecast_exports(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListWhatIfForecastExportsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_what_if_forecasts_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListWhatIfForecastsOutput,
crate::error::ListWhatIfForecastsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListWhatIfForecastsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListWhatIfForecastsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::ListWhatIfForecastsError {
meta: generic,
kind: crate::error::ListWhatIfForecastsErrorKind::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::ListWhatIfForecastsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidNextTokenException" => crate::error::ListWhatIfForecastsError {
meta: generic,
kind: crate::error::ListWhatIfForecastsErrorKind::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::ListWhatIfForecastsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListWhatIfForecastsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_what_if_forecasts_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListWhatIfForecastsOutput,
crate::error::ListWhatIfForecastsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_what_if_forecasts_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_what_if_forecasts(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListWhatIfForecastsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_resume_resource_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ResumeResourceOutput, crate::error::ResumeResourceError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ResumeResourceError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ResumeResourceError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::ResumeResourceError {
meta: generic,
kind: crate::error::ResumeResourceErrorKind::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::ResumeResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::ResumeResourceError {
meta: generic,
kind: crate::error::ResumeResourceErrorKind::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::ResumeResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::ResumeResourceError {
meta: generic,
kind: crate::error::ResumeResourceErrorKind::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::ResumeResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ResumeResourceError {
meta: generic,
kind: crate::error::ResumeResourceErrorKind::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::ResumeResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ResumeResourceError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_resume_resource_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ResumeResourceOutput, crate::error::ResumeResourceError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::resume_resource_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_resource_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StopResourceOutput, crate::error::StopResourceError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StopResourceError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::StopResourceError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::StopResourceError {
meta: generic,
kind: crate::error::StopResourceErrorKind::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::StopResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::StopResourceError {
meta: generic,
kind: crate::error::StopResourceErrorKind::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::StopResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::StopResourceError {
meta: generic,
kind: crate::error::StopResourceErrorKind::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::StopResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::StopResourceError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_resource_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StopResourceOutput, crate::error::StopResourceError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::stop_resource_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
}),
},
"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
}),
},
_ => 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
}),
},
"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
}),
},
_ => 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_dataset_group_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateDatasetGroupOutput,
crate::error::UpdateDatasetGroupError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateDatasetGroupError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UpdateDatasetGroupError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidInputException" => crate::error::UpdateDatasetGroupError {
meta: generic,
kind: crate::error::UpdateDatasetGroupErrorKind::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::UpdateDatasetGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::UpdateDatasetGroupError {
meta: generic,
kind: crate::error::UpdateDatasetGroupErrorKind::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::UpdateDatasetGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpdateDatasetGroupError {
meta: generic,
kind: crate::error::UpdateDatasetGroupErrorKind::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::UpdateDatasetGroupError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateDatasetGroupError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_dataset_group_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateDatasetGroupOutput,
crate::error::UpdateDatasetGroupError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_dataset_group_output::Builder::default();
let _ = response;
output.build()
})
}