aws-sdk-kafka 0.24.0

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

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

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

/// Operation shape for `CreateConfiguration`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`create_configuration`](crate::client::Client::create_configuration).
///
/// See [`crate::client::fluent_builders::CreateConfiguration`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateConfiguration {
    _private: (),
}
impl CreateConfiguration {
    /// Creates a new builder-style object to manufacture [`CreateConfigurationInput`](crate::input::CreateConfigurationInput).
    pub fn builder() -> crate::input::create_configuration_input::Builder {
        crate::input::create_configuration_input::Builder::default()
    }
    /// Creates a new `CreateConfiguration` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for CreateConfiguration {
    type Output = std::result::Result<
        crate::output::CreateConfigurationOutput,
        crate::error::CreateConfigurationError,
    >;
    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_configuration_error(response)
        } else {
            crate::operation_deser::parse_create_configuration_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 `DeleteConfiguration`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_configuration`](crate::client::Client::delete_configuration).
///
/// See [`crate::client::fluent_builders::DeleteConfiguration`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteConfiguration {
    _private: (),
}
impl DeleteConfiguration {
    /// Creates a new builder-style object to manufacture [`DeleteConfigurationInput`](crate::input::DeleteConfigurationInput).
    pub fn builder() -> crate::input::delete_configuration_input::Builder {
        crate::input::delete_configuration_input::Builder::default()
    }
    /// Creates a new `DeleteConfiguration` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteConfiguration {
    type Output = std::result::Result<
        crate::output::DeleteConfigurationOutput,
        crate::error::DeleteConfigurationError,
    >;
    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_configuration_error(response)
        } else {
            crate::operation_deser::parse_delete_configuration_response(response)
        }
    }
}

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

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

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

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

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

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

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

/// Operation shape for `ListClusterOperations`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_cluster_operations`](crate::client::Client::list_cluster_operations).
///
/// See [`crate::client::fluent_builders::ListClusterOperations`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListClusterOperations {
    _private: (),
}
impl ListClusterOperations {
    /// Creates a new builder-style object to manufacture [`ListClusterOperationsInput`](crate::input::ListClusterOperationsInput).
    pub fn builder() -> crate::input::list_cluster_operations_input::Builder {
        crate::input::list_cluster_operations_input::Builder::default()
    }
    /// Creates a new `ListClusterOperations` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListClusterOperations {
    type Output = std::result::Result<
        crate::output::ListClusterOperationsOutput,
        crate::error::ListClusterOperationsError,
    >;
    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_operations_error(response)
        } else {
            crate::operation_deser::parse_list_cluster_operations_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 `ListClustersV2`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_clusters_v2`](crate::client::Client::list_clusters_v2).
///
/// See [`crate::client::fluent_builders::ListClustersV2`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListClustersV2 {
    _private: (),
}
impl ListClustersV2 {
    /// Creates a new builder-style object to manufacture [`ListClustersV2Input`](crate::input::ListClustersV2Input).
    pub fn builder() -> crate::input::list_clusters_v2_input::Builder {
        crate::input::list_clusters_v2_input::Builder::default()
    }
    /// Creates a new `ListClustersV2` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListClustersV2 {
    type Output =
        std::result::Result<crate::output::ListClustersV2Output, crate::error::ListClustersV2Error>;
    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_v2_error(response)
        } else {
            crate::operation_deser::parse_list_clusters_v2_response(response)
        }
    }
}

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

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

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

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

/// Operation shape for `ListScramSecrets`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_scram_secrets`](crate::client::Client::list_scram_secrets).
///
/// See [`crate::client::fluent_builders::ListScramSecrets`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListScramSecrets {
    _private: (),
}
impl ListScramSecrets {
    /// Creates a new builder-style object to manufacture [`ListScramSecretsInput`](crate::input::ListScramSecretsInput).
    pub fn builder() -> crate::input::list_scram_secrets_input::Builder {
        crate::input::list_scram_secrets_input::Builder::default()
    }
    /// Creates a new `ListScramSecrets` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListScramSecrets {
    type Output = std::result::Result<
        crate::output::ListScramSecretsOutput,
        crate::error::ListScramSecretsError,
    >;
    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_scram_secrets_error(response)
        } else {
            crate::operation_deser::parse_list_scram_secrets_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 `RebootBroker`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`reboot_broker`](crate::client::Client::reboot_broker).
///
/// See [`crate::client::fluent_builders::RebootBroker`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct RebootBroker {
    _private: (),
}
impl RebootBroker {
    /// Creates a new builder-style object to manufacture [`RebootBrokerInput`](crate::input::RebootBrokerInput).
    pub fn builder() -> crate::input::reboot_broker_input::Builder {
        crate::input::reboot_broker_input::Builder::default()
    }
    /// Creates a new `RebootBroker` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for RebootBroker {
    type Output =
        std::result::Result<crate::output::RebootBrokerOutput, crate::error::RebootBrokerError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_reboot_broker_error(response)
        } else {
            crate::operation_deser::parse_reboot_broker_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() != 204 {
            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() != 204 {
            crate::operation_deser::parse_untag_resource_error(response)
        } else {
            crate::operation_deser::parse_untag_resource_response(response)
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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