aws-sdk-cleanrooms 0.1.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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