aws-sdk-codedeploy 0.0.22-alpha

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
#[allow(clippy::unnecessary_wraps)]
pub fn parse_add_tags_to_on_premises_instances_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::AddTagsToOnPremisesInstancesOutput,
    crate::error::AddTagsToOnPremisesInstancesError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::AddTagsToOnPremisesInstancesError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => {
            return Err(crate::error::AddTagsToOnPremisesInstancesError::unhandled(
                generic,
            ))
        }
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "InstanceLimitExceededException" => crate::error::AddTagsToOnPremisesInstancesError {
            meta: generic,
            kind:
                crate::error::AddTagsToOnPremisesInstancesErrorKind::InstanceLimitExceededException(
                    {
                        #[allow(unused_mut)]
                        let mut tmp = {
                            #[allow(unused_mut)]
                            let mut output =
                                crate::error::instance_limit_exceeded_exception::Builder::default();
                            let _ = response;
                            output = crate::json_deser::deser_structure_crate_error_instance_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AddTagsToOnPremisesInstancesError::unhandled)?;
                            output.build()
                        };
                        if (&tmp.message).is_none() {
                            tmp.message = _error_message;
                        }
                        tmp
                    },
                ),
        },
        "InstanceNameRequiredException" => crate::error::AddTagsToOnPremisesInstancesError {
            meta: generic,
            kind:
                crate::error::AddTagsToOnPremisesInstancesErrorKind::InstanceNameRequiredException(
                    {
                        #[allow(unused_mut)]
                        let mut tmp = {
                            #[allow(unused_mut)]
                            let mut output =
                                crate::error::instance_name_required_exception::Builder::default();
                            let _ = response;
                            output = crate::json_deser::deser_structure_crate_error_instance_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AddTagsToOnPremisesInstancesError::unhandled)?;
                            output.build()
                        };
                        if (&tmp.message).is_none() {
                            tmp.message = _error_message;
                        }
                        tmp
                    },
                ),
        },
        "InstanceNotRegisteredException" => crate::error::AddTagsToOnPremisesInstancesError {
            meta: generic,
            kind:
                crate::error::AddTagsToOnPremisesInstancesErrorKind::InstanceNotRegisteredException(
                    {
                        #[allow(unused_mut)]
                        let mut tmp = {
                            #[allow(unused_mut)]
                            let mut output =
                                crate::error::instance_not_registered_exception::Builder::default();
                            let _ = response;
                            output = crate::json_deser::deser_structure_crate_error_instance_not_registered_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AddTagsToOnPremisesInstancesError::unhandled)?;
                            output.build()
                        };
                        if (&tmp.message).is_none() {
                            tmp.message = _error_message;
                        }
                        tmp
                    },
                ),
        },
        "InvalidInstanceNameException" => crate::error::AddTagsToOnPremisesInstancesError {
            meta: generic,
            kind: crate::error::AddTagsToOnPremisesInstancesErrorKind::InvalidInstanceNameException(
                {
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]
                        let mut output =
                            crate::error::invalid_instance_name_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_invalid_instance_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AddTagsToOnPremisesInstancesError::unhandled)?;
                        output.build()
                    };
                    if (&tmp.message).is_none() {
                        tmp.message = _error_message;
                    }
                    tmp
                },
            ),
        },
        "InvalidTagException" => crate::error::AddTagsToOnPremisesInstancesError {
            meta: generic,
            kind: crate::error::AddTagsToOnPremisesInstancesErrorKind::InvalidTagException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output = crate::error::invalid_tag_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_tag_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AddTagsToOnPremisesInstancesError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "TagLimitExceededException" => crate::error::AddTagsToOnPremisesInstancesError {
            meta: generic,
            kind: crate::error::AddTagsToOnPremisesInstancesErrorKind::TagLimitExceededException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output = crate::error::tag_limit_exceeded_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_tag_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AddTagsToOnPremisesInstancesError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "TagRequiredException" => crate::error::AddTagsToOnPremisesInstancesError {
            meta: generic,
            kind: crate::error::AddTagsToOnPremisesInstancesErrorKind::TagRequiredException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output = crate::error::tag_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_tag_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AddTagsToOnPremisesInstancesError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        _ => crate::error::AddTagsToOnPremisesInstancesError::generic(generic),
    })
}

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

#[allow(clippy::unnecessary_wraps)]
pub fn parse_batch_get_application_revisions_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::BatchGetApplicationRevisionsOutput,
    crate::error::BatchGetApplicationRevisionsError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::BatchGetApplicationRevisionsError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => {
            return Err(crate::error::BatchGetApplicationRevisionsError::unhandled(
                generic,
            ))
        }
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "ApplicationDoesNotExistException" => crate::error::BatchGetApplicationRevisionsError { meta: generic, kind: crate::error::BatchGetApplicationRevisionsErrorKind::ApplicationDoesNotExistException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::application_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetApplicationRevisionsError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "ApplicationNameRequiredException" => crate::error::BatchGetApplicationRevisionsError { meta: generic, kind: crate::error::BatchGetApplicationRevisionsErrorKind::ApplicationNameRequiredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::application_name_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetApplicationRevisionsError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "BatchLimitExceededException" => crate::error::BatchGetApplicationRevisionsError { meta: generic, kind: crate::error::BatchGetApplicationRevisionsErrorKind::BatchLimitExceededException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::batch_limit_exceeded_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_batch_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetApplicationRevisionsError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidApplicationNameException" => crate::error::BatchGetApplicationRevisionsError { meta: generic, kind: crate::error::BatchGetApplicationRevisionsErrorKind::InvalidApplicationNameException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_application_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_application_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetApplicationRevisionsError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidRevisionException" => crate::error::BatchGetApplicationRevisionsError { meta: generic, kind: crate::error::BatchGetApplicationRevisionsErrorKind::InvalidRevisionException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_revision_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_revision_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetApplicationRevisionsError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "RevisionRequiredException" => crate::error::BatchGetApplicationRevisionsError { meta: generic, kind: crate::error::BatchGetApplicationRevisionsErrorKind::RevisionRequiredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::revision_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_revision_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetApplicationRevisionsError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        _ => crate::error::BatchGetApplicationRevisionsError::generic(generic)
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_batch_get_application_revisions_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::BatchGetApplicationRevisionsOutput,
    crate::error::BatchGetApplicationRevisionsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::batch_get_application_revisions_output::Builder::default();
        let _ = response;
        output =
            crate::json_deser::deser_operation_crate_operation_batch_get_application_revisions(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::BatchGetApplicationRevisionsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_batch_get_applications_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::BatchGetApplicationsOutput,
    crate::error::BatchGetApplicationsError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::BatchGetApplicationsError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => return Err(crate::error::BatchGetApplicationsError::unhandled(generic)),
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "ApplicationDoesNotExistException" => crate::error::BatchGetApplicationsError {
            meta: generic,
            kind: crate::error::BatchGetApplicationsErrorKind::ApplicationDoesNotExistException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::application_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetApplicationsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "ApplicationNameRequiredException" => crate::error::BatchGetApplicationsError {
            meta: generic,
            kind: crate::error::BatchGetApplicationsErrorKind::ApplicationNameRequiredException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::application_name_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetApplicationsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "BatchLimitExceededException" => crate::error::BatchGetApplicationsError {
            meta: generic,
            kind: crate::error::BatchGetApplicationsErrorKind::BatchLimitExceededException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::batch_limit_exceeded_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_batch_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetApplicationsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidApplicationNameException" => crate::error::BatchGetApplicationsError {
            meta: generic,
            kind: crate::error::BatchGetApplicationsErrorKind::InvalidApplicationNameException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_application_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_application_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetApplicationsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        _ => crate::error::BatchGetApplicationsError::generic(generic),
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_batch_get_applications_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::BatchGetApplicationsOutput,
    crate::error::BatchGetApplicationsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::batch_get_applications_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_batch_get_applications(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::BatchGetApplicationsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_batch_get_deployment_groups_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::BatchGetDeploymentGroupsOutput,
    crate::error::BatchGetDeploymentGroupsError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::BatchGetDeploymentGroupsError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => {
            return Err(crate::error::BatchGetDeploymentGroupsError::unhandled(
                generic,
            ))
        }
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "ApplicationDoesNotExistException" => crate::error::BatchGetDeploymentGroupsError { meta: generic, kind: crate::error::BatchGetDeploymentGroupsErrorKind::ApplicationDoesNotExistException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::application_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetDeploymentGroupsError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "ApplicationNameRequiredException" => crate::error::BatchGetDeploymentGroupsError { meta: generic, kind: crate::error::BatchGetDeploymentGroupsErrorKind::ApplicationNameRequiredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::application_name_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetDeploymentGroupsError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "BatchLimitExceededException" => crate::error::BatchGetDeploymentGroupsError { meta: generic, kind: crate::error::BatchGetDeploymentGroupsErrorKind::BatchLimitExceededException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::batch_limit_exceeded_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_batch_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetDeploymentGroupsError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentConfigDoesNotExistException" => crate::error::BatchGetDeploymentGroupsError { meta: generic, kind: crate::error::BatchGetDeploymentGroupsErrorKind::DeploymentConfigDoesNotExistException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_config_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_config_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetDeploymentGroupsError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentGroupNameRequiredException" => crate::error::BatchGetDeploymentGroupsError { meta: generic, kind: crate::error::BatchGetDeploymentGroupsErrorKind::DeploymentGroupNameRequiredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_group_name_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_group_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetDeploymentGroupsError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidApplicationNameException" => crate::error::BatchGetDeploymentGroupsError { meta: generic, kind: crate::error::BatchGetDeploymentGroupsErrorKind::InvalidApplicationNameException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_application_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_application_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetDeploymentGroupsError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidDeploymentGroupNameException" => crate::error::BatchGetDeploymentGroupsError { meta: generic, kind: crate::error::BatchGetDeploymentGroupsErrorKind::InvalidDeploymentGroupNameException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_deployment_group_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_group_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetDeploymentGroupsError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        _ => crate::error::BatchGetDeploymentGroupsError::generic(generic)
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_batch_get_deployment_groups_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::BatchGetDeploymentGroupsOutput,
    crate::error::BatchGetDeploymentGroupsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::batch_get_deployment_groups_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_batch_get_deployment_groups(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::BatchGetDeploymentGroupsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_batch_get_deployment_instances_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::BatchGetDeploymentInstancesOutput,
    crate::error::BatchGetDeploymentInstancesError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::BatchGetDeploymentInstancesError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => {
            return Err(crate::error::BatchGetDeploymentInstancesError::unhandled(
                generic,
            ))
        }
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "BatchLimitExceededException" => crate::error::BatchGetDeploymentInstancesError {
            meta: generic,
            kind: crate::error::BatchGetDeploymentInstancesErrorKind::BatchLimitExceededException(
                {
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]
                        let mut output =
                            crate::error::batch_limit_exceeded_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_batch_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetDeploymentInstancesError::unhandled)?;
                        output.build()
                    };
                    if (&tmp.message).is_none() {
                        tmp.message = _error_message;
                    }
                    tmp
                },
            ),
        },
        "DeploymentDoesNotExistException" => crate::error::BatchGetDeploymentInstancesError {
            meta: generic,
            kind:
                crate::error::BatchGetDeploymentInstancesErrorKind::DeploymentDoesNotExistException(
                    {
                        #[allow(unused_mut)]
                        let mut tmp = {
                            #[allow(unused_mut)]
                            let mut output =
                                crate::error::deployment_does_not_exist_exception::Builder::default(
                                );
                            let _ = response;
                            output = crate::json_deser::deser_structure_crate_error_deployment_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetDeploymentInstancesError::unhandled)?;
                            output.build()
                        };
                        if (&tmp.message).is_none() {
                            tmp.message = _error_message;
                        }
                        tmp
                    },
                ),
        },
        "DeploymentIdRequiredException" => crate::error::BatchGetDeploymentInstancesError {
            meta: generic,
            kind: crate::error::BatchGetDeploymentInstancesErrorKind::DeploymentIdRequiredException(
                {
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]
                        let mut output =
                            crate::error::deployment_id_required_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_deployment_id_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetDeploymentInstancesError::unhandled)?;
                        output.build()
                    };
                    if (&tmp.message).is_none() {
                        tmp.message = _error_message;
                    }
                    tmp
                },
            ),
        },
        "InstanceIdRequiredException" => crate::error::BatchGetDeploymentInstancesError {
            meta: generic,
            kind: crate::error::BatchGetDeploymentInstancesErrorKind::InstanceIdRequiredException(
                {
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]
                        let mut output =
                            crate::error::instance_id_required_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_instance_id_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetDeploymentInstancesError::unhandled)?;
                        output.build()
                    };
                    if (&tmp.message).is_none() {
                        tmp.message = _error_message;
                    }
                    tmp
                },
            ),
        },
        "InvalidComputePlatformException" => crate::error::BatchGetDeploymentInstancesError {
            meta: generic,
            kind:
                crate::error::BatchGetDeploymentInstancesErrorKind::InvalidComputePlatformException(
                    {
                        #[allow(unused_mut)]
                        let mut tmp = {
                            #[allow(unused_mut)]
                            let mut output =
                                crate::error::invalid_compute_platform_exception::Builder::default(
                                );
                            let _ = response;
                            output = crate::json_deser::deser_structure_crate_error_invalid_compute_platform_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetDeploymentInstancesError::unhandled)?;
                            output.build()
                        };
                        if (&tmp.message).is_none() {
                            tmp.message = _error_message;
                        }
                        tmp
                    },
                ),
        },
        "InvalidDeploymentIdException" => crate::error::BatchGetDeploymentInstancesError {
            meta: generic,
            kind: crate::error::BatchGetDeploymentInstancesErrorKind::InvalidDeploymentIdException(
                {
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]
                        let mut output =
                            crate::error::invalid_deployment_id_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_invalid_deployment_id_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetDeploymentInstancesError::unhandled)?;
                        output.build()
                    };
                    if (&tmp.message).is_none() {
                        tmp.message = _error_message;
                    }
                    tmp
                },
            ),
        },
        "InvalidInstanceNameException" => crate::error::BatchGetDeploymentInstancesError {
            meta: generic,
            kind: crate::error::BatchGetDeploymentInstancesErrorKind::InvalidInstanceNameException(
                {
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]
                        let mut output =
                            crate::error::invalid_instance_name_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_invalid_instance_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetDeploymentInstancesError::unhandled)?;
                        output.build()
                    };
                    if (&tmp.message).is_none() {
                        tmp.message = _error_message;
                    }
                    tmp
                },
            ),
        },
        _ => crate::error::BatchGetDeploymentInstancesError::generic(generic),
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_batch_get_deployment_instances_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::BatchGetDeploymentInstancesOutput,
    crate::error::BatchGetDeploymentInstancesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::batch_get_deployment_instances_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_batch_get_deployment_instances(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::BatchGetDeploymentInstancesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_batch_get_deployments_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::BatchGetDeploymentsOutput,
    crate::error::BatchGetDeploymentsError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::BatchGetDeploymentsError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => return Err(crate::error::BatchGetDeploymentsError::unhandled(generic)),
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "BatchLimitExceededException" => crate::error::BatchGetDeploymentsError {
            meta: generic,
            kind: crate::error::BatchGetDeploymentsErrorKind::BatchLimitExceededException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::batch_limit_exceeded_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_batch_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetDeploymentsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "DeploymentIdRequiredException" => crate::error::BatchGetDeploymentsError {
            meta: generic,
            kind: crate::error::BatchGetDeploymentsErrorKind::DeploymentIdRequiredException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::deployment_id_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_id_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetDeploymentsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidDeploymentIdException" => crate::error::BatchGetDeploymentsError {
            meta: generic,
            kind: crate::error::BatchGetDeploymentsErrorKind::InvalidDeploymentIdException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_deployment_id_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_id_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetDeploymentsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        _ => crate::error::BatchGetDeploymentsError::generic(generic),
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_batch_get_deployments_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::BatchGetDeploymentsOutput,
    crate::error::BatchGetDeploymentsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::batch_get_deployments_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_batch_get_deployments(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::BatchGetDeploymentsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_batch_get_deployment_targets_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::BatchGetDeploymentTargetsOutput,
    crate::error::BatchGetDeploymentTargetsError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::BatchGetDeploymentTargetsError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => {
            return Err(crate::error::BatchGetDeploymentTargetsError::unhandled(
                generic,
            ))
        }
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "DeploymentDoesNotExistException" => crate::error::BatchGetDeploymentTargetsError { meta: generic, kind: crate::error::BatchGetDeploymentTargetsErrorKind::DeploymentDoesNotExistException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetDeploymentTargetsError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentIdRequiredException" => crate::error::BatchGetDeploymentTargetsError { meta: generic, kind: crate::error::BatchGetDeploymentTargetsErrorKind::DeploymentIdRequiredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_id_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_id_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetDeploymentTargetsError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentNotStartedException" => crate::error::BatchGetDeploymentTargetsError { meta: generic, kind: crate::error::BatchGetDeploymentTargetsErrorKind::DeploymentNotStartedException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_not_started_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_not_started_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetDeploymentTargetsError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentTargetDoesNotExistException" => crate::error::BatchGetDeploymentTargetsError { meta: generic, kind: crate::error::BatchGetDeploymentTargetsErrorKind::DeploymentTargetDoesNotExistException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_target_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_target_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetDeploymentTargetsError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentTargetIdRequiredException" => crate::error::BatchGetDeploymentTargetsError { meta: generic, kind: crate::error::BatchGetDeploymentTargetsErrorKind::DeploymentTargetIdRequiredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_target_id_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_target_id_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetDeploymentTargetsError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentTargetListSizeExceededException" => crate::error::BatchGetDeploymentTargetsError { meta: generic, kind: crate::error::BatchGetDeploymentTargetsErrorKind::DeploymentTargetListSizeExceededException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_target_list_size_exceeded_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_target_list_size_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetDeploymentTargetsError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InstanceDoesNotExistException" => crate::error::BatchGetDeploymentTargetsError { meta: generic, kind: crate::error::BatchGetDeploymentTargetsErrorKind::InstanceDoesNotExistException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::instance_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_instance_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetDeploymentTargetsError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidDeploymentIdException" => crate::error::BatchGetDeploymentTargetsError { meta: generic, kind: crate::error::BatchGetDeploymentTargetsErrorKind::InvalidDeploymentIdException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_deployment_id_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_id_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetDeploymentTargetsError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidDeploymentTargetIdException" => crate::error::BatchGetDeploymentTargetsError { meta: generic, kind: crate::error::BatchGetDeploymentTargetsErrorKind::InvalidDeploymentTargetIdException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_deployment_target_id_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_target_id_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetDeploymentTargetsError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        _ => crate::error::BatchGetDeploymentTargetsError::generic(generic)
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_batch_get_deployment_targets_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::BatchGetDeploymentTargetsOutput,
    crate::error::BatchGetDeploymentTargetsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::batch_get_deployment_targets_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_batch_get_deployment_targets(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::BatchGetDeploymentTargetsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_batch_get_on_premises_instances_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::BatchGetOnPremisesInstancesOutput,
    crate::error::BatchGetOnPremisesInstancesError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::BatchGetOnPremisesInstancesError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => {
            return Err(crate::error::BatchGetOnPremisesInstancesError::unhandled(
                generic,
            ))
        }
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "BatchLimitExceededException" => crate::error::BatchGetOnPremisesInstancesError {
            meta: generic,
            kind: crate::error::BatchGetOnPremisesInstancesErrorKind::BatchLimitExceededException(
                {
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]
                        let mut output =
                            crate::error::batch_limit_exceeded_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_batch_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetOnPremisesInstancesError::unhandled)?;
                        output.build()
                    };
                    if (&tmp.message).is_none() {
                        tmp.message = _error_message;
                    }
                    tmp
                },
            ),
        },
        "InstanceNameRequiredException" => crate::error::BatchGetOnPremisesInstancesError {
            meta: generic,
            kind: crate::error::BatchGetOnPremisesInstancesErrorKind::InstanceNameRequiredException(
                {
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]
                        let mut output =
                            crate::error::instance_name_required_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_instance_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetOnPremisesInstancesError::unhandled)?;
                        output.build()
                    };
                    if (&tmp.message).is_none() {
                        tmp.message = _error_message;
                    }
                    tmp
                },
            ),
        },
        "InvalidInstanceNameException" => crate::error::BatchGetOnPremisesInstancesError {
            meta: generic,
            kind: crate::error::BatchGetOnPremisesInstancesErrorKind::InvalidInstanceNameException(
                {
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]
                        let mut output =
                            crate::error::invalid_instance_name_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_invalid_instance_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::BatchGetOnPremisesInstancesError::unhandled)?;
                        output.build()
                    };
                    if (&tmp.message).is_none() {
                        tmp.message = _error_message;
                    }
                    tmp
                },
            ),
        },
        _ => crate::error::BatchGetOnPremisesInstancesError::generic(generic),
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_batch_get_on_premises_instances_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::BatchGetOnPremisesInstancesOutput,
    crate::error::BatchGetOnPremisesInstancesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::batch_get_on_premises_instances_output::Builder::default();
        let _ = response;
        output =
            crate::json_deser::deser_operation_crate_operation_batch_get_on_premises_instances(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::BatchGetOnPremisesInstancesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_continue_deployment_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ContinueDeploymentOutput,
    crate::error::ContinueDeploymentError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::ContinueDeploymentError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => return Err(crate::error::ContinueDeploymentError::unhandled(generic)),
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "DeploymentAlreadyCompletedException" => crate::error::ContinueDeploymentError { meta: generic, kind: crate::error::ContinueDeploymentErrorKind::DeploymentAlreadyCompletedException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_already_completed_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_already_completed_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ContinueDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentDoesNotExistException" => crate::error::ContinueDeploymentError { meta: generic, kind: crate::error::ContinueDeploymentErrorKind::DeploymentDoesNotExistException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ContinueDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentIdRequiredException" => crate::error::ContinueDeploymentError { meta: generic, kind: crate::error::ContinueDeploymentErrorKind::DeploymentIdRequiredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_id_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_id_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ContinueDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentIsNotInReadyStateException" => crate::error::ContinueDeploymentError { meta: generic, kind: crate::error::ContinueDeploymentErrorKind::DeploymentIsNotInReadyStateException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_is_not_in_ready_state_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_is_not_in_ready_state_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ContinueDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidDeploymentIdException" => crate::error::ContinueDeploymentError { meta: generic, kind: crate::error::ContinueDeploymentErrorKind::InvalidDeploymentIdException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_deployment_id_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_id_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ContinueDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidDeploymentStatusException" => crate::error::ContinueDeploymentError { meta: generic, kind: crate::error::ContinueDeploymentErrorKind::InvalidDeploymentStatusException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_deployment_status_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_status_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ContinueDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidDeploymentWaitTypeException" => crate::error::ContinueDeploymentError { meta: generic, kind: crate::error::ContinueDeploymentErrorKind::InvalidDeploymentWaitTypeException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_deployment_wait_type_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_wait_type_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ContinueDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "UnsupportedActionForDeploymentTypeException" => crate::error::ContinueDeploymentError { meta: generic, kind: crate::error::ContinueDeploymentErrorKind::UnsupportedActionForDeploymentTypeException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::unsupported_action_for_deployment_type_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_unsupported_action_for_deployment_type_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ContinueDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        _ => crate::error::ContinueDeploymentError::generic(generic)
    })
}

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

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_application_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateApplicationOutput, crate::error::CreateApplicationError>
{
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateApplicationError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => return Err(crate::error::CreateApplicationError::unhandled(generic)),
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "ApplicationAlreadyExistsException" => crate::error::CreateApplicationError {
            meta: generic,
            kind: crate::error::CreateApplicationErrorKind::ApplicationAlreadyExistsException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::application_already_exists_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateApplicationError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "ApplicationLimitExceededException" => crate::error::CreateApplicationError {
            meta: generic,
            kind: crate::error::CreateApplicationErrorKind::ApplicationLimitExceededException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::application_limit_exceeded_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateApplicationError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "ApplicationNameRequiredException" => crate::error::CreateApplicationError {
            meta: generic,
            kind: crate::error::CreateApplicationErrorKind::ApplicationNameRequiredException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::application_name_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateApplicationError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidApplicationNameException" => crate::error::CreateApplicationError {
            meta: generic,
            kind: crate::error::CreateApplicationErrorKind::InvalidApplicationNameException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_application_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_application_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateApplicationError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidComputePlatformException" => crate::error::CreateApplicationError {
            meta: generic,
            kind: crate::error::CreateApplicationErrorKind::InvalidComputePlatformException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_compute_platform_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_compute_platform_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateApplicationError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidTagsToAddException" => crate::error::CreateApplicationError {
            meta: generic,
            kind: crate::error::CreateApplicationErrorKind::InvalidTagsToAddException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_tags_to_add_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_tags_to_add_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateApplicationError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        _ => crate::error::CreateApplicationError::generic(generic),
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_application_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateApplicationOutput, crate::error::CreateApplicationError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_application_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_create_application(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateApplicationError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_deployment_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateDeploymentOutput, crate::error::CreateDeploymentError>
{
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateDeploymentError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => return Err(crate::error::CreateDeploymentError::unhandled(generic)),
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "ApplicationDoesNotExistException" => crate::error::CreateDeploymentError { meta: generic, kind: crate::error::CreateDeploymentErrorKind::ApplicationDoesNotExistException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::application_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "ApplicationNameRequiredException" => crate::error::CreateDeploymentError { meta: generic, kind: crate::error::CreateDeploymentErrorKind::ApplicationNameRequiredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::application_name_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentConfigDoesNotExistException" => crate::error::CreateDeploymentError { meta: generic, kind: crate::error::CreateDeploymentErrorKind::DeploymentConfigDoesNotExistException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_config_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_config_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentGroupDoesNotExistException" => crate::error::CreateDeploymentError { meta: generic, kind: crate::error::CreateDeploymentErrorKind::DeploymentGroupDoesNotExistException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_group_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_group_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentGroupNameRequiredException" => crate::error::CreateDeploymentError { meta: generic, kind: crate::error::CreateDeploymentErrorKind::DeploymentGroupNameRequiredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_group_name_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_group_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentLimitExceededException" => crate::error::CreateDeploymentError { meta: generic, kind: crate::error::CreateDeploymentErrorKind::DeploymentLimitExceededException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_limit_exceeded_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DescriptionTooLongException" => crate::error::CreateDeploymentError { meta: generic, kind: crate::error::CreateDeploymentErrorKind::DescriptionTooLongException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::description_too_long_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_description_too_long_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidApplicationNameException" => crate::error::CreateDeploymentError { meta: generic, kind: crate::error::CreateDeploymentErrorKind::InvalidApplicationNameException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_application_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_application_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidAutoRollbackConfigException" => crate::error::CreateDeploymentError { meta: generic, kind: crate::error::CreateDeploymentErrorKind::InvalidAutoRollbackConfigException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_auto_rollback_config_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_auto_rollback_config_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidAutoScalingGroupException" => crate::error::CreateDeploymentError { meta: generic, kind: crate::error::CreateDeploymentErrorKind::InvalidAutoScalingGroupException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_auto_scaling_group_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_auto_scaling_group_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidDeploymentConfigNameException" => crate::error::CreateDeploymentError { meta: generic, kind: crate::error::CreateDeploymentErrorKind::InvalidDeploymentConfigNameException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_deployment_config_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_config_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidDeploymentGroupNameException" => crate::error::CreateDeploymentError { meta: generic, kind: crate::error::CreateDeploymentErrorKind::InvalidDeploymentGroupNameException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_deployment_group_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_group_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidFileExistsBehaviorException" => crate::error::CreateDeploymentError { meta: generic, kind: crate::error::CreateDeploymentErrorKind::InvalidFileExistsBehaviorException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_file_exists_behavior_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_file_exists_behavior_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidGitHubAccountTokenException" => crate::error::CreateDeploymentError { meta: generic, kind: crate::error::CreateDeploymentErrorKind::InvalidGitHubAccountTokenException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_git_hub_account_token_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_git_hub_account_token_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidIgnoreApplicationStopFailuresValueException" => crate::error::CreateDeploymentError { meta: generic, kind: crate::error::CreateDeploymentErrorKind::InvalidIgnoreApplicationStopFailuresValueException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_ignore_application_stop_failures_value_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_ignore_application_stop_failures_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidLoadBalancerInfoException" => crate::error::CreateDeploymentError { meta: generic, kind: crate::error::CreateDeploymentErrorKind::InvalidLoadBalancerInfoException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_load_balancer_info_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_load_balancer_info_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidRevisionException" => crate::error::CreateDeploymentError { meta: generic, kind: crate::error::CreateDeploymentErrorKind::InvalidRevisionException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_revision_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_revision_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidRoleException" => crate::error::CreateDeploymentError { meta: generic, kind: crate::error::CreateDeploymentErrorKind::InvalidRoleException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_role_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_role_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidTargetInstancesException" => crate::error::CreateDeploymentError { meta: generic, kind: crate::error::CreateDeploymentErrorKind::InvalidTargetInstancesException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_target_instances_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_target_instances_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidTrafficRoutingConfigurationException" => crate::error::CreateDeploymentError { meta: generic, kind: crate::error::CreateDeploymentErrorKind::InvalidTrafficRoutingConfigurationException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_traffic_routing_configuration_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_traffic_routing_configuration_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidUpdateOutdatedInstancesOnlyValueException" => crate::error::CreateDeploymentError { meta: generic, kind: crate::error::CreateDeploymentErrorKind::InvalidUpdateOutdatedInstancesOnlyValueException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_update_outdated_instances_only_value_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_update_outdated_instances_only_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "RevisionDoesNotExistException" => crate::error::CreateDeploymentError { meta: generic, kind: crate::error::CreateDeploymentErrorKind::RevisionDoesNotExistException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::revision_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_revision_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "RevisionRequiredException" => crate::error::CreateDeploymentError { meta: generic, kind: crate::error::CreateDeploymentErrorKind::RevisionRequiredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::revision_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_revision_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "ThrottlingException" => crate::error::CreateDeploymentError { meta: generic, kind: crate::error::CreateDeploymentErrorKind::ThrottlingException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::throttling_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_throttling_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        _ => crate::error::CreateDeploymentError::generic(generic)
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_deployment_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateDeploymentOutput, crate::error::CreateDeploymentError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_deployment_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_create_deployment(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateDeploymentError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_deployment_config_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateDeploymentConfigOutput,
    crate::error::CreateDeploymentConfigError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateDeploymentConfigError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => {
            return Err(crate::error::CreateDeploymentConfigError::unhandled(
                generic,
            ))
        }
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "DeploymentConfigAlreadyExistsException" => crate::error::CreateDeploymentConfigError { meta: generic, kind: crate::error::CreateDeploymentConfigErrorKind::DeploymentConfigAlreadyExistsException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_config_already_exists_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_config_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentConfigError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentConfigLimitExceededException" => crate::error::CreateDeploymentConfigError { meta: generic, kind: crate::error::CreateDeploymentConfigErrorKind::DeploymentConfigLimitExceededException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_config_limit_exceeded_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_config_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentConfigError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentConfigNameRequiredException" => crate::error::CreateDeploymentConfigError { meta: generic, kind: crate::error::CreateDeploymentConfigErrorKind::DeploymentConfigNameRequiredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_config_name_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_config_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentConfigError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidComputePlatformException" => crate::error::CreateDeploymentConfigError { meta: generic, kind: crate::error::CreateDeploymentConfigErrorKind::InvalidComputePlatformException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_compute_platform_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_compute_platform_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentConfigError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidDeploymentConfigNameException" => crate::error::CreateDeploymentConfigError { meta: generic, kind: crate::error::CreateDeploymentConfigErrorKind::InvalidDeploymentConfigNameException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_deployment_config_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_config_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentConfigError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidMinimumHealthyHostValueException" => crate::error::CreateDeploymentConfigError { meta: generic, kind: crate::error::CreateDeploymentConfigErrorKind::InvalidMinimumHealthyHostValueException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_minimum_healthy_host_value_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_minimum_healthy_host_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentConfigError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidTrafficRoutingConfigurationException" => crate::error::CreateDeploymentConfigError { meta: generic, kind: crate::error::CreateDeploymentConfigErrorKind::InvalidTrafficRoutingConfigurationException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_traffic_routing_configuration_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_traffic_routing_configuration_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentConfigError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        _ => crate::error::CreateDeploymentConfigError::generic(generic)
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_deployment_config_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateDeploymentConfigOutput,
    crate::error::CreateDeploymentConfigError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_deployment_config_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_create_deployment_config(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateDeploymentConfigError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_deployment_group_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateDeploymentGroupOutput,
    crate::error::CreateDeploymentGroupError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => return Err(crate::error::CreateDeploymentGroupError::unhandled(generic)),
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "AlarmsLimitExceededException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::AlarmsLimitExceededException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::alarms_limit_exceeded_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_alarms_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "ApplicationDoesNotExistException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::ApplicationDoesNotExistException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::application_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "ApplicationNameRequiredException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::ApplicationNameRequiredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::application_name_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentConfigDoesNotExistException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::DeploymentConfigDoesNotExistException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_config_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_config_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentGroupAlreadyExistsException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::DeploymentGroupAlreadyExistsException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_group_already_exists_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_group_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentGroupLimitExceededException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::DeploymentGroupLimitExceededException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_group_limit_exceeded_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_group_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentGroupNameRequiredException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::DeploymentGroupNameRequiredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_group_name_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_group_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "ECSServiceMappingLimitExceededException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::EcsServiceMappingLimitExceededException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::ecs_service_mapping_limit_exceeded_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_ecs_service_mapping_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidAlarmConfigException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::InvalidAlarmConfigException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_alarm_config_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_alarm_config_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidApplicationNameException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::InvalidApplicationNameException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_application_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_application_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidAutoRollbackConfigException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::InvalidAutoRollbackConfigException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_auto_rollback_config_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_auto_rollback_config_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidAutoScalingGroupException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::InvalidAutoScalingGroupException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_auto_scaling_group_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_auto_scaling_group_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidBlueGreenDeploymentConfigurationException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::InvalidBlueGreenDeploymentConfigurationException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_blue_green_deployment_configuration_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_blue_green_deployment_configuration_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidDeploymentConfigNameException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::InvalidDeploymentConfigNameException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_deployment_config_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_config_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidDeploymentGroupNameException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::InvalidDeploymentGroupNameException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_deployment_group_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_group_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidDeploymentStyleException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::InvalidDeploymentStyleException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_deployment_style_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_style_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidEC2TagCombinationException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::InvalidEc2TagCombinationException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_ec2_tag_combination_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_ec2_tag_combination_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidEC2TagException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::InvalidEc2TagException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_ec2_tag_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_ec2_tag_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidECSServiceException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::InvalidEcsServiceException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_ecs_service_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_ecs_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidInputException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::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::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidLoadBalancerInfoException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::InvalidLoadBalancerInfoException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_load_balancer_info_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_load_balancer_info_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidOnPremisesTagCombinationException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::InvalidOnPremisesTagCombinationException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_on_premises_tag_combination_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_on_premises_tag_combination_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidRoleException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::InvalidRoleException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_role_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_role_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidTagException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::InvalidTagException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_tag_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_tag_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidTagsToAddException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::InvalidTagsToAddException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_tags_to_add_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_tags_to_add_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidTargetGroupPairException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::InvalidTargetGroupPairException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_target_group_pair_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_target_group_pair_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidTrafficRoutingConfigurationException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::InvalidTrafficRoutingConfigurationException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_traffic_routing_configuration_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_traffic_routing_configuration_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidTriggerConfigException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::InvalidTriggerConfigException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_trigger_config_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_trigger_config_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "LifecycleHookLimitExceededException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::LifecycleHookLimitExceededException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::lifecycle_hook_limit_exceeded_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_lifecycle_hook_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "RoleRequiredException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::RoleRequiredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::role_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_role_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "TagSetListLimitExceededException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::TagSetListLimitExceededException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::tag_set_list_limit_exceeded_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_tag_set_list_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "ThrottlingException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::ThrottlingException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::throttling_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_throttling_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "TriggerTargetsLimitExceededException" => crate::error::CreateDeploymentGroupError { meta: generic, kind: crate::error::CreateDeploymentGroupErrorKind::TriggerTargetsLimitExceededException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::trigger_targets_limit_exceeded_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_trigger_targets_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        _ => crate::error::CreateDeploymentGroupError::generic(generic)
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_deployment_group_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::CreateDeploymentGroupOutput,
    crate::error::CreateDeploymentGroupError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::create_deployment_group_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_create_deployment_group(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::CreateDeploymentGroupError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_application_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteApplicationOutput, crate::error::DeleteApplicationError>
{
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteApplicationError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => return Err(crate::error::DeleteApplicationError::unhandled(generic)),
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "ApplicationNameRequiredException" => crate::error::DeleteApplicationError {
            meta: generic,
            kind: crate::error::DeleteApplicationErrorKind::ApplicationNameRequiredException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::application_name_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteApplicationError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidApplicationNameException" => crate::error::DeleteApplicationError {
            meta: generic,
            kind: crate::error::DeleteApplicationErrorKind::InvalidApplicationNameException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_application_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_application_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteApplicationError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidRoleException" => crate::error::DeleteApplicationError {
            meta: generic,
            kind: crate::error::DeleteApplicationErrorKind::InvalidRoleException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output = crate::error::invalid_role_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_role_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteApplicationError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        _ => crate::error::DeleteApplicationError::generic(generic),
    })
}

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

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_deployment_config_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteDeploymentConfigOutput,
    crate::error::DeleteDeploymentConfigError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteDeploymentConfigError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => {
            return Err(crate::error::DeleteDeploymentConfigError::unhandled(
                generic,
            ))
        }
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "DeploymentConfigInUseException" => crate::error::DeleteDeploymentConfigError {
            meta: generic,
            kind: crate::error::DeleteDeploymentConfigErrorKind::DeploymentConfigInUseException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::deployment_config_in_use_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_config_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteDeploymentConfigError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "DeploymentConfigNameRequiredException" => crate::error::DeleteDeploymentConfigError {
            meta: generic,
            kind:
                crate::error::DeleteDeploymentConfigErrorKind::DeploymentConfigNameRequiredException(
                    {
                        #[allow(unused_mut)]
                        let mut tmp = {
                            #[allow(unused_mut)]let mut output = crate::error::deployment_config_name_required_exception::Builder::default();
                            let _ = response;
                            output = crate::json_deser::deser_structure_crate_error_deployment_config_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteDeploymentConfigError::unhandled)?;
                            output.build()
                        };
                        if (&tmp.message).is_none() {
                            tmp.message = _error_message;
                        }
                        tmp
                    },
                ),
        },
        "InvalidDeploymentConfigNameException" => crate::error::DeleteDeploymentConfigError {
            meta: generic,
            kind:
                crate::error::DeleteDeploymentConfigErrorKind::InvalidDeploymentConfigNameException(
                    {
                        #[allow(unused_mut)]
                        let mut tmp = {
                            #[allow(unused_mut)]let mut output = crate::error::invalid_deployment_config_name_exception::Builder::default();
                            let _ = response;
                            output = crate::json_deser::deser_structure_crate_error_invalid_deployment_config_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteDeploymentConfigError::unhandled)?;
                            output.build()
                        };
                        if (&tmp.message).is_none() {
                            tmp.message = _error_message;
                        }
                        tmp
                    },
                ),
        },
        "InvalidOperationException" => crate::error::DeleteDeploymentConfigError {
            meta: generic,
            kind: crate::error::DeleteDeploymentConfigErrorKind::InvalidOperationException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output = crate::error::invalid_operation_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_operation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteDeploymentConfigError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        _ => crate::error::DeleteDeploymentConfigError::generic(generic),
    })
}

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

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_deployment_group_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteDeploymentGroupOutput,
    crate::error::DeleteDeploymentGroupError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteDeploymentGroupError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => return Err(crate::error::DeleteDeploymentGroupError::unhandled(generic)),
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "ApplicationNameRequiredException" => crate::error::DeleteDeploymentGroupError {
            meta: generic,
            kind: crate::error::DeleteDeploymentGroupErrorKind::ApplicationNameRequiredException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::application_name_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteDeploymentGroupError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "DeploymentGroupNameRequiredException" => crate::error::DeleteDeploymentGroupError {
            meta: generic,
            kind:
                crate::error::DeleteDeploymentGroupErrorKind::DeploymentGroupNameRequiredException(
                    {
                        #[allow(unused_mut)]
                        let mut tmp = {
                            #[allow(unused_mut)]let mut output = crate::error::deployment_group_name_required_exception::Builder::default();
                            let _ = response;
                            output = crate::json_deser::deser_structure_crate_error_deployment_group_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteDeploymentGroupError::unhandled)?;
                            output.build()
                        };
                        if (&tmp.message).is_none() {
                            tmp.message = _error_message;
                        }
                        tmp
                    },
                ),
        },
        "InvalidApplicationNameException" => crate::error::DeleteDeploymentGroupError {
            meta: generic,
            kind: crate::error::DeleteDeploymentGroupErrorKind::InvalidApplicationNameException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_application_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_application_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteDeploymentGroupError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidDeploymentGroupNameException" => crate::error::DeleteDeploymentGroupError {
            meta: generic,
            kind: crate::error::DeleteDeploymentGroupErrorKind::InvalidDeploymentGroupNameException(
                {
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]
                        let mut output =
                            crate::error::invalid_deployment_group_name_exception::Builder::default(
                            );
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_invalid_deployment_group_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteDeploymentGroupError::unhandled)?;
                        output.build()
                    };
                    if (&tmp.message).is_none() {
                        tmp.message = _error_message;
                    }
                    tmp
                },
            ),
        },
        "InvalidRoleException" => crate::error::DeleteDeploymentGroupError {
            meta: generic,
            kind: crate::error::DeleteDeploymentGroupErrorKind::InvalidRoleException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output = crate::error::invalid_role_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_role_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteDeploymentGroupError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        _ => crate::error::DeleteDeploymentGroupError::generic(generic),
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_deployment_group_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteDeploymentGroupOutput,
    crate::error::DeleteDeploymentGroupError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_deployment_group_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_delete_deployment_group(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DeleteDeploymentGroupError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_git_hub_account_token_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteGitHubAccountTokenOutput,
    crate::error::DeleteGitHubAccountTokenError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeleteGitHubAccountTokenError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => {
            return Err(crate::error::DeleteGitHubAccountTokenError::unhandled(
                generic,
            ))
        }
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "GitHubAccountTokenDoesNotExistException" => crate::error::DeleteGitHubAccountTokenError { meta: generic, kind: crate::error::DeleteGitHubAccountTokenErrorKind::GitHubAccountTokenDoesNotExistException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::git_hub_account_token_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_git_hub_account_token_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteGitHubAccountTokenError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "GitHubAccountTokenNameRequiredException" => crate::error::DeleteGitHubAccountTokenError { meta: generic, kind: crate::error::DeleteGitHubAccountTokenErrorKind::GitHubAccountTokenNameRequiredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::git_hub_account_token_name_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_git_hub_account_token_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteGitHubAccountTokenError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidGitHubAccountTokenNameException" => crate::error::DeleteGitHubAccountTokenError { meta: generic, kind: crate::error::DeleteGitHubAccountTokenErrorKind::InvalidGitHubAccountTokenNameException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_git_hub_account_token_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_git_hub_account_token_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteGitHubAccountTokenError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "OperationNotSupportedException" => crate::error::DeleteGitHubAccountTokenError { meta: generic, kind: crate::error::DeleteGitHubAccountTokenErrorKind::OperationNotSupportedException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::operation_not_supported_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_operation_not_supported_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteGitHubAccountTokenError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "ResourceValidationException" => crate::error::DeleteGitHubAccountTokenError { meta: generic, kind: crate::error::DeleteGitHubAccountTokenErrorKind::ResourceValidationException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::resource_validation_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_resource_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteGitHubAccountTokenError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        _ => crate::error::DeleteGitHubAccountTokenError::generic(generic)
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_git_hub_account_token_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeleteGitHubAccountTokenOutput,
    crate::error::DeleteGitHubAccountTokenError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::delete_git_hub_account_token_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_delete_git_hub_account_token(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::DeleteGitHubAccountTokenError::unhandled)?;
        output.build()
    })
}

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

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

#[allow(clippy::unnecessary_wraps)]
pub fn parse_deregister_on_premises_instance_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::DeregisterOnPremisesInstanceOutput,
    crate::error::DeregisterOnPremisesInstanceError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::DeregisterOnPremisesInstanceError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => {
            return Err(crate::error::DeregisterOnPremisesInstanceError::unhandled(
                generic,
            ))
        }
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "InstanceNameRequiredException" => crate::error::DeregisterOnPremisesInstanceError {
            meta: generic,
            kind:
                crate::error::DeregisterOnPremisesInstanceErrorKind::InstanceNameRequiredException(
                    {
                        #[allow(unused_mut)]
                        let mut tmp = {
                            #[allow(unused_mut)]
                            let mut output =
                                crate::error::instance_name_required_exception::Builder::default();
                            let _ = response;
                            output = crate::json_deser::deser_structure_crate_error_instance_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeregisterOnPremisesInstanceError::unhandled)?;
                            output.build()
                        };
                        if (&tmp.message).is_none() {
                            tmp.message = _error_message;
                        }
                        tmp
                    },
                ),
        },
        "InvalidInstanceNameException" => crate::error::DeregisterOnPremisesInstanceError {
            meta: generic,
            kind: crate::error::DeregisterOnPremisesInstanceErrorKind::InvalidInstanceNameException(
                {
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]
                        let mut output =
                            crate::error::invalid_instance_name_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_invalid_instance_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeregisterOnPremisesInstanceError::unhandled)?;
                        output.build()
                    };
                    if (&tmp.message).is_none() {
                        tmp.message = _error_message;
                    }
                    tmp
                },
            ),
        },
        _ => crate::error::DeregisterOnPremisesInstanceError::generic(generic),
    })
}

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

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_application_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetApplicationOutput, crate::error::GetApplicationError> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetApplicationError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => return Err(crate::error::GetApplicationError::unhandled(generic)),
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "ApplicationDoesNotExistException" => crate::error::GetApplicationError {
            meta: generic,
            kind: crate::error::GetApplicationErrorKind::ApplicationDoesNotExistException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::application_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetApplicationError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "ApplicationNameRequiredException" => crate::error::GetApplicationError {
            meta: generic,
            kind: crate::error::GetApplicationErrorKind::ApplicationNameRequiredException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::application_name_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetApplicationError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidApplicationNameException" => crate::error::GetApplicationError {
            meta: generic,
            kind: crate::error::GetApplicationErrorKind::InvalidApplicationNameException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_application_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_application_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetApplicationError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        _ => crate::error::GetApplicationError::generic(generic),
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_application_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetApplicationOutput, crate::error::GetApplicationError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::get_application_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_get_application(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::GetApplicationError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_application_revision_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetApplicationRevisionOutput,
    crate::error::GetApplicationRevisionError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetApplicationRevisionError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => {
            return Err(crate::error::GetApplicationRevisionError::unhandled(
                generic,
            ))
        }
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "ApplicationDoesNotExistException" => crate::error::GetApplicationRevisionError {
            meta: generic,
            kind: crate::error::GetApplicationRevisionErrorKind::ApplicationDoesNotExistException(
                {
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]
                        let mut output =
                            crate::error::application_does_not_exist_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_application_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetApplicationRevisionError::unhandled)?;
                        output.build()
                    };
                    if (&tmp.message).is_none() {
                        tmp.message = _error_message;
                    }
                    tmp
                },
            ),
        },
        "ApplicationNameRequiredException" => crate::error::GetApplicationRevisionError {
            meta: generic,
            kind: crate::error::GetApplicationRevisionErrorKind::ApplicationNameRequiredException(
                {
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]
                        let mut output =
                            crate::error::application_name_required_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_application_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetApplicationRevisionError::unhandled)?;
                        output.build()
                    };
                    if (&tmp.message).is_none() {
                        tmp.message = _error_message;
                    }
                    tmp
                },
            ),
        },
        "InvalidApplicationNameException" => crate::error::GetApplicationRevisionError {
            meta: generic,
            kind: crate::error::GetApplicationRevisionErrorKind::InvalidApplicationNameException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_application_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_application_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetApplicationRevisionError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidRevisionException" => crate::error::GetApplicationRevisionError {
            meta: generic,
            kind: crate::error::GetApplicationRevisionErrorKind::InvalidRevisionException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output = crate::error::invalid_revision_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_revision_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetApplicationRevisionError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "RevisionDoesNotExistException" => crate::error::GetApplicationRevisionError {
            meta: generic,
            kind: crate::error::GetApplicationRevisionErrorKind::RevisionDoesNotExistException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::revision_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_revision_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetApplicationRevisionError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "RevisionRequiredException" => crate::error::GetApplicationRevisionError {
            meta: generic,
            kind: crate::error::GetApplicationRevisionErrorKind::RevisionRequiredException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output = crate::error::revision_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_revision_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetApplicationRevisionError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        _ => crate::error::GetApplicationRevisionError::generic(generic),
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_application_revision_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetApplicationRevisionOutput,
    crate::error::GetApplicationRevisionError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::get_application_revision_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_get_application_revision(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::GetApplicationRevisionError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_deployment_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetDeploymentOutput, crate::error::GetDeploymentError> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetDeploymentError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => return Err(crate::error::GetDeploymentError::unhandled(generic)),
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "DeploymentDoesNotExistException" => crate::error::GetDeploymentError {
            meta: generic,
            kind: crate::error::GetDeploymentErrorKind::DeploymentDoesNotExistException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::deployment_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "DeploymentIdRequiredException" => crate::error::GetDeploymentError {
            meta: generic,
            kind: crate::error::GetDeploymentErrorKind::DeploymentIdRequiredException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::deployment_id_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_id_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidDeploymentIdException" => crate::error::GetDeploymentError {
            meta: generic,
            kind: crate::error::GetDeploymentErrorKind::InvalidDeploymentIdException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_deployment_id_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_id_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        _ => crate::error::GetDeploymentError::generic(generic),
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_deployment_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetDeploymentOutput, crate::error::GetDeploymentError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::get_deployment_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_get_deployment(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::GetDeploymentError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_deployment_config_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetDeploymentConfigOutput,
    crate::error::GetDeploymentConfigError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetDeploymentConfigError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => return Err(crate::error::GetDeploymentConfigError::unhandled(generic)),
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "DeploymentConfigDoesNotExistException" => crate::error::GetDeploymentConfigError {
            meta: generic,
            kind: crate::error::GetDeploymentConfigErrorKind::DeploymentConfigDoesNotExistException(
                {
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]let mut output = crate::error::deployment_config_does_not_exist_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_deployment_config_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentConfigError::unhandled)?;
                        output.build()
                    };
                    if (&tmp.message).is_none() {
                        tmp.message = _error_message;
                    }
                    tmp
                },
            ),
        },
        "DeploymentConfigNameRequiredException" => crate::error::GetDeploymentConfigError {
            meta: generic,
            kind: crate::error::GetDeploymentConfigErrorKind::DeploymentConfigNameRequiredException(
                {
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]let mut output = crate::error::deployment_config_name_required_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_deployment_config_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentConfigError::unhandled)?;
                        output.build()
                    };
                    if (&tmp.message).is_none() {
                        tmp.message = _error_message;
                    }
                    tmp
                },
            ),
        },
        "InvalidComputePlatformException" => crate::error::GetDeploymentConfigError {
            meta: generic,
            kind: crate::error::GetDeploymentConfigErrorKind::InvalidComputePlatformException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_compute_platform_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_compute_platform_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentConfigError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidDeploymentConfigNameException" => crate::error::GetDeploymentConfigError {
            meta: generic,
            kind: crate::error::GetDeploymentConfigErrorKind::InvalidDeploymentConfigNameException(
                {
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]let mut output = crate::error::invalid_deployment_config_name_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_invalid_deployment_config_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentConfigError::unhandled)?;
                        output.build()
                    };
                    if (&tmp.message).is_none() {
                        tmp.message = _error_message;
                    }
                    tmp
                },
            ),
        },
        _ => crate::error::GetDeploymentConfigError::generic(generic),
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_deployment_config_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetDeploymentConfigOutput,
    crate::error::GetDeploymentConfigError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::get_deployment_config_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_get_deployment_config(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::GetDeploymentConfigError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_deployment_group_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetDeploymentGroupOutput,
    crate::error::GetDeploymentGroupError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetDeploymentGroupError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => return Err(crate::error::GetDeploymentGroupError::unhandled(generic)),
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "ApplicationDoesNotExistException" => crate::error::GetDeploymentGroupError {
            meta: generic,
            kind: crate::error::GetDeploymentGroupErrorKind::ApplicationDoesNotExistException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::application_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentGroupError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "ApplicationNameRequiredException" => crate::error::GetDeploymentGroupError {
            meta: generic,
            kind: crate::error::GetDeploymentGroupErrorKind::ApplicationNameRequiredException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::application_name_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentGroupError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "DeploymentConfigDoesNotExistException" => crate::error::GetDeploymentGroupError {
            meta: generic,
            kind: crate::error::GetDeploymentGroupErrorKind::DeploymentConfigDoesNotExistException(
                {
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]let mut output = crate::error::deployment_config_does_not_exist_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_deployment_config_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentGroupError::unhandled)?;
                        output.build()
                    };
                    if (&tmp.message).is_none() {
                        tmp.message = _error_message;
                    }
                    tmp
                },
            ),
        },
        "DeploymentGroupDoesNotExistException" => crate::error::GetDeploymentGroupError {
            meta: generic,
            kind: crate::error::GetDeploymentGroupErrorKind::DeploymentGroupDoesNotExistException(
                {
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]let mut output = crate::error::deployment_group_does_not_exist_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_deployment_group_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentGroupError::unhandled)?;
                        output.build()
                    };
                    if (&tmp.message).is_none() {
                        tmp.message = _error_message;
                    }
                    tmp
                },
            ),
        },
        "DeploymentGroupNameRequiredException" => crate::error::GetDeploymentGroupError {
            meta: generic,
            kind: crate::error::GetDeploymentGroupErrorKind::DeploymentGroupNameRequiredException(
                {
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]let mut output = crate::error::deployment_group_name_required_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_deployment_group_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentGroupError::unhandled)?;
                        output.build()
                    };
                    if (&tmp.message).is_none() {
                        tmp.message = _error_message;
                    }
                    tmp
                },
            ),
        },
        "InvalidApplicationNameException" => crate::error::GetDeploymentGroupError {
            meta: generic,
            kind: crate::error::GetDeploymentGroupErrorKind::InvalidApplicationNameException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_application_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_application_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentGroupError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidDeploymentGroupNameException" => crate::error::GetDeploymentGroupError {
            meta: generic,
            kind: crate::error::GetDeploymentGroupErrorKind::InvalidDeploymentGroupNameException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_deployment_group_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_group_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentGroupError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        _ => crate::error::GetDeploymentGroupError::generic(generic),
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_deployment_group_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetDeploymentGroupOutput,
    crate::error::GetDeploymentGroupError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::get_deployment_group_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_get_deployment_group(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::GetDeploymentGroupError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_deployment_instance_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetDeploymentInstanceOutput,
    crate::error::GetDeploymentInstanceError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetDeploymentInstanceError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => return Err(crate::error::GetDeploymentInstanceError::unhandled(generic)),
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "DeploymentDoesNotExistException" => crate::error::GetDeploymentInstanceError {
            meta: generic,
            kind: crate::error::GetDeploymentInstanceErrorKind::DeploymentDoesNotExistException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::deployment_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentInstanceError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "DeploymentIdRequiredException" => crate::error::GetDeploymentInstanceError {
            meta: generic,
            kind: crate::error::GetDeploymentInstanceErrorKind::DeploymentIdRequiredException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::deployment_id_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_id_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentInstanceError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InstanceDoesNotExistException" => crate::error::GetDeploymentInstanceError {
            meta: generic,
            kind: crate::error::GetDeploymentInstanceErrorKind::InstanceDoesNotExistException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::instance_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_instance_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentInstanceError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InstanceIdRequiredException" => crate::error::GetDeploymentInstanceError {
            meta: generic,
            kind: crate::error::GetDeploymentInstanceErrorKind::InstanceIdRequiredException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::instance_id_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_instance_id_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentInstanceError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidComputePlatformException" => crate::error::GetDeploymentInstanceError {
            meta: generic,
            kind: crate::error::GetDeploymentInstanceErrorKind::InvalidComputePlatformException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_compute_platform_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_compute_platform_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentInstanceError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidDeploymentIdException" => crate::error::GetDeploymentInstanceError {
            meta: generic,
            kind: crate::error::GetDeploymentInstanceErrorKind::InvalidDeploymentIdException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_deployment_id_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_id_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentInstanceError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidInstanceNameException" => crate::error::GetDeploymentInstanceError {
            meta: generic,
            kind: crate::error::GetDeploymentInstanceErrorKind::InvalidInstanceNameException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_instance_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_instance_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentInstanceError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        _ => crate::error::GetDeploymentInstanceError::generic(generic),
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_deployment_instance_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetDeploymentInstanceOutput,
    crate::error::GetDeploymentInstanceError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::get_deployment_instance_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_get_deployment_instance(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::GetDeploymentInstanceError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_deployment_target_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetDeploymentTargetOutput,
    crate::error::GetDeploymentTargetError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetDeploymentTargetError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => return Err(crate::error::GetDeploymentTargetError::unhandled(generic)),
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "DeploymentDoesNotExistException" => crate::error::GetDeploymentTargetError {
            meta: generic,
            kind: crate::error::GetDeploymentTargetErrorKind::DeploymentDoesNotExistException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::deployment_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentTargetError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "DeploymentIdRequiredException" => crate::error::GetDeploymentTargetError {
            meta: generic,
            kind: crate::error::GetDeploymentTargetErrorKind::DeploymentIdRequiredException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::deployment_id_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_id_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentTargetError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "DeploymentNotStartedException" => crate::error::GetDeploymentTargetError {
            meta: generic,
            kind: crate::error::GetDeploymentTargetErrorKind::DeploymentNotStartedException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::deployment_not_started_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_not_started_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentTargetError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "DeploymentTargetDoesNotExistException" => crate::error::GetDeploymentTargetError {
            meta: generic,
            kind: crate::error::GetDeploymentTargetErrorKind::DeploymentTargetDoesNotExistException(
                {
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]let mut output = crate::error::deployment_target_does_not_exist_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_deployment_target_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentTargetError::unhandled)?;
                        output.build()
                    };
                    if (&tmp.message).is_none() {
                        tmp.message = _error_message;
                    }
                    tmp
                },
            ),
        },
        "DeploymentTargetIdRequiredException" => {
            crate::error::GetDeploymentTargetError {
                meta: generic,
                kind:
                    crate::error::GetDeploymentTargetErrorKind::DeploymentTargetIdRequiredException(
                        {
                            #[allow(unused_mut)]
                            let mut tmp = {
                                #[allow(unused_mut)]let mut output = crate::error::deployment_target_id_required_exception::Builder::default();
                                let _ = response;
                                output = crate::json_deser::deser_structure_crate_error_deployment_target_id_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentTargetError::unhandled)?;
                                output.build()
                            };
                            if (&tmp.message).is_none() {
                                tmp.message = _error_message;
                            }
                            tmp
                        },
                    ),
            }
        }
        "InvalidDeploymentIdException" => crate::error::GetDeploymentTargetError {
            meta: generic,
            kind: crate::error::GetDeploymentTargetErrorKind::InvalidDeploymentIdException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_deployment_id_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_id_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentTargetError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidDeploymentTargetIdException" => crate::error::GetDeploymentTargetError {
            meta: generic,
            kind: crate::error::GetDeploymentTargetErrorKind::InvalidDeploymentTargetIdException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_deployment_target_id_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_target_id_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentTargetError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidInstanceNameException" => crate::error::GetDeploymentTargetError {
            meta: generic,
            kind: crate::error::GetDeploymentTargetErrorKind::InvalidInstanceNameException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_instance_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_instance_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetDeploymentTargetError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        _ => crate::error::GetDeploymentTargetError::generic(generic),
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_deployment_target_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetDeploymentTargetOutput,
    crate::error::GetDeploymentTargetError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::get_deployment_target_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_get_deployment_target(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::GetDeploymentTargetError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_on_premises_instance_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetOnPremisesInstanceOutput,
    crate::error::GetOnPremisesInstanceError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::GetOnPremisesInstanceError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => return Err(crate::error::GetOnPremisesInstanceError::unhandled(generic)),
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "InstanceNameRequiredException" => crate::error::GetOnPremisesInstanceError {
            meta: generic,
            kind: crate::error::GetOnPremisesInstanceErrorKind::InstanceNameRequiredException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::instance_name_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_instance_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetOnPremisesInstanceError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InstanceNotRegisteredException" => crate::error::GetOnPremisesInstanceError {
            meta: generic,
            kind: crate::error::GetOnPremisesInstanceErrorKind::InstanceNotRegisteredException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::instance_not_registered_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_instance_not_registered_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetOnPremisesInstanceError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidInstanceNameException" => crate::error::GetOnPremisesInstanceError {
            meta: generic,
            kind: crate::error::GetOnPremisesInstanceErrorKind::InvalidInstanceNameException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_instance_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_instance_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetOnPremisesInstanceError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        _ => crate::error::GetOnPremisesInstanceError::generic(generic),
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_on_premises_instance_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::GetOnPremisesInstanceOutput,
    crate::error::GetOnPremisesInstanceError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::get_on_premises_instance_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_get_on_premises_instance(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::GetOnPremisesInstanceError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_application_revisions_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ListApplicationRevisionsOutput,
    crate::error::ListApplicationRevisionsError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::ListApplicationRevisionsError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => {
            return Err(crate::error::ListApplicationRevisionsError::unhandled(
                generic,
            ))
        }
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "ApplicationDoesNotExistException" => crate::error::ListApplicationRevisionsError {
            meta: generic,
            kind: crate::error::ListApplicationRevisionsErrorKind::ApplicationDoesNotExistException(
                {
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]
                        let mut output =
                            crate::error::application_does_not_exist_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_application_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListApplicationRevisionsError::unhandled)?;
                        output.build()
                    };
                    if (&tmp.message).is_none() {
                        tmp.message = _error_message;
                    }
                    tmp
                },
            ),
        },
        "ApplicationNameRequiredException" => crate::error::ListApplicationRevisionsError {
            meta: generic,
            kind: crate::error::ListApplicationRevisionsErrorKind::ApplicationNameRequiredException(
                {
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]
                        let mut output =
                            crate::error::application_name_required_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_application_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListApplicationRevisionsError::unhandled)?;
                        output.build()
                    };
                    if (&tmp.message).is_none() {
                        tmp.message = _error_message;
                    }
                    tmp
                },
            ),
        },
        "BucketNameFilterRequiredException" => crate::error::ListApplicationRevisionsError {
            meta: generic,
            kind:
                crate::error::ListApplicationRevisionsErrorKind::BucketNameFilterRequiredException(
                    {
                        #[allow(unused_mut)]
                        let mut tmp = {
                            #[allow(unused_mut)]let mut output = crate::error::bucket_name_filter_required_exception::Builder::default();
                            let _ = response;
                            output = crate::json_deser::deser_structure_crate_error_bucket_name_filter_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListApplicationRevisionsError::unhandled)?;
                            output.build()
                        };
                        if (&tmp.message).is_none() {
                            tmp.message = _error_message;
                        }
                        tmp
                    },
                ),
        },
        "InvalidApplicationNameException" => crate::error::ListApplicationRevisionsError {
            meta: generic,
            kind: crate::error::ListApplicationRevisionsErrorKind::InvalidApplicationNameException(
                {
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]
                        let mut output =
                            crate::error::invalid_application_name_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_invalid_application_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListApplicationRevisionsError::unhandled)?;
                        output.build()
                    };
                    if (&tmp.message).is_none() {
                        tmp.message = _error_message;
                    }
                    tmp
                },
            ),
        },
        "InvalidBucketNameFilterException" => crate::error::ListApplicationRevisionsError {
            meta: generic,
            kind: crate::error::ListApplicationRevisionsErrorKind::InvalidBucketNameFilterException(
                {
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]
                        let mut output =
                            crate::error::invalid_bucket_name_filter_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_invalid_bucket_name_filter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListApplicationRevisionsError::unhandled)?;
                        output.build()
                    };
                    if (&tmp.message).is_none() {
                        tmp.message = _error_message;
                    }
                    tmp
                },
            ),
        },
        "InvalidDeployedStateFilterException" => crate::error::ListApplicationRevisionsError {
            meta: generic,
            kind:
                crate::error::ListApplicationRevisionsErrorKind::InvalidDeployedStateFilterException(
                    {
                        #[allow(unused_mut)]
                        let mut tmp = {
                            #[allow(unused_mut)]let mut output = crate::error::invalid_deployed_state_filter_exception::Builder::default();
                            let _ = response;
                            output = crate::json_deser::deser_structure_crate_error_invalid_deployed_state_filter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListApplicationRevisionsError::unhandled)?;
                            output.build()
                        };
                        if (&tmp.message).is_none() {
                            tmp.message = _error_message;
                        }
                        tmp
                    },
                ),
        },
        "InvalidKeyPrefixFilterException" => crate::error::ListApplicationRevisionsError {
            meta: generic,
            kind: crate::error::ListApplicationRevisionsErrorKind::InvalidKeyPrefixFilterException(
                {
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]
                        let mut output =
                            crate::error::invalid_key_prefix_filter_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_invalid_key_prefix_filter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListApplicationRevisionsError::unhandled)?;
                        output.build()
                    };
                    if (&tmp.message).is_none() {
                        tmp.message = _error_message;
                    }
                    tmp
                },
            ),
        },
        "InvalidNextTokenException" => crate::error::ListApplicationRevisionsError {
            meta: generic,
            kind: crate::error::ListApplicationRevisionsErrorKind::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::ListApplicationRevisionsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidSortByException" => crate::error::ListApplicationRevisionsError {
            meta: generic,
            kind: crate::error::ListApplicationRevisionsErrorKind::InvalidSortByException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output = crate::error::invalid_sort_by_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_sort_by_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListApplicationRevisionsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidSortOrderException" => crate::error::ListApplicationRevisionsError {
            meta: generic,
            kind: crate::error::ListApplicationRevisionsErrorKind::InvalidSortOrderException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output = crate::error::invalid_sort_order_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_sort_order_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListApplicationRevisionsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        _ => crate::error::ListApplicationRevisionsError::generic(generic),
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_application_revisions_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ListApplicationRevisionsOutput,
    crate::error::ListApplicationRevisionsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::list_application_revisions_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_list_application_revisions(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ListApplicationRevisionsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_applications_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListApplicationsOutput, crate::error::ListApplicationsError>
{
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::ListApplicationsError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => return Err(crate::error::ListApplicationsError::unhandled(generic)),
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "InvalidNextTokenException" => crate::error::ListApplicationsError {
            meta: generic,
            kind: crate::error::ListApplicationsErrorKind::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::ListApplicationsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        _ => crate::error::ListApplicationsError::generic(generic),
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_applications_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListApplicationsOutput, crate::error::ListApplicationsError>
{
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::list_applications_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_list_applications(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ListApplicationsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_deployment_configs_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ListDeploymentConfigsOutput,
    crate::error::ListDeploymentConfigsError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::ListDeploymentConfigsError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => return Err(crate::error::ListDeploymentConfigsError::unhandled(generic)),
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "InvalidNextTokenException" => crate::error::ListDeploymentConfigsError {
            meta: generic,
            kind: crate::error::ListDeploymentConfigsErrorKind::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::ListDeploymentConfigsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        _ => crate::error::ListDeploymentConfigsError::generic(generic),
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_deployment_configs_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ListDeploymentConfigsOutput,
    crate::error::ListDeploymentConfigsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::list_deployment_configs_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_list_deployment_configs(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ListDeploymentConfigsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_deployment_groups_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ListDeploymentGroupsOutput,
    crate::error::ListDeploymentGroupsError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::ListDeploymentGroupsError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => return Err(crate::error::ListDeploymentGroupsError::unhandled(generic)),
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "ApplicationDoesNotExistException" => crate::error::ListDeploymentGroupsError {
            meta: generic,
            kind: crate::error::ListDeploymentGroupsErrorKind::ApplicationDoesNotExistException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::application_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentGroupsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "ApplicationNameRequiredException" => crate::error::ListDeploymentGroupsError {
            meta: generic,
            kind: crate::error::ListDeploymentGroupsErrorKind::ApplicationNameRequiredException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::application_name_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentGroupsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidApplicationNameException" => crate::error::ListDeploymentGroupsError {
            meta: generic,
            kind: crate::error::ListDeploymentGroupsErrorKind::InvalidApplicationNameException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_application_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_application_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentGroupsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidNextTokenException" => crate::error::ListDeploymentGroupsError {
            meta: generic,
            kind: crate::error::ListDeploymentGroupsErrorKind::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::ListDeploymentGroupsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        _ => crate::error::ListDeploymentGroupsError::generic(generic),
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_deployment_groups_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ListDeploymentGroupsOutput,
    crate::error::ListDeploymentGroupsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::list_deployment_groups_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_list_deployment_groups(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ListDeploymentGroupsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_deployment_instances_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ListDeploymentInstancesOutput,
    crate::error::ListDeploymentInstancesError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::ListDeploymentInstancesError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => {
            return Err(crate::error::ListDeploymentInstancesError::unhandled(
                generic,
            ))
        }
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "DeploymentDoesNotExistException" => crate::error::ListDeploymentInstancesError { meta: generic, kind: crate::error::ListDeploymentInstancesErrorKind::DeploymentDoesNotExistException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentInstancesError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentIdRequiredException" => crate::error::ListDeploymentInstancesError { meta: generic, kind: crate::error::ListDeploymentInstancesErrorKind::DeploymentIdRequiredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_id_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_id_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentInstancesError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentNotStartedException" => crate::error::ListDeploymentInstancesError { meta: generic, kind: crate::error::ListDeploymentInstancesErrorKind::DeploymentNotStartedException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_not_started_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_not_started_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentInstancesError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidComputePlatformException" => crate::error::ListDeploymentInstancesError { meta: generic, kind: crate::error::ListDeploymentInstancesErrorKind::InvalidComputePlatformException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_compute_platform_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_compute_platform_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentInstancesError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidDeploymentIdException" => crate::error::ListDeploymentInstancesError { meta: generic, kind: crate::error::ListDeploymentInstancesErrorKind::InvalidDeploymentIdException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_deployment_id_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_id_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentInstancesError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidDeploymentInstanceTypeException" => crate::error::ListDeploymentInstancesError { meta: generic, kind: crate::error::ListDeploymentInstancesErrorKind::InvalidDeploymentInstanceTypeException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_deployment_instance_type_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_instance_type_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentInstancesError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidInstanceStatusException" => crate::error::ListDeploymentInstancesError { meta: generic, kind: crate::error::ListDeploymentInstancesErrorKind::InvalidInstanceStatusException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_instance_status_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_instance_status_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentInstancesError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidInstanceTypeException" => crate::error::ListDeploymentInstancesError { meta: generic, kind: crate::error::ListDeploymentInstancesErrorKind::InvalidInstanceTypeException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_instance_type_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_instance_type_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentInstancesError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidNextTokenException" => crate::error::ListDeploymentInstancesError { meta: generic, kind: crate::error::ListDeploymentInstancesErrorKind::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::ListDeploymentInstancesError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidTargetFilterNameException" => crate::error::ListDeploymentInstancesError { meta: generic, kind: crate::error::ListDeploymentInstancesErrorKind::InvalidTargetFilterNameException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_target_filter_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_target_filter_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentInstancesError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        _ => crate::error::ListDeploymentInstancesError::generic(generic)
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_deployment_instances_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ListDeploymentInstancesOutput,
    crate::error::ListDeploymentInstancesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::list_deployment_instances_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_list_deployment_instances(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ListDeploymentInstancesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_deployments_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListDeploymentsOutput, crate::error::ListDeploymentsError> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::ListDeploymentsError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => return Err(crate::error::ListDeploymentsError::unhandled(generic)),
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "ApplicationDoesNotExistException" => crate::error::ListDeploymentsError {
            meta: generic,
            kind: crate::error::ListDeploymentsErrorKind::ApplicationDoesNotExistException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::application_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "ApplicationNameRequiredException" => crate::error::ListDeploymentsError {
            meta: generic,
            kind: crate::error::ListDeploymentsErrorKind::ApplicationNameRequiredException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::application_name_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "DeploymentGroupDoesNotExistException" => crate::error::ListDeploymentsError {
            meta: generic,
            kind: crate::error::ListDeploymentsErrorKind::DeploymentGroupDoesNotExistException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::deployment_group_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_group_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "DeploymentGroupNameRequiredException" => crate::error::ListDeploymentsError {
            meta: generic,
            kind: crate::error::ListDeploymentsErrorKind::DeploymentGroupNameRequiredException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::deployment_group_name_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_group_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidApplicationNameException" => crate::error::ListDeploymentsError {
            meta: generic,
            kind: crate::error::ListDeploymentsErrorKind::InvalidApplicationNameException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_application_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_application_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidDeploymentGroupNameException" => crate::error::ListDeploymentsError {
            meta: generic,
            kind: crate::error::ListDeploymentsErrorKind::InvalidDeploymentGroupNameException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_deployment_group_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_group_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidDeploymentStatusException" => crate::error::ListDeploymentsError {
            meta: generic,
            kind: crate::error::ListDeploymentsErrorKind::InvalidDeploymentStatusException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_deployment_status_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_status_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidExternalIdException" => crate::error::ListDeploymentsError {
            meta: generic,
            kind: crate::error::ListDeploymentsErrorKind::InvalidExternalIdException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_external_id_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_external_id_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidInputException" => crate::error::ListDeploymentsError {
            meta: generic,
            kind: crate::error::ListDeploymentsErrorKind::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::ListDeploymentsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidNextTokenException" => crate::error::ListDeploymentsError {
            meta: generic,
            kind: crate::error::ListDeploymentsErrorKind::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::ListDeploymentsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidTimeRangeException" => crate::error::ListDeploymentsError {
            meta: generic,
            kind: crate::error::ListDeploymentsErrorKind::InvalidTimeRangeException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output = crate::error::invalid_time_range_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_time_range_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        _ => crate::error::ListDeploymentsError::generic(generic),
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_deployments_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListDeploymentsOutput, crate::error::ListDeploymentsError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::list_deployments_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_list_deployments(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ListDeploymentsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_deployment_targets_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ListDeploymentTargetsOutput,
    crate::error::ListDeploymentTargetsError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::ListDeploymentTargetsError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => return Err(crate::error::ListDeploymentTargetsError::unhandled(generic)),
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "DeploymentDoesNotExistException" => crate::error::ListDeploymentTargetsError {
            meta: generic,
            kind: crate::error::ListDeploymentTargetsErrorKind::DeploymentDoesNotExistException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::deployment_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentTargetsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "DeploymentIdRequiredException" => crate::error::ListDeploymentTargetsError {
            meta: generic,
            kind: crate::error::ListDeploymentTargetsErrorKind::DeploymentIdRequiredException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::deployment_id_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_id_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentTargetsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "DeploymentNotStartedException" => crate::error::ListDeploymentTargetsError {
            meta: generic,
            kind: crate::error::ListDeploymentTargetsErrorKind::DeploymentNotStartedException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::deployment_not_started_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_not_started_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentTargetsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidDeploymentIdException" => crate::error::ListDeploymentTargetsError {
            meta: generic,
            kind: crate::error::ListDeploymentTargetsErrorKind::InvalidDeploymentIdException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_deployment_id_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_id_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentTargetsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidDeploymentInstanceTypeException" => crate::error::ListDeploymentTargetsError {
            meta: generic,
            kind:
                crate::error::ListDeploymentTargetsErrorKind::InvalidDeploymentInstanceTypeException(
                    {
                        #[allow(unused_mut)]
                        let mut tmp = {
                            #[allow(unused_mut)]let mut output = crate::error::invalid_deployment_instance_type_exception::Builder::default();
                            let _ = response;
                            output = crate::json_deser::deser_structure_crate_error_invalid_deployment_instance_type_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentTargetsError::unhandled)?;
                            output.build()
                        };
                        if (&tmp.message).is_none() {
                            tmp.message = _error_message;
                        }
                        tmp
                    },
                ),
        },
        "InvalidInstanceStatusException" => crate::error::ListDeploymentTargetsError {
            meta: generic,
            kind: crate::error::ListDeploymentTargetsErrorKind::InvalidInstanceStatusException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_instance_status_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_instance_status_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentTargetsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidInstanceTypeException" => crate::error::ListDeploymentTargetsError {
            meta: generic,
            kind: crate::error::ListDeploymentTargetsErrorKind::InvalidInstanceTypeException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_instance_type_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_instance_type_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListDeploymentTargetsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidNextTokenException" => crate::error::ListDeploymentTargetsError {
            meta: generic,
            kind: crate::error::ListDeploymentTargetsErrorKind::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::ListDeploymentTargetsError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        _ => crate::error::ListDeploymentTargetsError::generic(generic),
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_deployment_targets_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ListDeploymentTargetsOutput,
    crate::error::ListDeploymentTargetsError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::list_deployment_targets_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_list_deployment_targets(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ListDeploymentTargetsError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_git_hub_account_token_names_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ListGitHubAccountTokenNamesOutput,
    crate::error::ListGitHubAccountTokenNamesError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::ListGitHubAccountTokenNamesError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => {
            return Err(crate::error::ListGitHubAccountTokenNamesError::unhandled(
                generic,
            ))
        }
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "InvalidNextTokenException" => crate::error::ListGitHubAccountTokenNamesError {
            meta: generic,
            kind: crate::error::ListGitHubAccountTokenNamesErrorKind::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::ListGitHubAccountTokenNamesError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "OperationNotSupportedException" => crate::error::ListGitHubAccountTokenNamesError {
            meta: generic,
            kind:
                crate::error::ListGitHubAccountTokenNamesErrorKind::OperationNotSupportedException(
                    {
                        #[allow(unused_mut)]
                        let mut tmp = {
                            #[allow(unused_mut)]
                            let mut output =
                                crate::error::operation_not_supported_exception::Builder::default();
                            let _ = response;
                            output = crate::json_deser::deser_structure_crate_error_operation_not_supported_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListGitHubAccountTokenNamesError::unhandled)?;
                            output.build()
                        };
                        if (&tmp.message).is_none() {
                            tmp.message = _error_message;
                        }
                        tmp
                    },
                ),
        },
        "ResourceValidationException" => crate::error::ListGitHubAccountTokenNamesError {
            meta: generic,
            kind: crate::error::ListGitHubAccountTokenNamesErrorKind::ResourceValidationException(
                {
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]
                        let mut output =
                            crate::error::resource_validation_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_resource_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListGitHubAccountTokenNamesError::unhandled)?;
                        output.build()
                    };
                    if (&tmp.message).is_none() {
                        tmp.message = _error_message;
                    }
                    tmp
                },
            ),
        },
        _ => crate::error::ListGitHubAccountTokenNamesError::generic(generic),
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_git_hub_account_token_names_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ListGitHubAccountTokenNamesOutput,
    crate::error::ListGitHubAccountTokenNamesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::list_git_hub_account_token_names_output::Builder::default();
        let _ = response;
        output =
            crate::json_deser::deser_operation_crate_operation_list_git_hub_account_token_names(
                response.body().as_ref(),
                output,
            )
            .map_err(crate::error::ListGitHubAccountTokenNamesError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_on_premises_instances_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ListOnPremisesInstancesOutput,
    crate::error::ListOnPremisesInstancesError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::ListOnPremisesInstancesError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => {
            return Err(crate::error::ListOnPremisesInstancesError::unhandled(
                generic,
            ))
        }
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "InvalidNextTokenException" => crate::error::ListOnPremisesInstancesError {
            meta: generic,
            kind: crate::error::ListOnPremisesInstancesErrorKind::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::ListOnPremisesInstancesError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidRegistrationStatusException" => crate::error::ListOnPremisesInstancesError {
            meta: generic,
            kind:
                crate::error::ListOnPremisesInstancesErrorKind::InvalidRegistrationStatusException(
                    {
                        #[allow(unused_mut)]
                        let mut tmp = {
                            #[allow(unused_mut)]let mut output = crate::error::invalid_registration_status_exception::Builder::default();
                            let _ = response;
                            output = crate::json_deser::deser_structure_crate_error_invalid_registration_status_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListOnPremisesInstancesError::unhandled)?;
                            output.build()
                        };
                        if (&tmp.message).is_none() {
                            tmp.message = _error_message;
                        }
                        tmp
                    },
                ),
        },
        "InvalidTagFilterException" => crate::error::ListOnPremisesInstancesError {
            meta: generic,
            kind: crate::error::ListOnPremisesInstancesErrorKind::InvalidTagFilterException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output = crate::error::invalid_tag_filter_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_tag_filter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListOnPremisesInstancesError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        _ => crate::error::ListOnPremisesInstancesError::generic(generic),
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_on_premises_instances_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::ListOnPremisesInstancesOutput,
    crate::error::ListOnPremisesInstancesError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::list_on_premises_instances_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_list_on_premises_instances(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::ListOnPremisesInstancesError::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 {
        "ArnNotSupportedException" => crate::error::ListTagsForResourceError {
            meta: generic,
            kind: crate::error::ListTagsForResourceErrorKind::ArnNotSupportedException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output = crate::error::arn_not_supported_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_arn_not_supported_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
            }),
        },
        "InvalidArnException" => crate::error::ListTagsForResourceError {
            meta: generic,
            kind: crate::error::ListTagsForResourceErrorKind::InvalidArnException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output = crate::error::invalid_arn_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_arn_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
            }),
        },
        "ResourceArnRequiredException" => crate::error::ListTagsForResourceError {
            meta: generic,
            kind: crate::error::ListTagsForResourceErrorKind::ResourceArnRequiredException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::resource_arn_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_resource_arn_required_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_put_lifecycle_event_hook_execution_status_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::PutLifecycleEventHookExecutionStatusOutput,
    crate::error::PutLifecycleEventHookExecutionStatusError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::PutLifecycleEventHookExecutionStatusError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => {
            return Err(crate::error::PutLifecycleEventHookExecutionStatusError::unhandled(generic))
        }
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "DeploymentDoesNotExistException" => crate::error::PutLifecycleEventHookExecutionStatusError { meta: generic, kind: crate::error::PutLifecycleEventHookExecutionStatusErrorKind::DeploymentDoesNotExistException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutLifecycleEventHookExecutionStatusError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentIdRequiredException" => crate::error::PutLifecycleEventHookExecutionStatusError { meta: generic, kind: crate::error::PutLifecycleEventHookExecutionStatusErrorKind::DeploymentIdRequiredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_id_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_id_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutLifecycleEventHookExecutionStatusError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidDeploymentIdException" => crate::error::PutLifecycleEventHookExecutionStatusError { meta: generic, kind: crate::error::PutLifecycleEventHookExecutionStatusErrorKind::InvalidDeploymentIdException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_deployment_id_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_id_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutLifecycleEventHookExecutionStatusError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidLifecycleEventHookExecutionIdException" => crate::error::PutLifecycleEventHookExecutionStatusError { meta: generic, kind: crate::error::PutLifecycleEventHookExecutionStatusErrorKind::InvalidLifecycleEventHookExecutionIdException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_lifecycle_event_hook_execution_id_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_lifecycle_event_hook_execution_id_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutLifecycleEventHookExecutionStatusError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidLifecycleEventHookExecutionStatusException" => crate::error::PutLifecycleEventHookExecutionStatusError { meta: generic, kind: crate::error::PutLifecycleEventHookExecutionStatusErrorKind::InvalidLifecycleEventHookExecutionStatusException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_lifecycle_event_hook_execution_status_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_lifecycle_event_hook_execution_status_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutLifecycleEventHookExecutionStatusError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "LifecycleEventAlreadyCompletedException" => crate::error::PutLifecycleEventHookExecutionStatusError { meta: generic, kind: crate::error::PutLifecycleEventHookExecutionStatusErrorKind::LifecycleEventAlreadyCompletedException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::lifecycle_event_already_completed_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_lifecycle_event_already_completed_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutLifecycleEventHookExecutionStatusError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "UnsupportedActionForDeploymentTypeException" => crate::error::PutLifecycleEventHookExecutionStatusError { meta: generic, kind: crate::error::PutLifecycleEventHookExecutionStatusErrorKind::UnsupportedActionForDeploymentTypeException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::unsupported_action_for_deployment_type_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_unsupported_action_for_deployment_type_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutLifecycleEventHookExecutionStatusError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        _ => crate::error::PutLifecycleEventHookExecutionStatusError::generic(generic)
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_put_lifecycle_event_hook_execution_status_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::PutLifecycleEventHookExecutionStatusOutput,
    crate::error::PutLifecycleEventHookExecutionStatusError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output =
            crate::output::put_lifecycle_event_hook_execution_status_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_put_lifecycle_event_hook_execution_status(response.body().as_ref(), output).map_err(crate::error::PutLifecycleEventHookExecutionStatusError::unhandled)?;
        output.build()
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_register_application_revision_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RegisterApplicationRevisionOutput,
    crate::error::RegisterApplicationRevisionError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::RegisterApplicationRevisionError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => {
            return Err(crate::error::RegisterApplicationRevisionError::unhandled(
                generic,
            ))
        }
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "ApplicationDoesNotExistException" => crate::error::RegisterApplicationRevisionError {
            meta: generic,
            kind:
                crate::error::RegisterApplicationRevisionErrorKind::ApplicationDoesNotExistException(
                    {
                        #[allow(unused_mut)]
                        let mut tmp = {
                            #[allow(unused_mut)]let mut output = crate::error::application_does_not_exist_exception::Builder::default();
                            let _ = response;
                            output = crate::json_deser::deser_structure_crate_error_application_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RegisterApplicationRevisionError::unhandled)?;
                            output.build()
                        };
                        if (&tmp.message).is_none() {
                            tmp.message = _error_message;
                        }
                        tmp
                    },
                ),
        },
        "ApplicationNameRequiredException" => crate::error::RegisterApplicationRevisionError {
            meta: generic,
            kind:
                crate::error::RegisterApplicationRevisionErrorKind::ApplicationNameRequiredException(
                    {
                        #[allow(unused_mut)]
                        let mut tmp = {
                            #[allow(unused_mut)]
                            let mut output =
                                crate::error::application_name_required_exception::Builder::default(
                                );
                            let _ = response;
                            output = crate::json_deser::deser_structure_crate_error_application_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RegisterApplicationRevisionError::unhandled)?;
                            output.build()
                        };
                        if (&tmp.message).is_none() {
                            tmp.message = _error_message;
                        }
                        tmp
                    },
                ),
        },
        "DescriptionTooLongException" => crate::error::RegisterApplicationRevisionError {
            meta: generic,
            kind: crate::error::RegisterApplicationRevisionErrorKind::DescriptionTooLongException(
                {
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]
                        let mut output =
                            crate::error::description_too_long_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_description_too_long_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RegisterApplicationRevisionError::unhandled)?;
                        output.build()
                    };
                    if (&tmp.message).is_none() {
                        tmp.message = _error_message;
                    }
                    tmp
                },
            ),
        },
        "InvalidApplicationNameException" => crate::error::RegisterApplicationRevisionError {
            meta: generic,
            kind:
                crate::error::RegisterApplicationRevisionErrorKind::InvalidApplicationNameException(
                    {
                        #[allow(unused_mut)]
                        let mut tmp = {
                            #[allow(unused_mut)]
                            let mut output =
                                crate::error::invalid_application_name_exception::Builder::default(
                                );
                            let _ = response;
                            output = crate::json_deser::deser_structure_crate_error_invalid_application_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RegisterApplicationRevisionError::unhandled)?;
                            output.build()
                        };
                        if (&tmp.message).is_none() {
                            tmp.message = _error_message;
                        }
                        tmp
                    },
                ),
        },
        "InvalidRevisionException" => crate::error::RegisterApplicationRevisionError {
            meta: generic,
            kind: crate::error::RegisterApplicationRevisionErrorKind::InvalidRevisionException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output = crate::error::invalid_revision_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_revision_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RegisterApplicationRevisionError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "RevisionRequiredException" => crate::error::RegisterApplicationRevisionError {
            meta: generic,
            kind: crate::error::RegisterApplicationRevisionErrorKind::RevisionRequiredException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output = crate::error::revision_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_revision_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RegisterApplicationRevisionError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        _ => crate::error::RegisterApplicationRevisionError::generic(generic),
    })
}

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

#[allow(clippy::unnecessary_wraps)]
pub fn parse_register_on_premises_instance_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RegisterOnPremisesInstanceOutput,
    crate::error::RegisterOnPremisesInstanceError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::RegisterOnPremisesInstanceError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => {
            return Err(crate::error::RegisterOnPremisesInstanceError::unhandled(
                generic,
            ))
        }
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "IamArnRequiredException" => crate::error::RegisterOnPremisesInstanceError { meta: generic, kind: crate::error::RegisterOnPremisesInstanceErrorKind::IamArnRequiredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::iam_arn_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_iam_arn_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RegisterOnPremisesInstanceError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "IamSessionArnAlreadyRegisteredException" => crate::error::RegisterOnPremisesInstanceError { meta: generic, kind: crate::error::RegisterOnPremisesInstanceErrorKind::IamSessionArnAlreadyRegisteredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::iam_session_arn_already_registered_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_iam_session_arn_already_registered_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RegisterOnPremisesInstanceError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "IamUserArnAlreadyRegisteredException" => crate::error::RegisterOnPremisesInstanceError { meta: generic, kind: crate::error::RegisterOnPremisesInstanceErrorKind::IamUserArnAlreadyRegisteredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::iam_user_arn_already_registered_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_iam_user_arn_already_registered_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RegisterOnPremisesInstanceError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "IamUserArnRequiredException" => crate::error::RegisterOnPremisesInstanceError { meta: generic, kind: crate::error::RegisterOnPremisesInstanceErrorKind::IamUserArnRequiredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::iam_user_arn_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_iam_user_arn_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RegisterOnPremisesInstanceError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InstanceNameAlreadyRegisteredException" => crate::error::RegisterOnPremisesInstanceError { meta: generic, kind: crate::error::RegisterOnPremisesInstanceErrorKind::InstanceNameAlreadyRegisteredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::instance_name_already_registered_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_instance_name_already_registered_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RegisterOnPremisesInstanceError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InstanceNameRequiredException" => crate::error::RegisterOnPremisesInstanceError { meta: generic, kind: crate::error::RegisterOnPremisesInstanceErrorKind::InstanceNameRequiredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::instance_name_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_instance_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RegisterOnPremisesInstanceError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidIamSessionArnException" => crate::error::RegisterOnPremisesInstanceError { meta: generic, kind: crate::error::RegisterOnPremisesInstanceErrorKind::InvalidIamSessionArnException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_iam_session_arn_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_iam_session_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RegisterOnPremisesInstanceError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidIamUserArnException" => crate::error::RegisterOnPremisesInstanceError { meta: generic, kind: crate::error::RegisterOnPremisesInstanceErrorKind::InvalidIamUserArnException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_iam_user_arn_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_iam_user_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RegisterOnPremisesInstanceError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidInstanceNameException" => crate::error::RegisterOnPremisesInstanceError { meta: generic, kind: crate::error::RegisterOnPremisesInstanceErrorKind::InvalidInstanceNameException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_instance_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_instance_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RegisterOnPremisesInstanceError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "MultipleIamArnsProvidedException" => crate::error::RegisterOnPremisesInstanceError { meta: generic, kind: crate::error::RegisterOnPremisesInstanceErrorKind::MultipleIamArnsProvidedException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::multiple_iam_arns_provided_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_multiple_iam_arns_provided_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RegisterOnPremisesInstanceError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        _ => crate::error::RegisterOnPremisesInstanceError::generic(generic)
    })
}

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

#[allow(clippy::unnecessary_wraps)]
pub fn parse_remove_tags_from_on_premises_instances_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::RemoveTagsFromOnPremisesInstancesOutput,
    crate::error::RemoveTagsFromOnPremisesInstancesError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::RemoveTagsFromOnPremisesInstancesError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => {
            return Err(crate::error::RemoveTagsFromOnPremisesInstancesError::unhandled(generic))
        }
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "InstanceLimitExceededException" => crate::error::RemoveTagsFromOnPremisesInstancesError { meta: generic, kind: crate::error::RemoveTagsFromOnPremisesInstancesErrorKind::InstanceLimitExceededException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::instance_limit_exceeded_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_instance_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RemoveTagsFromOnPremisesInstancesError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InstanceNameRequiredException" => crate::error::RemoveTagsFromOnPremisesInstancesError { meta: generic, kind: crate::error::RemoveTagsFromOnPremisesInstancesErrorKind::InstanceNameRequiredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::instance_name_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_instance_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RemoveTagsFromOnPremisesInstancesError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InstanceNotRegisteredException" => crate::error::RemoveTagsFromOnPremisesInstancesError { meta: generic, kind: crate::error::RemoveTagsFromOnPremisesInstancesErrorKind::InstanceNotRegisteredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::instance_not_registered_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_instance_not_registered_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RemoveTagsFromOnPremisesInstancesError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidInstanceNameException" => crate::error::RemoveTagsFromOnPremisesInstancesError { meta: generic, kind: crate::error::RemoveTagsFromOnPremisesInstancesErrorKind::InvalidInstanceNameException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_instance_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_instance_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RemoveTagsFromOnPremisesInstancesError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidTagException" => crate::error::RemoveTagsFromOnPremisesInstancesError { meta: generic, kind: crate::error::RemoveTagsFromOnPremisesInstancesErrorKind::InvalidTagException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_tag_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_tag_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RemoveTagsFromOnPremisesInstancesError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "TagLimitExceededException" => crate::error::RemoveTagsFromOnPremisesInstancesError { meta: generic, kind: crate::error::RemoveTagsFromOnPremisesInstancesErrorKind::TagLimitExceededException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::tag_limit_exceeded_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_tag_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RemoveTagsFromOnPremisesInstancesError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "TagRequiredException" => crate::error::RemoveTagsFromOnPremisesInstancesError { meta: generic, kind: crate::error::RemoveTagsFromOnPremisesInstancesErrorKind::TagRequiredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::tag_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_tag_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RemoveTagsFromOnPremisesInstancesError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        _ => crate::error::RemoveTagsFromOnPremisesInstancesError::generic(generic)
    })
}

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

#[allow(clippy::unnecessary_wraps)]
pub fn parse_skip_wait_time_for_instance_termination_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::SkipWaitTimeForInstanceTerminationOutput,
    crate::error::SkipWaitTimeForInstanceTerminationError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::SkipWaitTimeForInstanceTerminationError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => {
            return Err(crate::error::SkipWaitTimeForInstanceTerminationError::unhandled(generic))
        }
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "DeploymentAlreadyCompletedException" => crate::error::SkipWaitTimeForInstanceTerminationError { meta: generic, kind: crate::error::SkipWaitTimeForInstanceTerminationErrorKind::DeploymentAlreadyCompletedException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_already_completed_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_already_completed_exception_json_err(response.body().as_ref(), output).map_err(crate::error::SkipWaitTimeForInstanceTerminationError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentDoesNotExistException" => crate::error::SkipWaitTimeForInstanceTerminationError { meta: generic, kind: crate::error::SkipWaitTimeForInstanceTerminationErrorKind::DeploymentDoesNotExistException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::SkipWaitTimeForInstanceTerminationError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentIdRequiredException" => crate::error::SkipWaitTimeForInstanceTerminationError { meta: generic, kind: crate::error::SkipWaitTimeForInstanceTerminationErrorKind::DeploymentIdRequiredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_id_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_id_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::SkipWaitTimeForInstanceTerminationError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentNotStartedException" => crate::error::SkipWaitTimeForInstanceTerminationError { meta: generic, kind: crate::error::SkipWaitTimeForInstanceTerminationErrorKind::DeploymentNotStartedException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_not_started_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_not_started_exception_json_err(response.body().as_ref(), output).map_err(crate::error::SkipWaitTimeForInstanceTerminationError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidDeploymentIdException" => crate::error::SkipWaitTimeForInstanceTerminationError { meta: generic, kind: crate::error::SkipWaitTimeForInstanceTerminationErrorKind::InvalidDeploymentIdException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_deployment_id_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_id_exception_json_err(response.body().as_ref(), output).map_err(crate::error::SkipWaitTimeForInstanceTerminationError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "UnsupportedActionForDeploymentTypeException" => crate::error::SkipWaitTimeForInstanceTerminationError { meta: generic, kind: crate::error::SkipWaitTimeForInstanceTerminationErrorKind::UnsupportedActionForDeploymentTypeException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::unsupported_action_for_deployment_type_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_unsupported_action_for_deployment_type_exception_json_err(response.body().as_ref(), output).map_err(crate::error::SkipWaitTimeForInstanceTerminationError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        _ => crate::error::SkipWaitTimeForInstanceTerminationError::generic(generic)
    })
}

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

#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_deployment_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StopDeploymentOutput, crate::error::StopDeploymentError> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::StopDeploymentError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => return Err(crate::error::StopDeploymentError::unhandled(generic)),
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "DeploymentAlreadyCompletedException" => crate::error::StopDeploymentError {
            meta: generic,
            kind: crate::error::StopDeploymentErrorKind::DeploymentAlreadyCompletedException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::deployment_already_completed_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_already_completed_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopDeploymentError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "DeploymentDoesNotExistException" => crate::error::StopDeploymentError {
            meta: generic,
            kind: crate::error::StopDeploymentErrorKind::DeploymentDoesNotExistException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::deployment_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopDeploymentError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "DeploymentGroupDoesNotExistException" => crate::error::StopDeploymentError {
            meta: generic,
            kind: crate::error::StopDeploymentErrorKind::DeploymentGroupDoesNotExistException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::deployment_group_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_group_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopDeploymentError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "DeploymentIdRequiredException" => crate::error::StopDeploymentError {
            meta: generic,
            kind: crate::error::StopDeploymentErrorKind::DeploymentIdRequiredException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::deployment_id_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_id_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopDeploymentError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidDeploymentIdException" => crate::error::StopDeploymentError {
            meta: generic,
            kind: crate::error::StopDeploymentErrorKind::InvalidDeploymentIdException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_deployment_id_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_id_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopDeploymentError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "UnsupportedActionForDeploymentTypeException" => crate::error::StopDeploymentError {
            meta: generic,
            kind:
                crate::error::StopDeploymentErrorKind::UnsupportedActionForDeploymentTypeException(
                    {
                        #[allow(unused_mut)]
                        let mut tmp = {
                            #[allow(unused_mut)]let mut output = crate::error::unsupported_action_for_deployment_type_exception::Builder::default();
                            let _ = response;
                            output = crate::json_deser::deser_structure_crate_error_unsupported_action_for_deployment_type_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopDeploymentError::unhandled)?;
                            output.build()
                        };
                        if (&tmp.message).is_none() {
                            tmp.message = _error_message;
                        }
                        tmp
                    },
                ),
        },
        _ => crate::error::StopDeploymentError::generic(generic),
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_deployment_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StopDeploymentOutput, crate::error::StopDeploymentError> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::stop_deployment_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_stop_deployment(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::StopDeploymentError::unhandled)?;
        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 {
        "ApplicationDoesNotExistException" => crate::error::TagResourceError {
            meta: generic,
            kind: crate::error::TagResourceErrorKind::ApplicationDoesNotExistException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::application_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_does_not_exist_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
            }),
        },
        "ArnNotSupportedException" => crate::error::TagResourceError {
            meta: generic,
            kind: crate::error::TagResourceErrorKind::ArnNotSupportedException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output = crate::error::arn_not_supported_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_arn_not_supported_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
            }),
        },
        "DeploymentConfigDoesNotExistException" => {
            crate::error::TagResourceError {
                meta: generic,
                kind: crate::error::TagResourceErrorKind::DeploymentConfigDoesNotExistException({
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]let mut output = crate::error::deployment_config_does_not_exist_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_deployment_config_does_not_exist_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
                }),
            }
        }
        "DeploymentGroupDoesNotExistException" => {
            crate::error::TagResourceError {
                meta: generic,
                kind: crate::error::TagResourceErrorKind::DeploymentGroupDoesNotExistException({
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]let mut output = crate::error::deployment_group_does_not_exist_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_deployment_group_does_not_exist_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
                }),
            }
        }
        "InvalidArnException" => crate::error::TagResourceError {
            meta: generic,
            kind: crate::error::TagResourceErrorKind::InvalidArnException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output = crate::error::invalid_arn_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_arn_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
            }),
        },
        "InvalidTagsToAddException" => crate::error::TagResourceError {
            meta: generic,
            kind: crate::error::TagResourceErrorKind::InvalidTagsToAddException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_tags_to_add_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_tags_to_add_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
            }),
        },
        "ResourceArnRequiredException" => crate::error::TagResourceError {
            meta: generic,
            kind: crate::error::TagResourceErrorKind::ResourceArnRequiredException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::resource_arn_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_resource_arn_required_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
            }),
        },
        "TagRequiredException" => crate::error::TagResourceError {
            meta: generic,
            kind: crate::error::TagResourceErrorKind::TagRequiredException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output = crate::error::tag_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_tag_required_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 {
        "ApplicationDoesNotExistException" => crate::error::UntagResourceError {
            meta: generic,
            kind: crate::error::UntagResourceErrorKind::ApplicationDoesNotExistException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::application_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_does_not_exist_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
            }),
        },
        "ArnNotSupportedException" => crate::error::UntagResourceError {
            meta: generic,
            kind: crate::error::UntagResourceErrorKind::ArnNotSupportedException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output = crate::error::arn_not_supported_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_arn_not_supported_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
            }),
        },
        "DeploymentConfigDoesNotExistException" => crate::error::UntagResourceError {
            meta: generic,
            kind: crate::error::UntagResourceErrorKind::DeploymentConfigDoesNotExistException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::deployment_config_does_not_exist_exception::Builder::default(
                        );
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_config_does_not_exist_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
            }),
        },
        "DeploymentGroupDoesNotExistException" => {
            crate::error::UntagResourceError {
                meta: generic,
                kind: crate::error::UntagResourceErrorKind::DeploymentGroupDoesNotExistException({
                    #[allow(unused_mut)]
                    let mut tmp = {
                        #[allow(unused_mut)]let mut output = crate::error::deployment_group_does_not_exist_exception::Builder::default();
                        let _ = response;
                        output = crate::json_deser::deser_structure_crate_error_deployment_group_does_not_exist_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
                }),
            }
        }
        "InvalidArnException" => crate::error::UntagResourceError {
            meta: generic,
            kind: crate::error::UntagResourceErrorKind::InvalidArnException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output = crate::error::invalid_arn_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_arn_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
            }),
        },
        "InvalidTagsToAddException" => crate::error::UntagResourceError {
            meta: generic,
            kind: crate::error::UntagResourceErrorKind::InvalidTagsToAddException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_tags_to_add_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_tags_to_add_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
            }),
        },
        "ResourceArnRequiredException" => crate::error::UntagResourceError {
            meta: generic,
            kind: crate::error::UntagResourceErrorKind::ResourceArnRequiredException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::resource_arn_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_resource_arn_required_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
            }),
        },
        "TagRequiredException" => crate::error::UntagResourceError {
            meta: generic,
            kind: crate::error::UntagResourceErrorKind::TagRequiredException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output = crate::error::tag_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_tag_required_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_application_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateApplicationOutput, crate::error::UpdateApplicationError>
{
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::UpdateApplicationError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => return Err(crate::error::UpdateApplicationError::unhandled(generic)),
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "ApplicationAlreadyExistsException" => crate::error::UpdateApplicationError {
            meta: generic,
            kind: crate::error::UpdateApplicationErrorKind::ApplicationAlreadyExistsException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::application_already_exists_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateApplicationError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "ApplicationDoesNotExistException" => crate::error::UpdateApplicationError {
            meta: generic,
            kind: crate::error::UpdateApplicationErrorKind::ApplicationDoesNotExistException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::application_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateApplicationError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "ApplicationNameRequiredException" => crate::error::UpdateApplicationError {
            meta: generic,
            kind: crate::error::UpdateApplicationErrorKind::ApplicationNameRequiredException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::application_name_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateApplicationError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        "InvalidApplicationNameException" => crate::error::UpdateApplicationError {
            meta: generic,
            kind: crate::error::UpdateApplicationErrorKind::InvalidApplicationNameException({
                #[allow(unused_mut)]
                let mut tmp = {
                    #[allow(unused_mut)]
                    let mut output =
                        crate::error::invalid_application_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_application_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateApplicationError::unhandled)?;
                    output.build()
                };
                if (&tmp.message).is_none() {
                    tmp.message = _error_message;
                }
                tmp
            }),
        },
        _ => crate::error::UpdateApplicationError::generic(generic),
    })
}

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

#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_deployment_group_error(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::UpdateDeploymentGroupOutput,
    crate::error::UpdateDeploymentGroupError,
> {
    let generic = crate::json_deser::parse_http_generic_error(response)
        .map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
    let error_code = match generic.code() {
        Some(code) => code,
        None => return Err(crate::error::UpdateDeploymentGroupError::unhandled(generic)),
    };

    let _error_message = generic.message().map(|msg| msg.to_owned());
    Err(match error_code {
        "AlarmsLimitExceededException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::AlarmsLimitExceededException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::alarms_limit_exceeded_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_alarms_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "ApplicationDoesNotExistException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::ApplicationDoesNotExistException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::application_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "ApplicationNameRequiredException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::ApplicationNameRequiredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::application_name_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_application_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentConfigDoesNotExistException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::DeploymentConfigDoesNotExistException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_config_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_config_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentGroupAlreadyExistsException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::DeploymentGroupAlreadyExistsException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_group_already_exists_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_group_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentGroupDoesNotExistException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::DeploymentGroupDoesNotExistException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_group_does_not_exist_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_group_does_not_exist_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "DeploymentGroupNameRequiredException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::DeploymentGroupNameRequiredException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::deployment_group_name_required_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_deployment_group_name_required_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "ECSServiceMappingLimitExceededException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::EcsServiceMappingLimitExceededException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::ecs_service_mapping_limit_exceeded_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_ecs_service_mapping_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidAlarmConfigException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::InvalidAlarmConfigException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_alarm_config_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_alarm_config_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidApplicationNameException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::InvalidApplicationNameException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_application_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_application_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidAutoRollbackConfigException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::InvalidAutoRollbackConfigException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_auto_rollback_config_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_auto_rollback_config_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidAutoScalingGroupException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::InvalidAutoScalingGroupException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_auto_scaling_group_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_auto_scaling_group_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidBlueGreenDeploymentConfigurationException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::InvalidBlueGreenDeploymentConfigurationException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_blue_green_deployment_configuration_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_blue_green_deployment_configuration_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidDeploymentConfigNameException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::InvalidDeploymentConfigNameException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_deployment_config_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_config_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidDeploymentGroupNameException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::InvalidDeploymentGroupNameException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_deployment_group_name_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_group_name_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidDeploymentStyleException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::InvalidDeploymentStyleException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_deployment_style_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_deployment_style_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidEC2TagCombinationException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::InvalidEc2TagCombinationException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_ec2_tag_combination_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_ec2_tag_combination_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidEC2TagException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::InvalidEc2TagException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_ec2_tag_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_ec2_tag_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidECSServiceException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::InvalidEcsServiceException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_ecs_service_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_ecs_service_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidInputException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::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::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidLoadBalancerInfoException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::InvalidLoadBalancerInfoException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_load_balancer_info_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_load_balancer_info_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidOnPremisesTagCombinationException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::InvalidOnPremisesTagCombinationException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_on_premises_tag_combination_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_on_premises_tag_combination_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidRoleException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::InvalidRoleException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_role_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_role_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidTagException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::InvalidTagException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_tag_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_tag_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidTargetGroupPairException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::InvalidTargetGroupPairException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_target_group_pair_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_target_group_pair_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidTrafficRoutingConfigurationException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::InvalidTrafficRoutingConfigurationException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_traffic_routing_configuration_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_traffic_routing_configuration_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "InvalidTriggerConfigException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::InvalidTriggerConfigException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::invalid_trigger_config_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_invalid_trigger_config_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "LifecycleHookLimitExceededException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::LifecycleHookLimitExceededException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::lifecycle_hook_limit_exceeded_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_lifecycle_hook_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "TagSetListLimitExceededException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::TagSetListLimitExceededException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::tag_set_list_limit_exceeded_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_tag_set_list_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "ThrottlingException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::ThrottlingException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::throttling_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_throttling_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        "TriggerTargetsLimitExceededException" => crate::error::UpdateDeploymentGroupError { meta: generic, kind: crate::error::UpdateDeploymentGroupErrorKind::TriggerTargetsLimitExceededException({
            #[allow(unused_mut)]let mut tmp =
                 {
                    #[allow(unused_mut)]let mut output = crate::error::trigger_targets_limit_exceeded_exception::Builder::default();
                    let _ = response;
                    output = crate::json_deser::deser_structure_crate_error_trigger_targets_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
                    output.build()
                }
            ;
            if (&tmp.message).is_none() {
                                                        tmp.message = _error_message;
                                                    }
            tmp
        })},
        _ => crate::error::UpdateDeploymentGroupError::generic(generic)
    })
}

#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_deployment_group_response(
    response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
    crate::output::UpdateDeploymentGroupOutput,
    crate::error::UpdateDeploymentGroupError,
> {
    Ok({
        #[allow(unused_mut)]
        let mut output = crate::output::update_deployment_group_output::Builder::default();
        let _ = response;
        output = crate::json_deser::deser_operation_crate_operation_update_deployment_group(
            response.body().as_ref(),
            output,
        )
        .map_err(crate::error::UpdateDeploymentGroupError::unhandled)?;
        output.build()
    })
}