aws-sdk-docdbelastic 0.1.0

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

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

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

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

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

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

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

/// Operation shape for `ListClusterSnapshots`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_cluster_snapshots`](crate::client::Client::list_cluster_snapshots).
///
/// See [`crate::client::fluent_builders::ListClusterSnapshots`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListClusterSnapshots {
    _private: (),
}
impl ListClusterSnapshots {
    /// Creates a new builder-style object to manufacture [`ListClusterSnapshotsInput`](crate::input::ListClusterSnapshotsInput).
    pub fn builder() -> crate::input::list_cluster_snapshots_input::Builder {
        crate::input::list_cluster_snapshots_input::Builder::default()
    }
    /// Creates a new `ListClusterSnapshots` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListClusterSnapshots {
    type Output = std::result::Result<
        crate::output::ListClusterSnapshotsOutput,
        crate::error::ListClusterSnapshotsError,
    >;
    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_cluster_snapshots_error(response)
        } else {
            crate::operation_deser::parse_list_cluster_snapshots_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 `RestoreClusterFromSnapshot`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`restore_cluster_from_snapshot`](crate::client::Client::restore_cluster_from_snapshot).
///
/// See [`crate::client::fluent_builders::RestoreClusterFromSnapshot`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct RestoreClusterFromSnapshot {
    _private: (),
}
impl RestoreClusterFromSnapshot {
    /// Creates a new builder-style object to manufacture [`RestoreClusterFromSnapshotInput`](crate::input::RestoreClusterFromSnapshotInput).
    pub fn builder() -> crate::input::restore_cluster_from_snapshot_input::Builder {
        crate::input::restore_cluster_from_snapshot_input::Builder::default()
    }
    /// Creates a new `RestoreClusterFromSnapshot` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for RestoreClusterFromSnapshot {
    type Output = std::result::Result<
        crate::output::RestoreClusterFromSnapshotOutput,
        crate::error::RestoreClusterFromSnapshotError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_restore_cluster_from_snapshot_error(response)
        } else {
            crate::operation_deser::parse_restore_cluster_from_snapshot_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 `UpdateCluster`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`update_cluster`](crate::client::Client::update_cluster).
///
/// See [`crate::client::fluent_builders::UpdateCluster`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateCluster {
    _private: (),
}
impl UpdateCluster {
    /// Creates a new builder-style object to manufacture [`UpdateClusterInput`](crate::input::UpdateClusterInput).
    pub fn builder() -> crate::input::update_cluster_input::Builder {
        crate::input::update_cluster_input::Builder::default()
    }
    /// Creates a new `UpdateCluster` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateCluster {
    type Output =
        std::result::Result<crate::output::UpdateClusterOutput, crate::error::UpdateClusterError>;
    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_cluster_error(response)
        } else {
            crate::operation_deser::parse_update_cluster_response(response)
        }
    }
}

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