aws-sdk-forecast 0.24.0

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
/// Operation shape for `CreateAutoPredictor`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_auto_predictor`](crate::client::Client::create_auto_predictor).
///
/// See [`crate::client::fluent_builders::CreateAutoPredictor`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateAutoPredictor {
    _private: (),
}
impl CreateAutoPredictor {
    /// Creates a new builder-style object to manufacture [`CreateAutoPredictorInput`](crate::input::CreateAutoPredictorInput).
    pub fn builder() -> crate::input::create_auto_predictor_input::Builder {
        crate::input::create_auto_predictor_input::Builder::default()
    }
    /// Creates a new `CreateAutoPredictor` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateAutoPredictor {
    type Output = std::result::Result<
        crate::output::CreateAutoPredictorOutput,
        crate::error::CreateAutoPredictorError,
    >;
    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_auto_predictor_error(response)
        } else {
            crate::operation_deser::parse_create_auto_predictor_response(response)
        }
    }
}

/// Operation shape for `CreateDataset`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_dataset`](crate::client::Client::create_dataset).
///
/// See [`crate::client::fluent_builders::CreateDataset`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateDataset {
    _private: (),
}
impl CreateDataset {
    /// Creates a new builder-style object to manufacture [`CreateDatasetInput`](crate::input::CreateDatasetInput).
    pub fn builder() -> crate::input::create_dataset_input::Builder {
        crate::input::create_dataset_input::Builder::default()
    }
    /// Creates a new `CreateDataset` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateDataset {
    type Output =
        std::result::Result<crate::output::CreateDatasetOutput, crate::error::CreateDatasetError>;
    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_dataset_error(response)
        } else {
            crate::operation_deser::parse_create_dataset_response(response)
        }
    }
}

/// Operation shape for `CreateDatasetGroup`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_dataset_group`](crate::client::Client::create_dataset_group).
///
/// See [`crate::client::fluent_builders::CreateDatasetGroup`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateDatasetGroup {
    _private: (),
}
impl CreateDatasetGroup {
    /// Creates a new builder-style object to manufacture [`CreateDatasetGroupInput`](crate::input::CreateDatasetGroupInput).
    pub fn builder() -> crate::input::create_dataset_group_input::Builder {
        crate::input::create_dataset_group_input::Builder::default()
    }
    /// Creates a new `CreateDatasetGroup` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateDatasetGroup {
    type Output = std::result::Result<
        crate::output::CreateDatasetGroupOutput,
        crate::error::CreateDatasetGroupError,
    >;
    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_dataset_group_error(response)
        } else {
            crate::operation_deser::parse_create_dataset_group_response(response)
        }
    }
}

/// Operation shape for `CreateDatasetImportJob`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_dataset_import_job`](crate::client::Client::create_dataset_import_job).
///
/// See [`crate::client::fluent_builders::CreateDatasetImportJob`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateDatasetImportJob {
    _private: (),
}
impl CreateDatasetImportJob {
    /// Creates a new builder-style object to manufacture [`CreateDatasetImportJobInput`](crate::input::CreateDatasetImportJobInput).
    pub fn builder() -> crate::input::create_dataset_import_job_input::Builder {
        crate::input::create_dataset_import_job_input::Builder::default()
    }
    /// Creates a new `CreateDatasetImportJob` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateDatasetImportJob {
    type Output = std::result::Result<
        crate::output::CreateDatasetImportJobOutput,
        crate::error::CreateDatasetImportJobError,
    >;
    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_dataset_import_job_error(response)
        } else {
            crate::operation_deser::parse_create_dataset_import_job_response(response)
        }
    }
}

/// Operation shape for `CreateExplainability`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_explainability`](crate::client::Client::create_explainability).
///
/// See [`crate::client::fluent_builders::CreateExplainability`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateExplainability {
    _private: (),
}
impl CreateExplainability {
    /// Creates a new builder-style object to manufacture [`CreateExplainabilityInput`](crate::input::CreateExplainabilityInput).
    pub fn builder() -> crate::input::create_explainability_input::Builder {
        crate::input::create_explainability_input::Builder::default()
    }
    /// Creates a new `CreateExplainability` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateExplainability {
    type Output = std::result::Result<
        crate::output::CreateExplainabilityOutput,
        crate::error::CreateExplainabilityError,
    >;
    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_explainability_error(response)
        } else {
            crate::operation_deser::parse_create_explainability_response(response)
        }
    }
}

/// Operation shape for `CreateExplainabilityExport`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_explainability_export`](crate::client::Client::create_explainability_export).
///
/// See [`crate::client::fluent_builders::CreateExplainabilityExport`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateExplainabilityExport {
    _private: (),
}
impl CreateExplainabilityExport {
    /// Creates a new builder-style object to manufacture [`CreateExplainabilityExportInput`](crate::input::CreateExplainabilityExportInput).
    pub fn builder() -> crate::input::create_explainability_export_input::Builder {
        crate::input::create_explainability_export_input::Builder::default()
    }
    /// Creates a new `CreateExplainabilityExport` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateExplainabilityExport {
    type Output = std::result::Result<
        crate::output::CreateExplainabilityExportOutput,
        crate::error::CreateExplainabilityExportError,
    >;
    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_explainability_export_error(response)
        } else {
            crate::operation_deser::parse_create_explainability_export_response(response)
        }
    }
}

/// Operation shape for `CreateForecast`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_forecast`](crate::client::Client::create_forecast).
///
/// See [`crate::client::fluent_builders::CreateForecast`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateForecast {
    _private: (),
}
impl CreateForecast {
    /// Creates a new builder-style object to manufacture [`CreateForecastInput`](crate::input::CreateForecastInput).
    pub fn builder() -> crate::input::create_forecast_input::Builder {
        crate::input::create_forecast_input::Builder::default()
    }
    /// Creates a new `CreateForecast` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateForecast {
    type Output =
        std::result::Result<crate::output::CreateForecastOutput, crate::error::CreateForecastError>;
    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_forecast_error(response)
        } else {
            crate::operation_deser::parse_create_forecast_response(response)
        }
    }
}

/// Operation shape for `CreateForecastExportJob`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_forecast_export_job`](crate::client::Client::create_forecast_export_job).
///
/// See [`crate::client::fluent_builders::CreateForecastExportJob`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateForecastExportJob {
    _private: (),
}
impl CreateForecastExportJob {
    /// Creates a new builder-style object to manufacture [`CreateForecastExportJobInput`](crate::input::CreateForecastExportJobInput).
    pub fn builder() -> crate::input::create_forecast_export_job_input::Builder {
        crate::input::create_forecast_export_job_input::Builder::default()
    }
    /// Creates a new `CreateForecastExportJob` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateForecastExportJob {
    type Output = std::result::Result<
        crate::output::CreateForecastExportJobOutput,
        crate::error::CreateForecastExportJobError,
    >;
    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_forecast_export_job_error(response)
        } else {
            crate::operation_deser::parse_create_forecast_export_job_response(response)
        }
    }
}

/// Operation shape for `CreateMonitor`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_monitor`](crate::client::Client::create_monitor).
///
/// See [`crate::client::fluent_builders::CreateMonitor`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateMonitor {
    _private: (),
}
impl CreateMonitor {
    /// Creates a new builder-style object to manufacture [`CreateMonitorInput`](crate::input::CreateMonitorInput).
    pub fn builder() -> crate::input::create_monitor_input::Builder {
        crate::input::create_monitor_input::Builder::default()
    }
    /// Creates a new `CreateMonitor` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateMonitor {
    type Output =
        std::result::Result<crate::output::CreateMonitorOutput, crate::error::CreateMonitorError>;
    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_monitor_error(response)
        } else {
            crate::operation_deser::parse_create_monitor_response(response)
        }
    }
}

/// Operation shape for `CreatePredictor`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_predictor`](crate::client::Client::create_predictor).
///
/// See [`crate::client::fluent_builders::CreatePredictor`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreatePredictor {
    _private: (),
}
impl CreatePredictor {
    /// Creates a new builder-style object to manufacture [`CreatePredictorInput`](crate::input::CreatePredictorInput).
    pub fn builder() -> crate::input::create_predictor_input::Builder {
        crate::input::create_predictor_input::Builder::default()
    }
    /// Creates a new `CreatePredictor` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreatePredictor {
    type Output = std::result::Result<
        crate::output::CreatePredictorOutput,
        crate::error::CreatePredictorError,
    >;
    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_predictor_error(response)
        } else {
            crate::operation_deser::parse_create_predictor_response(response)
        }
    }
}

/// Operation shape for `CreatePredictorBacktestExportJob`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_predictor_backtest_export_job`](crate::client::Client::create_predictor_backtest_export_job).
///
/// See [`crate::client::fluent_builders::CreatePredictorBacktestExportJob`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreatePredictorBacktestExportJob {
    _private: (),
}
impl CreatePredictorBacktestExportJob {
    /// Creates a new builder-style object to manufacture [`CreatePredictorBacktestExportJobInput`](crate::input::CreatePredictorBacktestExportJobInput).
    pub fn builder() -> crate::input::create_predictor_backtest_export_job_input::Builder {
        crate::input::create_predictor_backtest_export_job_input::Builder::default()
    }
    /// Creates a new `CreatePredictorBacktestExportJob` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreatePredictorBacktestExportJob {
    type Output = std::result::Result<
        crate::output::CreatePredictorBacktestExportJobOutput,
        crate::error::CreatePredictorBacktestExportJobError,
    >;
    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_predictor_backtest_export_job_error(response)
        } else {
            crate::operation_deser::parse_create_predictor_backtest_export_job_response(response)
        }
    }
}

/// Operation shape for `CreateWhatIfAnalysis`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_what_if_analysis`](crate::client::Client::create_what_if_analysis).
///
/// See [`crate::client::fluent_builders::CreateWhatIfAnalysis`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateWhatIfAnalysis {
    _private: (),
}
impl CreateWhatIfAnalysis {
    /// Creates a new builder-style object to manufacture [`CreateWhatIfAnalysisInput`](crate::input::CreateWhatIfAnalysisInput).
    pub fn builder() -> crate::input::create_what_if_analysis_input::Builder {
        crate::input::create_what_if_analysis_input::Builder::default()
    }
    /// Creates a new `CreateWhatIfAnalysis` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateWhatIfAnalysis {
    type Output = std::result::Result<
        crate::output::CreateWhatIfAnalysisOutput,
        crate::error::CreateWhatIfAnalysisError,
    >;
    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_what_if_analysis_error(response)
        } else {
            crate::operation_deser::parse_create_what_if_analysis_response(response)
        }
    }
}

/// Operation shape for `CreateWhatIfForecast`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_what_if_forecast`](crate::client::Client::create_what_if_forecast).
///
/// See [`crate::client::fluent_builders::CreateWhatIfForecast`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateWhatIfForecast {
    _private: (),
}
impl CreateWhatIfForecast {
    /// Creates a new builder-style object to manufacture [`CreateWhatIfForecastInput`](crate::input::CreateWhatIfForecastInput).
    pub fn builder() -> crate::input::create_what_if_forecast_input::Builder {
        crate::input::create_what_if_forecast_input::Builder::default()
    }
    /// Creates a new `CreateWhatIfForecast` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateWhatIfForecast {
    type Output = std::result::Result<
        crate::output::CreateWhatIfForecastOutput,
        crate::error::CreateWhatIfForecastError,
    >;
    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_what_if_forecast_error(response)
        } else {
            crate::operation_deser::parse_create_what_if_forecast_response(response)
        }
    }
}

/// Operation shape for `CreateWhatIfForecastExport`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_what_if_forecast_export`](crate::client::Client::create_what_if_forecast_export).
///
/// See [`crate::client::fluent_builders::CreateWhatIfForecastExport`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateWhatIfForecastExport {
    _private: (),
}
impl CreateWhatIfForecastExport {
    /// Creates a new builder-style object to manufacture [`CreateWhatIfForecastExportInput`](crate::input::CreateWhatIfForecastExportInput).
    pub fn builder() -> crate::input::create_what_if_forecast_export_input::Builder {
        crate::input::create_what_if_forecast_export_input::Builder::default()
    }
    /// Creates a new `CreateWhatIfForecastExport` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateWhatIfForecastExport {
    type Output = std::result::Result<
        crate::output::CreateWhatIfForecastExportOutput,
        crate::error::CreateWhatIfForecastExportError,
    >;
    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_what_if_forecast_export_error(response)
        } else {
            crate::operation_deser::parse_create_what_if_forecast_export_response(response)
        }
    }
}

/// Operation shape for `DeleteDataset`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_dataset`](crate::client::Client::delete_dataset).
///
/// See [`crate::client::fluent_builders::DeleteDataset`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteDataset {
    _private: (),
}
impl DeleteDataset {
    /// Creates a new builder-style object to manufacture [`DeleteDatasetInput`](crate::input::DeleteDatasetInput).
    pub fn builder() -> crate::input::delete_dataset_input::Builder {
        crate::input::delete_dataset_input::Builder::default()
    }
    /// Creates a new `DeleteDataset` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteDataset {
    type Output =
        std::result::Result<crate::output::DeleteDatasetOutput, crate::error::DeleteDatasetError>;
    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_dataset_error(response)
        } else {
            crate::operation_deser::parse_delete_dataset_response(response)
        }
    }
}

/// Operation shape for `DeleteDatasetGroup`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_dataset_group`](crate::client::Client::delete_dataset_group).
///
/// See [`crate::client::fluent_builders::DeleteDatasetGroup`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteDatasetGroup {
    _private: (),
}
impl DeleteDatasetGroup {
    /// Creates a new builder-style object to manufacture [`DeleteDatasetGroupInput`](crate::input::DeleteDatasetGroupInput).
    pub fn builder() -> crate::input::delete_dataset_group_input::Builder {
        crate::input::delete_dataset_group_input::Builder::default()
    }
    /// Creates a new `DeleteDatasetGroup` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteDatasetGroup {
    type Output = std::result::Result<
        crate::output::DeleteDatasetGroupOutput,
        crate::error::DeleteDatasetGroupError,
    >;
    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_dataset_group_error(response)
        } else {
            crate::operation_deser::parse_delete_dataset_group_response(response)
        }
    }
}

/// Operation shape for `DeleteDatasetImportJob`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_dataset_import_job`](crate::client::Client::delete_dataset_import_job).
///
/// See [`crate::client::fluent_builders::DeleteDatasetImportJob`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteDatasetImportJob {
    _private: (),
}
impl DeleteDatasetImportJob {
    /// Creates a new builder-style object to manufacture [`DeleteDatasetImportJobInput`](crate::input::DeleteDatasetImportJobInput).
    pub fn builder() -> crate::input::delete_dataset_import_job_input::Builder {
        crate::input::delete_dataset_import_job_input::Builder::default()
    }
    /// Creates a new `DeleteDatasetImportJob` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteDatasetImportJob {
    type Output = std::result::Result<
        crate::output::DeleteDatasetImportJobOutput,
        crate::error::DeleteDatasetImportJobError,
    >;
    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_dataset_import_job_error(response)
        } else {
            crate::operation_deser::parse_delete_dataset_import_job_response(response)
        }
    }
}

/// Operation shape for `DeleteExplainability`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_explainability`](crate::client::Client::delete_explainability).
///
/// See [`crate::client::fluent_builders::DeleteExplainability`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteExplainability {
    _private: (),
}
impl DeleteExplainability {
    /// Creates a new builder-style object to manufacture [`DeleteExplainabilityInput`](crate::input::DeleteExplainabilityInput).
    pub fn builder() -> crate::input::delete_explainability_input::Builder {
        crate::input::delete_explainability_input::Builder::default()
    }
    /// Creates a new `DeleteExplainability` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteExplainability {
    type Output = std::result::Result<
        crate::output::DeleteExplainabilityOutput,
        crate::error::DeleteExplainabilityError,
    >;
    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_explainability_error(response)
        } else {
            crate::operation_deser::parse_delete_explainability_response(response)
        }
    }
}

/// Operation shape for `DeleteExplainabilityExport`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_explainability_export`](crate::client::Client::delete_explainability_export).
///
/// See [`crate::client::fluent_builders::DeleteExplainabilityExport`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteExplainabilityExport {
    _private: (),
}
impl DeleteExplainabilityExport {
    /// Creates a new builder-style object to manufacture [`DeleteExplainabilityExportInput`](crate::input::DeleteExplainabilityExportInput).
    pub fn builder() -> crate::input::delete_explainability_export_input::Builder {
        crate::input::delete_explainability_export_input::Builder::default()
    }
    /// Creates a new `DeleteExplainabilityExport` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteExplainabilityExport {
    type Output = std::result::Result<
        crate::output::DeleteExplainabilityExportOutput,
        crate::error::DeleteExplainabilityExportError,
    >;
    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_explainability_export_error(response)
        } else {
            crate::operation_deser::parse_delete_explainability_export_response(response)
        }
    }
}

/// Operation shape for `DeleteForecast`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_forecast`](crate::client::Client::delete_forecast).
///
/// See [`crate::client::fluent_builders::DeleteForecast`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteForecast {
    _private: (),
}
impl DeleteForecast {
    /// Creates a new builder-style object to manufacture [`DeleteForecastInput`](crate::input::DeleteForecastInput).
    pub fn builder() -> crate::input::delete_forecast_input::Builder {
        crate::input::delete_forecast_input::Builder::default()
    }
    /// Creates a new `DeleteForecast` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteForecast {
    type Output =
        std::result::Result<crate::output::DeleteForecastOutput, crate::error::DeleteForecastError>;
    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_forecast_error(response)
        } else {
            crate::operation_deser::parse_delete_forecast_response(response)
        }
    }
}

/// Operation shape for `DeleteForecastExportJob`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_forecast_export_job`](crate::client::Client::delete_forecast_export_job).
///
/// See [`crate::client::fluent_builders::DeleteForecastExportJob`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteForecastExportJob {
    _private: (),
}
impl DeleteForecastExportJob {
    /// Creates a new builder-style object to manufacture [`DeleteForecastExportJobInput`](crate::input::DeleteForecastExportJobInput).
    pub fn builder() -> crate::input::delete_forecast_export_job_input::Builder {
        crate::input::delete_forecast_export_job_input::Builder::default()
    }
    /// Creates a new `DeleteForecastExportJob` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteForecastExportJob {
    type Output = std::result::Result<
        crate::output::DeleteForecastExportJobOutput,
        crate::error::DeleteForecastExportJobError,
    >;
    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_forecast_export_job_error(response)
        } else {
            crate::operation_deser::parse_delete_forecast_export_job_response(response)
        }
    }
}

/// Operation shape for `DeleteMonitor`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_monitor`](crate::client::Client::delete_monitor).
///
/// See [`crate::client::fluent_builders::DeleteMonitor`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteMonitor {
    _private: (),
}
impl DeleteMonitor {
    /// Creates a new builder-style object to manufacture [`DeleteMonitorInput`](crate::input::DeleteMonitorInput).
    pub fn builder() -> crate::input::delete_monitor_input::Builder {
        crate::input::delete_monitor_input::Builder::default()
    }
    /// Creates a new `DeleteMonitor` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteMonitor {
    type Output =
        std::result::Result<crate::output::DeleteMonitorOutput, crate::error::DeleteMonitorError>;
    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_monitor_error(response)
        } else {
            crate::operation_deser::parse_delete_monitor_response(response)
        }
    }
}

/// Operation shape for `DeletePredictor`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_predictor`](crate::client::Client::delete_predictor).
///
/// See [`crate::client::fluent_builders::DeletePredictor`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeletePredictor {
    _private: (),
}
impl DeletePredictor {
    /// Creates a new builder-style object to manufacture [`DeletePredictorInput`](crate::input::DeletePredictorInput).
    pub fn builder() -> crate::input::delete_predictor_input::Builder {
        crate::input::delete_predictor_input::Builder::default()
    }
    /// Creates a new `DeletePredictor` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeletePredictor {
    type Output = std::result::Result<
        crate::output::DeletePredictorOutput,
        crate::error::DeletePredictorError,
    >;
    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_predictor_error(response)
        } else {
            crate::operation_deser::parse_delete_predictor_response(response)
        }
    }
}

/// Operation shape for `DeletePredictorBacktestExportJob`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_predictor_backtest_export_job`](crate::client::Client::delete_predictor_backtest_export_job).
///
/// See [`crate::client::fluent_builders::DeletePredictorBacktestExportJob`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeletePredictorBacktestExportJob {
    _private: (),
}
impl DeletePredictorBacktestExportJob {
    /// Creates a new builder-style object to manufacture [`DeletePredictorBacktestExportJobInput`](crate::input::DeletePredictorBacktestExportJobInput).
    pub fn builder() -> crate::input::delete_predictor_backtest_export_job_input::Builder {
        crate::input::delete_predictor_backtest_export_job_input::Builder::default()
    }
    /// Creates a new `DeletePredictorBacktestExportJob` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeletePredictorBacktestExportJob {
    type Output = std::result::Result<
        crate::output::DeletePredictorBacktestExportJobOutput,
        crate::error::DeletePredictorBacktestExportJobError,
    >;
    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_predictor_backtest_export_job_error(response)
        } else {
            crate::operation_deser::parse_delete_predictor_backtest_export_job_response(response)
        }
    }
}

/// Operation shape for `DeleteResourceTree`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_resource_tree`](crate::client::Client::delete_resource_tree).
///
/// See [`crate::client::fluent_builders::DeleteResourceTree`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteResourceTree {
    _private: (),
}
impl DeleteResourceTree {
    /// Creates a new builder-style object to manufacture [`DeleteResourceTreeInput`](crate::input::DeleteResourceTreeInput).
    pub fn builder() -> crate::input::delete_resource_tree_input::Builder {
        crate::input::delete_resource_tree_input::Builder::default()
    }
    /// Creates a new `DeleteResourceTree` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteResourceTree {
    type Output = std::result::Result<
        crate::output::DeleteResourceTreeOutput,
        crate::error::DeleteResourceTreeError,
    >;
    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_resource_tree_error(response)
        } else {
            crate::operation_deser::parse_delete_resource_tree_response(response)
        }
    }
}

/// Operation shape for `DeleteWhatIfAnalysis`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_what_if_analysis`](crate::client::Client::delete_what_if_analysis).
///
/// See [`crate::client::fluent_builders::DeleteWhatIfAnalysis`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteWhatIfAnalysis {
    _private: (),
}
impl DeleteWhatIfAnalysis {
    /// Creates a new builder-style object to manufacture [`DeleteWhatIfAnalysisInput`](crate::input::DeleteWhatIfAnalysisInput).
    pub fn builder() -> crate::input::delete_what_if_analysis_input::Builder {
        crate::input::delete_what_if_analysis_input::Builder::default()
    }
    /// Creates a new `DeleteWhatIfAnalysis` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteWhatIfAnalysis {
    type Output = std::result::Result<
        crate::output::DeleteWhatIfAnalysisOutput,
        crate::error::DeleteWhatIfAnalysisError,
    >;
    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_what_if_analysis_error(response)
        } else {
            crate::operation_deser::parse_delete_what_if_analysis_response(response)
        }
    }
}

/// Operation shape for `DeleteWhatIfForecast`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_what_if_forecast`](crate::client::Client::delete_what_if_forecast).
///
/// See [`crate::client::fluent_builders::DeleteWhatIfForecast`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteWhatIfForecast {
    _private: (),
}
impl DeleteWhatIfForecast {
    /// Creates a new builder-style object to manufacture [`DeleteWhatIfForecastInput`](crate::input::DeleteWhatIfForecastInput).
    pub fn builder() -> crate::input::delete_what_if_forecast_input::Builder {
        crate::input::delete_what_if_forecast_input::Builder::default()
    }
    /// Creates a new `DeleteWhatIfForecast` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteWhatIfForecast {
    type Output = std::result::Result<
        crate::output::DeleteWhatIfForecastOutput,
        crate::error::DeleteWhatIfForecastError,
    >;
    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_what_if_forecast_error(response)
        } else {
            crate::operation_deser::parse_delete_what_if_forecast_response(response)
        }
    }
}

/// Operation shape for `DeleteWhatIfForecastExport`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_what_if_forecast_export`](crate::client::Client::delete_what_if_forecast_export).
///
/// See [`crate::client::fluent_builders::DeleteWhatIfForecastExport`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteWhatIfForecastExport {
    _private: (),
}
impl DeleteWhatIfForecastExport {
    /// Creates a new builder-style object to manufacture [`DeleteWhatIfForecastExportInput`](crate::input::DeleteWhatIfForecastExportInput).
    pub fn builder() -> crate::input::delete_what_if_forecast_export_input::Builder {
        crate::input::delete_what_if_forecast_export_input::Builder::default()
    }
    /// Creates a new `DeleteWhatIfForecastExport` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteWhatIfForecastExport {
    type Output = std::result::Result<
        crate::output::DeleteWhatIfForecastExportOutput,
        crate::error::DeleteWhatIfForecastExportError,
    >;
    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_what_if_forecast_export_error(response)
        } else {
            crate::operation_deser::parse_delete_what_if_forecast_export_response(response)
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// Operation shape for `GetAccuracyMetrics`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_accuracy_metrics`](crate::client::Client::get_accuracy_metrics).
///
/// See [`crate::client::fluent_builders::GetAccuracyMetrics`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetAccuracyMetrics {
    _private: (),
}
impl GetAccuracyMetrics {
    /// Creates a new builder-style object to manufacture [`GetAccuracyMetricsInput`](crate::input::GetAccuracyMetricsInput).
    pub fn builder() -> crate::input::get_accuracy_metrics_input::Builder {
        crate::input::get_accuracy_metrics_input::Builder::default()
    }
    /// Creates a new `GetAccuracyMetrics` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for GetAccuracyMetrics {
    type Output = std::result::Result<
        crate::output::GetAccuracyMetricsOutput,
        crate::error::GetAccuracyMetricsError,
    >;
    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_accuracy_metrics_error(response)
        } else {
            crate::operation_deser::parse_get_accuracy_metrics_response(response)
        }
    }
}

/// Operation shape for `ListDatasetGroups`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_dataset_groups`](crate::client::Client::list_dataset_groups).
///
/// See [`crate::client::fluent_builders::ListDatasetGroups`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListDatasetGroups {
    _private: (),
}
impl ListDatasetGroups {
    /// Creates a new builder-style object to manufacture [`ListDatasetGroupsInput`](crate::input::ListDatasetGroupsInput).
    pub fn builder() -> crate::input::list_dataset_groups_input::Builder {
        crate::input::list_dataset_groups_input::Builder::default()
    }
    /// Creates a new `ListDatasetGroups` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListDatasetGroups {
    type Output = std::result::Result<
        crate::output::ListDatasetGroupsOutput,
        crate::error::ListDatasetGroupsError,
    >;
    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_dataset_groups_error(response)
        } else {
            crate::operation_deser::parse_list_dataset_groups_response(response)
        }
    }
}

/// Operation shape for `ListDatasetImportJobs`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_dataset_import_jobs`](crate::client::Client::list_dataset_import_jobs).
///
/// See [`crate::client::fluent_builders::ListDatasetImportJobs`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListDatasetImportJobs {
    _private: (),
}
impl ListDatasetImportJobs {
    /// Creates a new builder-style object to manufacture [`ListDatasetImportJobsInput`](crate::input::ListDatasetImportJobsInput).
    pub fn builder() -> crate::input::list_dataset_import_jobs_input::Builder {
        crate::input::list_dataset_import_jobs_input::Builder::default()
    }
    /// Creates a new `ListDatasetImportJobs` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListDatasetImportJobs {
    type Output = std::result::Result<
        crate::output::ListDatasetImportJobsOutput,
        crate::error::ListDatasetImportJobsError,
    >;
    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_dataset_import_jobs_error(response)
        } else {
            crate::operation_deser::parse_list_dataset_import_jobs_response(response)
        }
    }
}

/// Operation shape for `ListDatasets`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_datasets`](crate::client::Client::list_datasets).
///
/// 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_datasets_input::Builder {
        crate::input::list_datasets_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_datasets_error(response)
        } else {
            crate::operation_deser::parse_list_datasets_response(response)
        }
    }
}

/// Operation shape for `ListExplainabilities`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_explainabilities`](crate::client::Client::list_explainabilities).
///
/// See [`crate::client::fluent_builders::ListExplainabilities`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListExplainabilities {
    _private: (),
}
impl ListExplainabilities {
    /// Creates a new builder-style object to manufacture [`ListExplainabilitiesInput`](crate::input::ListExplainabilitiesInput).
    pub fn builder() -> crate::input::list_explainabilities_input::Builder {
        crate::input::list_explainabilities_input::Builder::default()
    }
    /// Creates a new `ListExplainabilities` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListExplainabilities {
    type Output = std::result::Result<
        crate::output::ListExplainabilitiesOutput,
        crate::error::ListExplainabilitiesError,
    >;
    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_explainabilities_error(response)
        } else {
            crate::operation_deser::parse_list_explainabilities_response(response)
        }
    }
}

/// Operation shape for `ListExplainabilityExports`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_explainability_exports`](crate::client::Client::list_explainability_exports).
///
/// See [`crate::client::fluent_builders::ListExplainabilityExports`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListExplainabilityExports {
    _private: (),
}
impl ListExplainabilityExports {
    /// Creates a new builder-style object to manufacture [`ListExplainabilityExportsInput`](crate::input::ListExplainabilityExportsInput).
    pub fn builder() -> crate::input::list_explainability_exports_input::Builder {
        crate::input::list_explainability_exports_input::Builder::default()
    }
    /// Creates a new `ListExplainabilityExports` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListExplainabilityExports {
    type Output = std::result::Result<
        crate::output::ListExplainabilityExportsOutput,
        crate::error::ListExplainabilityExportsError,
    >;
    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_explainability_exports_error(response)
        } else {
            crate::operation_deser::parse_list_explainability_exports_response(response)
        }
    }
}

/// Operation shape for `ListForecastExportJobs`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_forecast_export_jobs`](crate::client::Client::list_forecast_export_jobs).
///
/// See [`crate::client::fluent_builders::ListForecastExportJobs`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListForecastExportJobs {
    _private: (),
}
impl ListForecastExportJobs {
    /// Creates a new builder-style object to manufacture [`ListForecastExportJobsInput`](crate::input::ListForecastExportJobsInput).
    pub fn builder() -> crate::input::list_forecast_export_jobs_input::Builder {
        crate::input::list_forecast_export_jobs_input::Builder::default()
    }
    /// Creates a new `ListForecastExportJobs` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListForecastExportJobs {
    type Output = std::result::Result<
        crate::output::ListForecastExportJobsOutput,
        crate::error::ListForecastExportJobsError,
    >;
    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_forecast_export_jobs_error(response)
        } else {
            crate::operation_deser::parse_list_forecast_export_jobs_response(response)
        }
    }
}

/// Operation shape for `ListForecasts`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_forecasts`](crate::client::Client::list_forecasts).
///
/// See [`crate::client::fluent_builders::ListForecasts`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListForecasts {
    _private: (),
}
impl ListForecasts {
    /// Creates a new builder-style object to manufacture [`ListForecastsInput`](crate::input::ListForecastsInput).
    pub fn builder() -> crate::input::list_forecasts_input::Builder {
        crate::input::list_forecasts_input::Builder::default()
    }
    /// Creates a new `ListForecasts` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListForecasts {
    type Output =
        std::result::Result<crate::output::ListForecastsOutput, crate::error::ListForecastsError>;
    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_forecasts_error(response)
        } else {
            crate::operation_deser::parse_list_forecasts_response(response)
        }
    }
}

/// Operation shape for `ListMonitorEvaluations`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_monitor_evaluations`](crate::client::Client::list_monitor_evaluations).
///
/// See [`crate::client::fluent_builders::ListMonitorEvaluations`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListMonitorEvaluations {
    _private: (),
}
impl ListMonitorEvaluations {
    /// Creates a new builder-style object to manufacture [`ListMonitorEvaluationsInput`](crate::input::ListMonitorEvaluationsInput).
    pub fn builder() -> crate::input::list_monitor_evaluations_input::Builder {
        crate::input::list_monitor_evaluations_input::Builder::default()
    }
    /// Creates a new `ListMonitorEvaluations` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListMonitorEvaluations {
    type Output = std::result::Result<
        crate::output::ListMonitorEvaluationsOutput,
        crate::error::ListMonitorEvaluationsError,
    >;
    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_monitor_evaluations_error(response)
        } else {
            crate::operation_deser::parse_list_monitor_evaluations_response(response)
        }
    }
}

/// Operation shape for `ListMonitors`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_monitors`](crate::client::Client::list_monitors).
///
/// See [`crate::client::fluent_builders::ListMonitors`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListMonitors {
    _private: (),
}
impl ListMonitors {
    /// Creates a new builder-style object to manufacture [`ListMonitorsInput`](crate::input::ListMonitorsInput).
    pub fn builder() -> crate::input::list_monitors_input::Builder {
        crate::input::list_monitors_input::Builder::default()
    }
    /// Creates a new `ListMonitors` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListMonitors {
    type Output =
        std::result::Result<crate::output::ListMonitorsOutput, crate::error::ListMonitorsError>;
    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_monitors_error(response)
        } else {
            crate::operation_deser::parse_list_monitors_response(response)
        }
    }
}

/// Operation shape for `ListPredictorBacktestExportJobs`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_predictor_backtest_export_jobs`](crate::client::Client::list_predictor_backtest_export_jobs).
///
/// See [`crate::client::fluent_builders::ListPredictorBacktestExportJobs`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListPredictorBacktestExportJobs {
    _private: (),
}
impl ListPredictorBacktestExportJobs {
    /// Creates a new builder-style object to manufacture [`ListPredictorBacktestExportJobsInput`](crate::input::ListPredictorBacktestExportJobsInput).
    pub fn builder() -> crate::input::list_predictor_backtest_export_jobs_input::Builder {
        crate::input::list_predictor_backtest_export_jobs_input::Builder::default()
    }
    /// Creates a new `ListPredictorBacktestExportJobs` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListPredictorBacktestExportJobs {
    type Output = std::result::Result<
        crate::output::ListPredictorBacktestExportJobsOutput,
        crate::error::ListPredictorBacktestExportJobsError,
    >;
    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_predictor_backtest_export_jobs_error(response)
        } else {
            crate::operation_deser::parse_list_predictor_backtest_export_jobs_response(response)
        }
    }
}

/// Operation shape for `ListPredictors`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_predictors`](crate::client::Client::list_predictors).
///
/// See [`crate::client::fluent_builders::ListPredictors`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListPredictors {
    _private: (),
}
impl ListPredictors {
    /// Creates a new builder-style object to manufacture [`ListPredictorsInput`](crate::input::ListPredictorsInput).
    pub fn builder() -> crate::input::list_predictors_input::Builder {
        crate::input::list_predictors_input::Builder::default()
    }
    /// Creates a new `ListPredictors` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListPredictors {
    type Output =
        std::result::Result<crate::output::ListPredictorsOutput, crate::error::ListPredictorsError>;
    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_predictors_error(response)
        } else {
            crate::operation_deser::parse_list_predictors_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 `ListWhatIfAnalyses`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_what_if_analyses`](crate::client::Client::list_what_if_analyses).
///
/// See [`crate::client::fluent_builders::ListWhatIfAnalyses`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListWhatIfAnalyses {
    _private: (),
}
impl ListWhatIfAnalyses {
    /// Creates a new builder-style object to manufacture [`ListWhatIfAnalysesInput`](crate::input::ListWhatIfAnalysesInput).
    pub fn builder() -> crate::input::list_what_if_analyses_input::Builder {
        crate::input::list_what_if_analyses_input::Builder::default()
    }
    /// Creates a new `ListWhatIfAnalyses` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListWhatIfAnalyses {
    type Output = std::result::Result<
        crate::output::ListWhatIfAnalysesOutput,
        crate::error::ListWhatIfAnalysesError,
    >;
    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_what_if_analyses_error(response)
        } else {
            crate::operation_deser::parse_list_what_if_analyses_response(response)
        }
    }
}

/// Operation shape for `ListWhatIfForecastExports`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_what_if_forecast_exports`](crate::client::Client::list_what_if_forecast_exports).
///
/// See [`crate::client::fluent_builders::ListWhatIfForecastExports`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListWhatIfForecastExports {
    _private: (),
}
impl ListWhatIfForecastExports {
    /// Creates a new builder-style object to manufacture [`ListWhatIfForecastExportsInput`](crate::input::ListWhatIfForecastExportsInput).
    pub fn builder() -> crate::input::list_what_if_forecast_exports_input::Builder {
        crate::input::list_what_if_forecast_exports_input::Builder::default()
    }
    /// Creates a new `ListWhatIfForecastExports` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListWhatIfForecastExports {
    type Output = std::result::Result<
        crate::output::ListWhatIfForecastExportsOutput,
        crate::error::ListWhatIfForecastExportsError,
    >;
    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_what_if_forecast_exports_error(response)
        } else {
            crate::operation_deser::parse_list_what_if_forecast_exports_response(response)
        }
    }
}

/// Operation shape for `ListWhatIfForecasts`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_what_if_forecasts`](crate::client::Client::list_what_if_forecasts).
///
/// See [`crate::client::fluent_builders::ListWhatIfForecasts`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListWhatIfForecasts {
    _private: (),
}
impl ListWhatIfForecasts {
    /// Creates a new builder-style object to manufacture [`ListWhatIfForecastsInput`](crate::input::ListWhatIfForecastsInput).
    pub fn builder() -> crate::input::list_what_if_forecasts_input::Builder {
        crate::input::list_what_if_forecasts_input::Builder::default()
    }
    /// Creates a new `ListWhatIfForecasts` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListWhatIfForecasts {
    type Output = std::result::Result<
        crate::output::ListWhatIfForecastsOutput,
        crate::error::ListWhatIfForecastsError,
    >;
    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_what_if_forecasts_error(response)
        } else {
            crate::operation_deser::parse_list_what_if_forecasts_response(response)
        }
    }
}

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

/// Operation shape for `StopResource`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`stop_resource`](crate::client::Client::stop_resource).
///
/// See [`crate::client::fluent_builders::StopResource`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct StopResource {
    _private: (),
}
impl StopResource {
    /// Creates a new builder-style object to manufacture [`StopResourceInput`](crate::input::StopResourceInput).
    pub fn builder() -> crate::input::stop_resource_input::Builder {
        crate::input::stop_resource_input::Builder::default()
    }
    /// Creates a new `StopResource` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for StopResource {
    type Output =
        std::result::Result<crate::output::StopResourceOutput, crate::error::StopResourceError>;
    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_resource_error(response)
        } else {
            crate::operation_deser::parse_stop_resource_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 `UpdateDatasetGroup`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_dataset_group`](crate::client::Client::update_dataset_group).
///
/// See [`crate::client::fluent_builders::UpdateDatasetGroup`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateDatasetGroup {
    _private: (),
}
impl UpdateDatasetGroup {
    /// Creates a new builder-style object to manufacture [`UpdateDatasetGroupInput`](crate::input::UpdateDatasetGroupInput).
    pub fn builder() -> crate::input::update_dataset_group_input::Builder {
        crate::input::update_dataset_group_input::Builder::default()
    }
    /// Creates a new `UpdateDatasetGroup` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateDatasetGroup {
    type Output = std::result::Result<
        crate::output::UpdateDatasetGroupOutput,
        crate::error::UpdateDatasetGroupError,
    >;
    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_dataset_group_error(response)
        } else {
            crate::operation_deser::parse_update_dataset_group_response(response)
        }
    }
}

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