aws-sdk-m2 0.24.0

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
/// Operation shape for `CancelBatchJobExecution`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`cancel_batch_job_execution`](crate::client::Client::cancel_batch_job_execution).
///
/// See [`crate::client::fluent_builders::CancelBatchJobExecution`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CancelBatchJobExecution {
    _private: (),
}
impl CancelBatchJobExecution {
    /// Creates a new builder-style object to manufacture [`CancelBatchJobExecutionInput`](crate::input::CancelBatchJobExecutionInput).
    pub fn builder() -> crate::input::cancel_batch_job_execution_input::Builder {
        crate::input::cancel_batch_job_execution_input::Builder::default()
    }
    /// Creates a new `CancelBatchJobExecution` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CancelBatchJobExecution {
    type Output = std::result::Result<
        crate::output::CancelBatchJobExecutionOutput,
        crate::error::CancelBatchJobExecutionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_cancel_batch_job_execution_error(response)
        } else {
            crate::operation_deser::parse_cancel_batch_job_execution_response(response)
        }
    }
}

/// Operation shape for `CreateApplication`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_application`](crate::client::Client::create_application).
///
/// See [`crate::client::fluent_builders::CreateApplication`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateApplication {
    _private: (),
}
impl CreateApplication {
    /// Creates a new builder-style object to manufacture [`CreateApplicationInput`](crate::input::CreateApplicationInput).
    pub fn builder() -> crate::input::create_application_input::Builder {
        crate::input::create_application_input::Builder::default()
    }
    /// Creates a new `CreateApplication` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateApplication {
    type Output = std::result::Result<
        crate::output::CreateApplicationOutput,
        crate::error::CreateApplicationError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_application_error(response)
        } else {
            crate::operation_deser::parse_create_application_response(response)
        }
    }
}

/// Operation shape for `CreateDataSetImportTask`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_data_set_import_task`](crate::client::Client::create_data_set_import_task).
///
/// See [`crate::client::fluent_builders::CreateDataSetImportTask`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateDataSetImportTask {
    _private: (),
}
impl CreateDataSetImportTask {
    /// Creates a new builder-style object to manufacture [`CreateDataSetImportTaskInput`](crate::input::CreateDataSetImportTaskInput).
    pub fn builder() -> crate::input::create_data_set_import_task_input::Builder {
        crate::input::create_data_set_import_task_input::Builder::default()
    }
    /// Creates a new `CreateDataSetImportTask` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateDataSetImportTask {
    type Output = std::result::Result<
        crate::output::CreateDataSetImportTaskOutput,
        crate::error::CreateDataSetImportTaskError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_data_set_import_task_error(response)
        } else {
            crate::operation_deser::parse_create_data_set_import_task_response(response)
        }
    }
}

/// Operation shape for `CreateDeployment`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_deployment`](crate::client::Client::create_deployment).
///
/// See [`crate::client::fluent_builders::CreateDeployment`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateDeployment {
    _private: (),
}
impl CreateDeployment {
    /// Creates a new builder-style object to manufacture [`CreateDeploymentInput`](crate::input::CreateDeploymentInput).
    pub fn builder() -> crate::input::create_deployment_input::Builder {
        crate::input::create_deployment_input::Builder::default()
    }
    /// Creates a new `CreateDeployment` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateDeployment {
    type Output = std::result::Result<
        crate::output::CreateDeploymentOutput,
        crate::error::CreateDeploymentError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_deployment_error(response)
        } else {
            crate::operation_deser::parse_create_deployment_response(response)
        }
    }
}

/// Operation shape for `CreateEnvironment`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_environment`](crate::client::Client::create_environment).
///
/// See [`crate::client::fluent_builders::CreateEnvironment`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateEnvironment {
    _private: (),
}
impl CreateEnvironment {
    /// Creates a new builder-style object to manufacture [`CreateEnvironmentInput`](crate::input::CreateEnvironmentInput).
    pub fn builder() -> crate::input::create_environment_input::Builder {
        crate::input::create_environment_input::Builder::default()
    }
    /// Creates a new `CreateEnvironment` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateEnvironment {
    type Output = std::result::Result<
        crate::output::CreateEnvironmentOutput,
        crate::error::CreateEnvironmentError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_environment_error(response)
        } else {
            crate::operation_deser::parse_create_environment_response(response)
        }
    }
}

/// Operation shape for `DeleteApplication`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_application`](crate::client::Client::delete_application).
///
/// See [`crate::client::fluent_builders::DeleteApplication`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteApplication {
    _private: (),
}
impl DeleteApplication {
    /// Creates a new builder-style object to manufacture [`DeleteApplicationInput`](crate::input::DeleteApplicationInput).
    pub fn builder() -> crate::input::delete_application_input::Builder {
        crate::input::delete_application_input::Builder::default()
    }
    /// Creates a new `DeleteApplication` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteApplication {
    type Output = std::result::Result<
        crate::output::DeleteApplicationOutput,
        crate::error::DeleteApplicationError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_application_error(response)
        } else {
            crate::operation_deser::parse_delete_application_response(response)
        }
    }
}

/// Operation shape for `DeleteApplicationFromEnvironment`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_application_from_environment`](crate::client::Client::delete_application_from_environment).
///
/// See [`crate::client::fluent_builders::DeleteApplicationFromEnvironment`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteApplicationFromEnvironment {
    _private: (),
}
impl DeleteApplicationFromEnvironment {
    /// Creates a new builder-style object to manufacture [`DeleteApplicationFromEnvironmentInput`](crate::input::DeleteApplicationFromEnvironmentInput).
    pub fn builder() -> crate::input::delete_application_from_environment_input::Builder {
        crate::input::delete_application_from_environment_input::Builder::default()
    }
    /// Creates a new `DeleteApplicationFromEnvironment` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteApplicationFromEnvironment {
    type Output = std::result::Result<
        crate::output::DeleteApplicationFromEnvironmentOutput,
        crate::error::DeleteApplicationFromEnvironmentError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_application_from_environment_error(response)
        } else {
            crate::operation_deser::parse_delete_application_from_environment_response(response)
        }
    }
}

/// Operation shape for `DeleteEnvironment`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_environment`](crate::client::Client::delete_environment).
///
/// See [`crate::client::fluent_builders::DeleteEnvironment`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteEnvironment {
    _private: (),
}
impl DeleteEnvironment {
    /// Creates a new builder-style object to manufacture [`DeleteEnvironmentInput`](crate::input::DeleteEnvironmentInput).
    pub fn builder() -> crate::input::delete_environment_input::Builder {
        crate::input::delete_environment_input::Builder::default()
    }
    /// Creates a new `DeleteEnvironment` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteEnvironment {
    type Output = std::result::Result<
        crate::output::DeleteEnvironmentOutput,
        crate::error::DeleteEnvironmentError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_environment_error(response)
        } else {
            crate::operation_deser::parse_delete_environment_response(response)
        }
    }
}

/// Operation shape for `GetApplication`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_application`](crate::client::Client::get_application).
///
/// See [`crate::client::fluent_builders::GetApplication`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetApplication {
    _private: (),
}
impl GetApplication {
    /// Creates a new builder-style object to manufacture [`GetApplicationInput`](crate::input::GetApplicationInput).
    pub fn builder() -> crate::input::get_application_input::Builder {
        crate::input::get_application_input::Builder::default()
    }
    /// Creates a new `GetApplication` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetApplication {
    type Output =
        std::result::Result<crate::output::GetApplicationOutput, crate::error::GetApplicationError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_application_error(response)
        } else {
            crate::operation_deser::parse_get_application_response(response)
        }
    }
}

/// Operation shape for `GetApplicationVersion`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_application_version`](crate::client::Client::get_application_version).
///
/// See [`crate::client::fluent_builders::GetApplicationVersion`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetApplicationVersion {
    _private: (),
}
impl GetApplicationVersion {
    /// Creates a new builder-style object to manufacture [`GetApplicationVersionInput`](crate::input::GetApplicationVersionInput).
    pub fn builder() -> crate::input::get_application_version_input::Builder {
        crate::input::get_application_version_input::Builder::default()
    }
    /// Creates a new `GetApplicationVersion` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetApplicationVersion {
    type Output = std::result::Result<
        crate::output::GetApplicationVersionOutput,
        crate::error::GetApplicationVersionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_application_version_error(response)
        } else {
            crate::operation_deser::parse_get_application_version_response(response)
        }
    }
}

/// Operation shape for `GetBatchJobExecution`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_batch_job_execution`](crate::client::Client::get_batch_job_execution).
///
/// See [`crate::client::fluent_builders::GetBatchJobExecution`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetBatchJobExecution {
    _private: (),
}
impl GetBatchJobExecution {
    /// Creates a new builder-style object to manufacture [`GetBatchJobExecutionInput`](crate::input::GetBatchJobExecutionInput).
    pub fn builder() -> crate::input::get_batch_job_execution_input::Builder {
        crate::input::get_batch_job_execution_input::Builder::default()
    }
    /// Creates a new `GetBatchJobExecution` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetBatchJobExecution {
    type Output = std::result::Result<
        crate::output::GetBatchJobExecutionOutput,
        crate::error::GetBatchJobExecutionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_batch_job_execution_error(response)
        } else {
            crate::operation_deser::parse_get_batch_job_execution_response(response)
        }
    }
}

/// Operation shape for `GetDataSetDetails`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_data_set_details`](crate::client::Client::get_data_set_details).
///
/// See [`crate::client::fluent_builders::GetDataSetDetails`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetDataSetDetails {
    _private: (),
}
impl GetDataSetDetails {
    /// Creates a new builder-style object to manufacture [`GetDataSetDetailsInput`](crate::input::GetDataSetDetailsInput).
    pub fn builder() -> crate::input::get_data_set_details_input::Builder {
        crate::input::get_data_set_details_input::Builder::default()
    }
    /// Creates a new `GetDataSetDetails` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetDataSetDetails {
    type Output = std::result::Result<
        crate::output::GetDataSetDetailsOutput,
        crate::error::GetDataSetDetailsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_data_set_details_error(response)
        } else {
            crate::operation_deser::parse_get_data_set_details_response(response)
        }
    }
}

/// Operation shape for `GetDataSetImportTask`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_data_set_import_task`](crate::client::Client::get_data_set_import_task).
///
/// See [`crate::client::fluent_builders::GetDataSetImportTask`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetDataSetImportTask {
    _private: (),
}
impl GetDataSetImportTask {
    /// Creates a new builder-style object to manufacture [`GetDataSetImportTaskInput`](crate::input::GetDataSetImportTaskInput).
    pub fn builder() -> crate::input::get_data_set_import_task_input::Builder {
        crate::input::get_data_set_import_task_input::Builder::default()
    }
    /// Creates a new `GetDataSetImportTask` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetDataSetImportTask {
    type Output = std::result::Result<
        crate::output::GetDataSetImportTaskOutput,
        crate::error::GetDataSetImportTaskError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_data_set_import_task_error(response)
        } else {
            crate::operation_deser::parse_get_data_set_import_task_response(response)
        }
    }
}

/// Operation shape for `GetDeployment`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_deployment`](crate::client::Client::get_deployment).
///
/// See [`crate::client::fluent_builders::GetDeployment`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetDeployment {
    _private: (),
}
impl GetDeployment {
    /// Creates a new builder-style object to manufacture [`GetDeploymentInput`](crate::input::GetDeploymentInput).
    pub fn builder() -> crate::input::get_deployment_input::Builder {
        crate::input::get_deployment_input::Builder::default()
    }
    /// Creates a new `GetDeployment` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetDeployment {
    type Output =
        std::result::Result<crate::output::GetDeploymentOutput, crate::error::GetDeploymentError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_deployment_error(response)
        } else {
            crate::operation_deser::parse_get_deployment_response(response)
        }
    }
}

/// Operation shape for `GetEnvironment`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_environment`](crate::client::Client::get_environment).
///
/// See [`crate::client::fluent_builders::GetEnvironment`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetEnvironment {
    _private: (),
}
impl GetEnvironment {
    /// Creates a new builder-style object to manufacture [`GetEnvironmentInput`](crate::input::GetEnvironmentInput).
    pub fn builder() -> crate::input::get_environment_input::Builder {
        crate::input::get_environment_input::Builder::default()
    }
    /// Creates a new `GetEnvironment` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetEnvironment {
    type Output =
        std::result::Result<crate::output::GetEnvironmentOutput, crate::error::GetEnvironmentError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_environment_error(response)
        } else {
            crate::operation_deser::parse_get_environment_response(response)
        }
    }
}

/// Operation shape for `ListApplications`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_applications`](crate::client::Client::list_applications).
///
/// See [`crate::client::fluent_builders::ListApplications`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListApplications {
    _private: (),
}
impl ListApplications {
    /// Creates a new builder-style object to manufacture [`ListApplicationsInput`](crate::input::ListApplicationsInput).
    pub fn builder() -> crate::input::list_applications_input::Builder {
        crate::input::list_applications_input::Builder::default()
    }
    /// Creates a new `ListApplications` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListApplications {
    type Output = std::result::Result<
        crate::output::ListApplicationsOutput,
        crate::error::ListApplicationsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_applications_error(response)
        } else {
            crate::operation_deser::parse_list_applications_response(response)
        }
    }
}

/// Operation shape for `ListApplicationVersions`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_application_versions`](crate::client::Client::list_application_versions).
///
/// See [`crate::client::fluent_builders::ListApplicationVersions`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListApplicationVersions {
    _private: (),
}
impl ListApplicationVersions {
    /// Creates a new builder-style object to manufacture [`ListApplicationVersionsInput`](crate::input::ListApplicationVersionsInput).
    pub fn builder() -> crate::input::list_application_versions_input::Builder {
        crate::input::list_application_versions_input::Builder::default()
    }
    /// Creates a new `ListApplicationVersions` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListApplicationVersions {
    type Output = std::result::Result<
        crate::output::ListApplicationVersionsOutput,
        crate::error::ListApplicationVersionsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_application_versions_error(response)
        } else {
            crate::operation_deser::parse_list_application_versions_response(response)
        }
    }
}

/// Operation shape for `ListBatchJobDefinitions`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_batch_job_definitions`](crate::client::Client::list_batch_job_definitions).
///
/// See [`crate::client::fluent_builders::ListBatchJobDefinitions`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListBatchJobDefinitions {
    _private: (),
}
impl ListBatchJobDefinitions {
    /// Creates a new builder-style object to manufacture [`ListBatchJobDefinitionsInput`](crate::input::ListBatchJobDefinitionsInput).
    pub fn builder() -> crate::input::list_batch_job_definitions_input::Builder {
        crate::input::list_batch_job_definitions_input::Builder::default()
    }
    /// Creates a new `ListBatchJobDefinitions` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListBatchJobDefinitions {
    type Output = std::result::Result<
        crate::output::ListBatchJobDefinitionsOutput,
        crate::error::ListBatchJobDefinitionsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_batch_job_definitions_error(response)
        } else {
            crate::operation_deser::parse_list_batch_job_definitions_response(response)
        }
    }
}

/// Operation shape for `ListBatchJobExecutions`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_batch_job_executions`](crate::client::Client::list_batch_job_executions).
///
/// See [`crate::client::fluent_builders::ListBatchJobExecutions`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListBatchJobExecutions {
    _private: (),
}
impl ListBatchJobExecutions {
    /// Creates a new builder-style object to manufacture [`ListBatchJobExecutionsInput`](crate::input::ListBatchJobExecutionsInput).
    pub fn builder() -> crate::input::list_batch_job_executions_input::Builder {
        crate::input::list_batch_job_executions_input::Builder::default()
    }
    /// Creates a new `ListBatchJobExecutions` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListBatchJobExecutions {
    type Output = std::result::Result<
        crate::output::ListBatchJobExecutionsOutput,
        crate::error::ListBatchJobExecutionsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_batch_job_executions_error(response)
        } else {
            crate::operation_deser::parse_list_batch_job_executions_response(response)
        }
    }
}

/// Operation shape for `ListDataSetImportHistory`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_data_set_import_history`](crate::client::Client::list_data_set_import_history).
///
/// See [`crate::client::fluent_builders::ListDataSetImportHistory`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListDataSetImportHistory {
    _private: (),
}
impl ListDataSetImportHistory {
    /// Creates a new builder-style object to manufacture [`ListDataSetImportHistoryInput`](crate::input::ListDataSetImportHistoryInput).
    pub fn builder() -> crate::input::list_data_set_import_history_input::Builder {
        crate::input::list_data_set_import_history_input::Builder::default()
    }
    /// Creates a new `ListDataSetImportHistory` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListDataSetImportHistory {
    type Output = std::result::Result<
        crate::output::ListDataSetImportHistoryOutput,
        crate::error::ListDataSetImportHistoryError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_data_set_import_history_error(response)
        } else {
            crate::operation_deser::parse_list_data_set_import_history_response(response)
        }
    }
}

/// Operation shape for `ListDataSets`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_data_sets`](crate::client::Client::list_data_sets).
///
/// See [`crate::client::fluent_builders::ListDataSets`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListDataSets {
    _private: (),
}
impl ListDataSets {
    /// Creates a new builder-style object to manufacture [`ListDataSetsInput`](crate::input::ListDataSetsInput).
    pub fn builder() -> crate::input::list_data_sets_input::Builder {
        crate::input::list_data_sets_input::Builder::default()
    }
    /// Creates a new `ListDataSets` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListDataSets {
    type Output =
        std::result::Result<crate::output::ListDataSetsOutput, crate::error::ListDataSetsError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_data_sets_error(response)
        } else {
            crate::operation_deser::parse_list_data_sets_response(response)
        }
    }
}

/// Operation shape for `ListDeployments`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_deployments`](crate::client::Client::list_deployments).
///
/// See [`crate::client::fluent_builders::ListDeployments`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListDeployments {
    _private: (),
}
impl ListDeployments {
    /// Creates a new builder-style object to manufacture [`ListDeploymentsInput`](crate::input::ListDeploymentsInput).
    pub fn builder() -> crate::input::list_deployments_input::Builder {
        crate::input::list_deployments_input::Builder::default()
    }
    /// Creates a new `ListDeployments` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListDeployments {
    type Output = std::result::Result<
        crate::output::ListDeploymentsOutput,
        crate::error::ListDeploymentsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_deployments_error(response)
        } else {
            crate::operation_deser::parse_list_deployments_response(response)
        }
    }
}

/// Operation shape for `ListEngineVersions`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_engine_versions`](crate::client::Client::list_engine_versions).
///
/// See [`crate::client::fluent_builders::ListEngineVersions`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListEngineVersions {
    _private: (),
}
impl ListEngineVersions {
    /// Creates a new builder-style object to manufacture [`ListEngineVersionsInput`](crate::input::ListEngineVersionsInput).
    pub fn builder() -> crate::input::list_engine_versions_input::Builder {
        crate::input::list_engine_versions_input::Builder::default()
    }
    /// Creates a new `ListEngineVersions` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListEngineVersions {
    type Output = std::result::Result<
        crate::output::ListEngineVersionsOutput,
        crate::error::ListEngineVersionsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_engine_versions_error(response)
        } else {
            crate::operation_deser::parse_list_engine_versions_response(response)
        }
    }
}

/// Operation shape for `ListEnvironments`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_environments`](crate::client::Client::list_environments).
///
/// See [`crate::client::fluent_builders::ListEnvironments`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListEnvironments {
    _private: (),
}
impl ListEnvironments {
    /// Creates a new builder-style object to manufacture [`ListEnvironmentsInput`](crate::input::ListEnvironmentsInput).
    pub fn builder() -> crate::input::list_environments_input::Builder {
        crate::input::list_environments_input::Builder::default()
    }
    /// Creates a new `ListEnvironments` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListEnvironments {
    type Output = std::result::Result<
        crate::output::ListEnvironmentsOutput,
        crate::error::ListEnvironmentsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_environments_error(response)
        } else {
            crate::operation_deser::parse_list_environments_response(response)
        }
    }
}

/// Operation shape for `ListTagsForResource`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_tags_for_resource`](crate::client::Client::list_tags_for_resource).
///
/// See [`crate::client::fluent_builders::ListTagsForResource`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListTagsForResource {
    _private: (),
}
impl ListTagsForResource {
    /// Creates a new builder-style object to manufacture [`ListTagsForResourceInput`](crate::input::ListTagsForResourceInput).
    pub fn builder() -> crate::input::list_tags_for_resource_input::Builder {
        crate::input::list_tags_for_resource_input::Builder::default()
    }
    /// Creates a new `ListTagsForResource` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListTagsForResource {
    type Output = std::result::Result<
        crate::output::ListTagsForResourceOutput,
        crate::error::ListTagsForResourceError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_tags_for_resource_error(response)
        } else {
            crate::operation_deser::parse_list_tags_for_resource_response(response)
        }
    }
}

/// Operation shape for `StartApplication`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`start_application`](crate::client::Client::start_application).
///
/// See [`crate::client::fluent_builders::StartApplication`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct StartApplication {
    _private: (),
}
impl StartApplication {
    /// Creates a new builder-style object to manufacture [`StartApplicationInput`](crate::input::StartApplicationInput).
    pub fn builder() -> crate::input::start_application_input::Builder {
        crate::input::start_application_input::Builder::default()
    }
    /// Creates a new `StartApplication` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for StartApplication {
    type Output = std::result::Result<
        crate::output::StartApplicationOutput,
        crate::error::StartApplicationError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_start_application_error(response)
        } else {
            crate::operation_deser::parse_start_application_response(response)
        }
    }
}

/// Operation shape for `StartBatchJob`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`start_batch_job`](crate::client::Client::start_batch_job).
///
/// See [`crate::client::fluent_builders::StartBatchJob`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct StartBatchJob {
    _private: (),
}
impl StartBatchJob {
    /// Creates a new builder-style object to manufacture [`StartBatchJobInput`](crate::input::StartBatchJobInput).
    pub fn builder() -> crate::input::start_batch_job_input::Builder {
        crate::input::start_batch_job_input::Builder::default()
    }
    /// Creates a new `StartBatchJob` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for StartBatchJob {
    type Output =
        std::result::Result<crate::output::StartBatchJobOutput, crate::error::StartBatchJobError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_start_batch_job_error(response)
        } else {
            crate::operation_deser::parse_start_batch_job_response(response)
        }
    }
}

/// Operation shape for `StopApplication`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`stop_application`](crate::client::Client::stop_application).
///
/// See [`crate::client::fluent_builders::StopApplication`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct StopApplication {
    _private: (),
}
impl StopApplication {
    /// Creates a new builder-style object to manufacture [`StopApplicationInput`](crate::input::StopApplicationInput).
    pub fn builder() -> crate::input::stop_application_input::Builder {
        crate::input::stop_application_input::Builder::default()
    }
    /// Creates a new `StopApplication` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for StopApplication {
    type Output = std::result::Result<
        crate::output::StopApplicationOutput,
        crate::error::StopApplicationError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_stop_application_error(response)
        } else {
            crate::operation_deser::parse_stop_application_response(response)
        }
    }
}

/// Operation shape for `TagResource`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`tag_resource`](crate::client::Client::tag_resource).
///
/// See [`crate::client::fluent_builders::TagResource`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct TagResource {
    _private: (),
}
impl TagResource {
    /// Creates a new builder-style object to manufacture [`TagResourceInput`](crate::input::TagResourceInput).
    pub fn builder() -> crate::input::tag_resource_input::Builder {
        crate::input::tag_resource_input::Builder::default()
    }
    /// Creates a new `TagResource` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for TagResource {
    type Output =
        std::result::Result<crate::output::TagResourceOutput, crate::error::TagResourceError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_tag_resource_error(response)
        } else {
            crate::operation_deser::parse_tag_resource_response(response)
        }
    }
}

/// Operation shape for `UntagResource`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`untag_resource`](crate::client::Client::untag_resource).
///
/// See [`crate::client::fluent_builders::UntagResource`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UntagResource {
    _private: (),
}
impl UntagResource {
    /// Creates a new builder-style object to manufacture [`UntagResourceInput`](crate::input::UntagResourceInput).
    pub fn builder() -> crate::input::untag_resource_input::Builder {
        crate::input::untag_resource_input::Builder::default()
    }
    /// Creates a new `UntagResource` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UntagResource {
    type Output =
        std::result::Result<crate::output::UntagResourceOutput, crate::error::UntagResourceError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_untag_resource_error(response)
        } else {
            crate::operation_deser::parse_untag_resource_response(response)
        }
    }
}

/// Operation shape for `UpdateApplication`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_application`](crate::client::Client::update_application).
///
/// See [`crate::client::fluent_builders::UpdateApplication`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateApplication {
    _private: (),
}
impl UpdateApplication {
    /// Creates a new builder-style object to manufacture [`UpdateApplicationInput`](crate::input::UpdateApplicationInput).
    pub fn builder() -> crate::input::update_application_input::Builder {
        crate::input::update_application_input::Builder::default()
    }
    /// Creates a new `UpdateApplication` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateApplication {
    type Output = std::result::Result<
        crate::output::UpdateApplicationOutput,
        crate::error::UpdateApplicationError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_application_error(response)
        } else {
            crate::operation_deser::parse_update_application_response(response)
        }
    }
}

/// Operation shape for `UpdateEnvironment`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_environment`](crate::client::Client::update_environment).
///
/// See [`crate::client::fluent_builders::UpdateEnvironment`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateEnvironment {
    _private: (),
}
impl UpdateEnvironment {
    /// Creates a new builder-style object to manufacture [`UpdateEnvironmentInput`](crate::input::UpdateEnvironmentInput).
    pub fn builder() -> crate::input::update_environment_input::Builder {
        crate::input::update_environment_input::Builder::default()
    }
    /// Creates a new `UpdateEnvironment` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateEnvironment {
    type Output = std::result::Result<
        crate::output::UpdateEnvironmentOutput,
        crate::error::UpdateEnvironmentError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_update_environment_error(response)
        } else {
            crate::operation_deser::parse_update_environment_response(response)
        }
    }
}

/// Operation customization and supporting types
pub mod customize;