aws-sdk-cleanrooms 0.1.0

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
#[derive(Debug)]
pub(crate) struct Handle {
    pub(crate) client: aws_smithy_client::Client<
        aws_smithy_client::erase::DynConnector,
        aws_smithy_client::erase::DynMiddleware<aws_smithy_client::erase::DynConnector>,
    >,
    pub(crate) conf: crate::Config,
}

/// Client for AWS Clean Rooms Service
///
/// Client for invoking operations on AWS Clean Rooms Service. Each operation on AWS Clean Rooms Service is a method on this
/// this struct. `.send()` MUST be invoked on the generated operations to dispatch the request to the service.
///
/// # Examples
/// **Constructing a client and invoking an operation**
/// ```rust,no_run
/// # async fn docs() {
///     // create a shared configuration. This can be used & shared between multiple service clients.
///     let shared_config = aws_config::load_from_env().await;
///     let client = aws_sdk_cleanrooms::Client::new(&shared_config);
///     // invoke an operation
///     /* let rsp = client
///         .<operation_name>().
///         .<param>("some value")
///         .send().await; */
/// # }
/// ```
/// **Constructing a client with custom configuration**
/// ```rust,no_run
/// use aws_config::retry::RetryConfig;
/// # async fn docs() {
/// let shared_config = aws_config::load_from_env().await;
/// let config = aws_sdk_cleanrooms::config::Builder::from(&shared_config)
///   .retry_config(RetryConfig::disabled())
///   .build();
/// let client = aws_sdk_cleanrooms::Client::from_conf(config);
/// # }
#[derive(std::fmt::Debug)]
pub struct Client {
    handle: std::sync::Arc<Handle>,
}

impl std::clone::Clone for Client {
    fn clone(&self) -> Self {
        Self {
            handle: self.handle.clone(),
        }
    }
}

#[doc(inline)]
pub use aws_smithy_client::Builder;

impl
    From<
        aws_smithy_client::Client<
            aws_smithy_client::erase::DynConnector,
            aws_smithy_client::erase::DynMiddleware<aws_smithy_client::erase::DynConnector>,
        >,
    > for Client
{
    fn from(
        client: aws_smithy_client::Client<
            aws_smithy_client::erase::DynConnector,
            aws_smithy_client::erase::DynMiddleware<aws_smithy_client::erase::DynConnector>,
        >,
    ) -> Self {
        Self::with_config(client, crate::Config::builder().build())
    }
}

impl Client {
    /// Creates a client with the given service configuration.
    pub fn with_config(
        client: aws_smithy_client::Client<
            aws_smithy_client::erase::DynConnector,
            aws_smithy_client::erase::DynMiddleware<aws_smithy_client::erase::DynConnector>,
        >,
        conf: crate::Config,
    ) -> Self {
        Self {
            handle: std::sync::Arc::new(Handle { client, conf }),
        }
    }

    /// Returns the client's configuration.
    pub fn conf(&self) -> &crate::Config {
        &self.handle.conf
    }
}
impl Client {
    /// Constructs a fluent builder for the [`BatchGetSchema`](crate::client::fluent_builders::BatchGetSchema) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`collaboration_identifier(impl Into<String>)`](crate::client::fluent_builders::BatchGetSchema::collaboration_identifier) / [`set_collaboration_identifier(Option<String>)`](crate::client::fluent_builders::BatchGetSchema::set_collaboration_identifier): <p>A unique identifier for the collaboration that the schemas belong to. Currently accepts collaboration ID.</p>
    ///   - [`names(Vec<String>)`](crate::client::fluent_builders::BatchGetSchema::names) / [`set_names(Option<Vec<String>>)`](crate::client::fluent_builders::BatchGetSchema::set_names): <p>The names for the schema objects to retrieve.&gt;</p>
    /// - On success, responds with [`BatchGetSchemaOutput`](crate::output::BatchGetSchemaOutput) with field(s):
    ///   - [`schemas(Option<Vec<Schema>>)`](crate::output::BatchGetSchemaOutput::schemas): <p>The retrieved list of schemas.</p>
    ///   - [`errors(Option<Vec<BatchGetSchemaError>>)`](crate::output::BatchGetSchemaOutput::errors): <p>Error reasons for schemas that could not be retrieved. One error is returned for every schema that could not be retrieved.</p>
    /// - On failure, responds with [`SdkError<BatchGetSchemaError>`](crate::error::BatchGetSchemaError)
    pub fn batch_get_schema(&self) -> fluent_builders::BatchGetSchema {
        fluent_builders::BatchGetSchema::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`CreateCollaboration`](crate::client::fluent_builders::CreateCollaboration) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`members(Vec<MemberSpecification>)`](crate::client::fluent_builders::CreateCollaboration::members) / [`set_members(Option<Vec<MemberSpecification>>)`](crate::client::fluent_builders::CreateCollaboration::set_members): <p>A list of initial members, not including the creator. This list is immutable.</p>
    ///   - [`name(impl Into<String>)`](crate::client::fluent_builders::CreateCollaboration::name) / [`set_name(Option<String>)`](crate::client::fluent_builders::CreateCollaboration::set_name): <p>The display name for a collaboration.</p>
    ///   - [`description(impl Into<String>)`](crate::client::fluent_builders::CreateCollaboration::description) / [`set_description(Option<String>)`](crate::client::fluent_builders::CreateCollaboration::set_description): <p>A description of the collaboration provided by the collaboration owner.</p>
    ///   - [`creator_member_abilities(Vec<MemberAbility>)`](crate::client::fluent_builders::CreateCollaboration::creator_member_abilities) / [`set_creator_member_abilities(Option<Vec<MemberAbility>>)`](crate::client::fluent_builders::CreateCollaboration::set_creator_member_abilities): <p>The abilities granted to the collaboration creator.</p>
    ///   - [`creator_display_name(impl Into<String>)`](crate::client::fluent_builders::CreateCollaboration::creator_display_name) / [`set_creator_display_name(Option<String>)`](crate::client::fluent_builders::CreateCollaboration::set_creator_display_name): <p>The display name of the collaboration creator.</p>
    ///   - [`data_encryption_metadata(DataEncryptionMetadata)`](crate::client::fluent_builders::CreateCollaboration::data_encryption_metadata) / [`set_data_encryption_metadata(Option<DataEncryptionMetadata>)`](crate::client::fluent_builders::CreateCollaboration::set_data_encryption_metadata): <p>The settings for client-side encryption with Cryptographic Computing for Clean Rooms.</p>
    ///   - [`query_log_status(CollaborationQueryLogStatus)`](crate::client::fluent_builders::CreateCollaboration::query_log_status) / [`set_query_log_status(Option<CollaborationQueryLogStatus>)`](crate::client::fluent_builders::CreateCollaboration::set_query_log_status): <p>An indicator as to whether query logging has been enabled or disabled for the collaboration.</p>
    /// - On success, responds with [`CreateCollaborationOutput`](crate::output::CreateCollaborationOutput) with field(s):
    ///   - [`collaboration(Option<Collaboration>)`](crate::output::CreateCollaborationOutput::collaboration): <p>The entire created collaboration object.</p>
    /// - On failure, responds with [`SdkError<CreateCollaborationError>`](crate::error::CreateCollaborationError)
    pub fn create_collaboration(&self) -> fluent_builders::CreateCollaboration {
        fluent_builders::CreateCollaboration::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`CreateConfiguredTable`](crate::client::fluent_builders::CreateConfiguredTable) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`name(impl Into<String>)`](crate::client::fluent_builders::CreateConfiguredTable::name) / [`set_name(Option<String>)`](crate::client::fluent_builders::CreateConfiguredTable::set_name): <p>The name of the configured table.</p>
    ///   - [`description(impl Into<String>)`](crate::client::fluent_builders::CreateConfiguredTable::description) / [`set_description(Option<String>)`](crate::client::fluent_builders::CreateConfiguredTable::set_description): <p>A description for the configured table.</p>
    ///   - [`table_reference(TableReference)`](crate::client::fluent_builders::CreateConfiguredTable::table_reference) / [`set_table_reference(Option<TableReference>)`](crate::client::fluent_builders::CreateConfiguredTable::set_table_reference): <p>A reference to the AWS Glue table being configured.</p>
    ///   - [`allowed_columns(Vec<String>)`](crate::client::fluent_builders::CreateConfiguredTable::allowed_columns) / [`set_allowed_columns(Option<Vec<String>>)`](crate::client::fluent_builders::CreateConfiguredTable::set_allowed_columns): <p>The columns of the underlying table that can be used by collaborations or analysis rules.</p>
    ///   - [`analysis_method(AnalysisMethod)`](crate::client::fluent_builders::CreateConfiguredTable::analysis_method) / [`set_analysis_method(Option<AnalysisMethod>)`](crate::client::fluent_builders::CreateConfiguredTable::set_analysis_method): <p>The analysis method for the configured tables. The only valid value is currently `DIRECT_QUERY`.</p>
    /// - On success, responds with [`CreateConfiguredTableOutput`](crate::output::CreateConfiguredTableOutput) with field(s):
    ///   - [`configured_table(Option<ConfiguredTable>)`](crate::output::CreateConfiguredTableOutput::configured_table): <p>The created configured table.</p>
    /// - On failure, responds with [`SdkError<CreateConfiguredTableError>`](crate::error::CreateConfiguredTableError)
    pub fn create_configured_table(&self) -> fluent_builders::CreateConfiguredTable {
        fluent_builders::CreateConfiguredTable::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`CreateConfiguredTableAnalysisRule`](crate::client::fluent_builders::CreateConfiguredTableAnalysisRule) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`configured_table_identifier(impl Into<String>)`](crate::client::fluent_builders::CreateConfiguredTableAnalysisRule::configured_table_identifier) / [`set_configured_table_identifier(Option<String>)`](crate::client::fluent_builders::CreateConfiguredTableAnalysisRule::set_configured_table_identifier): <p>The identifier for the configured table to create the analysis rule for. Currently accepts the configured table ID. </p>
    ///   - [`analysis_rule_type(ConfiguredTableAnalysisRuleType)`](crate::client::fluent_builders::CreateConfiguredTableAnalysisRule::analysis_rule_type) / [`set_analysis_rule_type(Option<ConfiguredTableAnalysisRuleType>)`](crate::client::fluent_builders::CreateConfiguredTableAnalysisRule::set_analysis_rule_type): <p>The type of analysis rule. Valid values are AGGREGATION and LIST.</p>
    ///   - [`analysis_rule_policy(ConfiguredTableAnalysisRulePolicy)`](crate::client::fluent_builders::CreateConfiguredTableAnalysisRule::analysis_rule_policy) / [`set_analysis_rule_policy(Option<ConfiguredTableAnalysisRulePolicy>)`](crate::client::fluent_builders::CreateConfiguredTableAnalysisRule::set_analysis_rule_policy): <p>The entire created configured table analysis rule object.</p>
    /// - On success, responds with [`CreateConfiguredTableAnalysisRuleOutput`](crate::output::CreateConfiguredTableAnalysisRuleOutput) with field(s):
    ///   - [`analysis_rule(Option<ConfiguredTableAnalysisRule>)`](crate::output::CreateConfiguredTableAnalysisRuleOutput::analysis_rule): <p>The entire created analysis rule.</p>
    /// - On failure, responds with [`SdkError<CreateConfiguredTableAnalysisRuleError>`](crate::error::CreateConfiguredTableAnalysisRuleError)
    pub fn create_configured_table_analysis_rule(
        &self,
    ) -> fluent_builders::CreateConfiguredTableAnalysisRule {
        fluent_builders::CreateConfiguredTableAnalysisRule::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`CreateConfiguredTableAssociation`](crate::client::fluent_builders::CreateConfiguredTableAssociation) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`name(impl Into<String>)`](crate::client::fluent_builders::CreateConfiguredTableAssociation::name) / [`set_name(Option<String>)`](crate::client::fluent_builders::CreateConfiguredTableAssociation::set_name): <p>The name of the configured table association. This name is used to query the underlying configured table.</p>
    ///   - [`description(impl Into<String>)`](crate::client::fluent_builders::CreateConfiguredTableAssociation::description) / [`set_description(Option<String>)`](crate::client::fluent_builders::CreateConfiguredTableAssociation::set_description): <p>A description for the configured table association.</p>
    ///   - [`membership_identifier(impl Into<String>)`](crate::client::fluent_builders::CreateConfiguredTableAssociation::membership_identifier) / [`set_membership_identifier(Option<String>)`](crate::client::fluent_builders::CreateConfiguredTableAssociation::set_membership_identifier): <p>A unique identifier for one of your memberships for a collaboration. The configured table is associated to the collaboration that this membership belongs to. Currently accepts a membership ID.</p>
    ///   - [`configured_table_identifier(impl Into<String>)`](crate::client::fluent_builders::CreateConfiguredTableAssociation::configured_table_identifier) / [`set_configured_table_identifier(Option<String>)`](crate::client::fluent_builders::CreateConfiguredTableAssociation::set_configured_table_identifier): <p>A unique identifier for the configured table to be associated to. Currently accepts a configured table ID.</p>
    ///   - [`role_arn(impl Into<String>)`](crate::client::fluent_builders::CreateConfiguredTableAssociation::role_arn) / [`set_role_arn(Option<String>)`](crate::client::fluent_builders::CreateConfiguredTableAssociation::set_role_arn): <p>The service will assume this role to access catalog metadata and query the table.</p>
    /// - On success, responds with [`CreateConfiguredTableAssociationOutput`](crate::output::CreateConfiguredTableAssociationOutput) with field(s):
    ///   - [`configured_table_association(Option<ConfiguredTableAssociation>)`](crate::output::CreateConfiguredTableAssociationOutput::configured_table_association): <p>The entire configured table association object.</p>
    /// - On failure, responds with [`SdkError<CreateConfiguredTableAssociationError>`](crate::error::CreateConfiguredTableAssociationError)
    pub fn create_configured_table_association(
        &self,
    ) -> fluent_builders::CreateConfiguredTableAssociation {
        fluent_builders::CreateConfiguredTableAssociation::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`CreateMembership`](crate::client::fluent_builders::CreateMembership) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`collaboration_identifier(impl Into<String>)`](crate::client::fluent_builders::CreateMembership::collaboration_identifier) / [`set_collaboration_identifier(Option<String>)`](crate::client::fluent_builders::CreateMembership::set_collaboration_identifier): <p>The unique ID for the associated collaboration.</p>
    ///   - [`query_log_status(MembershipQueryLogStatus)`](crate::client::fluent_builders::CreateMembership::query_log_status) / [`set_query_log_status(Option<MembershipQueryLogStatus>)`](crate::client::fluent_builders::CreateMembership::set_query_log_status): <p>An indicator as to whether query logging has been enabled or disabled for the collaboration.</p>
    /// - On success, responds with [`CreateMembershipOutput`](crate::output::CreateMembershipOutput) with field(s):
    ///   - [`membership(Option<Membership>)`](crate::output::CreateMembershipOutput::membership): <p>The membership that was created.</p>
    /// - On failure, responds with [`SdkError<CreateMembershipError>`](crate::error::CreateMembershipError)
    pub fn create_membership(&self) -> fluent_builders::CreateMembership {
        fluent_builders::CreateMembership::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`DeleteCollaboration`](crate::client::fluent_builders::DeleteCollaboration) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`collaboration_identifier(impl Into<String>)`](crate::client::fluent_builders::DeleteCollaboration::collaboration_identifier) / [`set_collaboration_identifier(Option<String>)`](crate::client::fluent_builders::DeleteCollaboration::set_collaboration_identifier): <p>The identifier for the collaboration.</p>
    /// - On success, responds with [`DeleteCollaborationOutput`](crate::output::DeleteCollaborationOutput)

    /// - On failure, responds with [`SdkError<DeleteCollaborationError>`](crate::error::DeleteCollaborationError)
    pub fn delete_collaboration(&self) -> fluent_builders::DeleteCollaboration {
        fluent_builders::DeleteCollaboration::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`DeleteConfiguredTable`](crate::client::fluent_builders::DeleteConfiguredTable) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`configured_table_identifier(impl Into<String>)`](crate::client::fluent_builders::DeleteConfiguredTable::configured_table_identifier) / [`set_configured_table_identifier(Option<String>)`](crate::client::fluent_builders::DeleteConfiguredTable::set_configured_table_identifier): <p>The unique ID for the configured table to delete.</p>
    /// - On success, responds with [`DeleteConfiguredTableOutput`](crate::output::DeleteConfiguredTableOutput)

    /// - On failure, responds with [`SdkError<DeleteConfiguredTableError>`](crate::error::DeleteConfiguredTableError)
    pub fn delete_configured_table(&self) -> fluent_builders::DeleteConfiguredTable {
        fluent_builders::DeleteConfiguredTable::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`DeleteConfiguredTableAnalysisRule`](crate::client::fluent_builders::DeleteConfiguredTableAnalysisRule) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`configured_table_identifier(impl Into<String>)`](crate::client::fluent_builders::DeleteConfiguredTableAnalysisRule::configured_table_identifier) / [`set_configured_table_identifier(Option<String>)`](crate::client::fluent_builders::DeleteConfiguredTableAnalysisRule::set_configured_table_identifier): <p>The unique identifier for the configured table that the analysis rule applies to. Currently accepts the configured table ID.</p>
    ///   - [`analysis_rule_type(ConfiguredTableAnalysisRuleType)`](crate::client::fluent_builders::DeleteConfiguredTableAnalysisRule::analysis_rule_type) / [`set_analysis_rule_type(Option<ConfiguredTableAnalysisRuleType>)`](crate::client::fluent_builders::DeleteConfiguredTableAnalysisRule::set_analysis_rule_type): <p>The analysis rule type to be deleted. Configured table analysis rules are uniquely identified by their configured table identifier and analysis rule type.</p>
    /// - On success, responds with [`DeleteConfiguredTableAnalysisRuleOutput`](crate::output::DeleteConfiguredTableAnalysisRuleOutput)

    /// - On failure, responds with [`SdkError<DeleteConfiguredTableAnalysisRuleError>`](crate::error::DeleteConfiguredTableAnalysisRuleError)
    pub fn delete_configured_table_analysis_rule(
        &self,
    ) -> fluent_builders::DeleteConfiguredTableAnalysisRule {
        fluent_builders::DeleteConfiguredTableAnalysisRule::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`DeleteConfiguredTableAssociation`](crate::client::fluent_builders::DeleteConfiguredTableAssociation) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`configured_table_association_identifier(impl Into<String>)`](crate::client::fluent_builders::DeleteConfiguredTableAssociation::configured_table_association_identifier) / [`set_configured_table_association_identifier(Option<String>)`](crate::client::fluent_builders::DeleteConfiguredTableAssociation::set_configured_table_association_identifier): <p>The unique ID for the configured table association to be deleted. Currently accepts the configured table ID.</p>
    ///   - [`membership_identifier(impl Into<String>)`](crate::client::fluent_builders::DeleteConfiguredTableAssociation::membership_identifier) / [`set_membership_identifier(Option<String>)`](crate::client::fluent_builders::DeleteConfiguredTableAssociation::set_membership_identifier): <p>A unique identifier for the membership that the configured table association belongs to. Currently accepts the membership ID.</p>
    /// - On success, responds with [`DeleteConfiguredTableAssociationOutput`](crate::output::DeleteConfiguredTableAssociationOutput)

    /// - On failure, responds with [`SdkError<DeleteConfiguredTableAssociationError>`](crate::error::DeleteConfiguredTableAssociationError)
    pub fn delete_configured_table_association(
        &self,
    ) -> fluent_builders::DeleteConfiguredTableAssociation {
        fluent_builders::DeleteConfiguredTableAssociation::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`DeleteMember`](crate::client::fluent_builders::DeleteMember) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`collaboration_identifier(impl Into<String>)`](crate::client::fluent_builders::DeleteMember::collaboration_identifier) / [`set_collaboration_identifier(Option<String>)`](crate::client::fluent_builders::DeleteMember::set_collaboration_identifier): <p>The unique identifier for the associated collaboration.</p>
    ///   - [`account_id(impl Into<String>)`](crate::client::fluent_builders::DeleteMember::account_id) / [`set_account_id(Option<String>)`](crate::client::fluent_builders::DeleteMember::set_account_id): <p>The account ID of the member to remove.</p>
    /// - On success, responds with [`DeleteMemberOutput`](crate::output::DeleteMemberOutput)

    /// - On failure, responds with [`SdkError<DeleteMemberError>`](crate::error::DeleteMemberError)
    pub fn delete_member(&self) -> fluent_builders::DeleteMember {
        fluent_builders::DeleteMember::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`DeleteMembership`](crate::client::fluent_builders::DeleteMembership) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`membership_identifier(impl Into<String>)`](crate::client::fluent_builders::DeleteMembership::membership_identifier) / [`set_membership_identifier(Option<String>)`](crate::client::fluent_builders::DeleteMembership::set_membership_identifier): <p>The identifier for a membership resource.</p>
    /// - On success, responds with [`DeleteMembershipOutput`](crate::output::DeleteMembershipOutput)

    /// - On failure, responds with [`SdkError<DeleteMembershipError>`](crate::error::DeleteMembershipError)
    pub fn delete_membership(&self) -> fluent_builders::DeleteMembership {
        fluent_builders::DeleteMembership::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`GetCollaboration`](crate::client::fluent_builders::GetCollaboration) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`collaboration_identifier(impl Into<String>)`](crate::client::fluent_builders::GetCollaboration::collaboration_identifier) / [`set_collaboration_identifier(Option<String>)`](crate::client::fluent_builders::GetCollaboration::set_collaboration_identifier): <p>The identifier for the collaboration.</p>
    /// - On success, responds with [`GetCollaborationOutput`](crate::output::GetCollaborationOutput) with field(s):
    ///   - [`collaboration(Option<Collaboration>)`](crate::output::GetCollaborationOutput::collaboration): <p>The entire collaboration for this identifier.</p>
    /// - On failure, responds with [`SdkError<GetCollaborationError>`](crate::error::GetCollaborationError)
    pub fn get_collaboration(&self) -> fluent_builders::GetCollaboration {
        fluent_builders::GetCollaboration::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`GetConfiguredTable`](crate::client::fluent_builders::GetConfiguredTable) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`configured_table_identifier(impl Into<String>)`](crate::client::fluent_builders::GetConfiguredTable::configured_table_identifier) / [`set_configured_table_identifier(Option<String>)`](crate::client::fluent_builders::GetConfiguredTable::set_configured_table_identifier): <p>The unique ID for the configured table to retrieve.</p>
    /// - On success, responds with [`GetConfiguredTableOutput`](crate::output::GetConfiguredTableOutput) with field(s):
    ///   - [`configured_table(Option<ConfiguredTable>)`](crate::output::GetConfiguredTableOutput::configured_table): <p>The retrieved configured table.</p>
    /// - On failure, responds with [`SdkError<GetConfiguredTableError>`](crate::error::GetConfiguredTableError)
    pub fn get_configured_table(&self) -> fluent_builders::GetConfiguredTable {
        fluent_builders::GetConfiguredTable::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`GetConfiguredTableAnalysisRule`](crate::client::fluent_builders::GetConfiguredTableAnalysisRule) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`configured_table_identifier(impl Into<String>)`](crate::client::fluent_builders::GetConfiguredTableAnalysisRule::configured_table_identifier) / [`set_configured_table_identifier(Option<String>)`](crate::client::fluent_builders::GetConfiguredTableAnalysisRule::set_configured_table_identifier): <p>The unique identifier for the configured table to retrieve. Currently accepts the configured table ID.</p>
    ///   - [`analysis_rule_type(ConfiguredTableAnalysisRuleType)`](crate::client::fluent_builders::GetConfiguredTableAnalysisRule::analysis_rule_type) / [`set_analysis_rule_type(Option<ConfiguredTableAnalysisRuleType>)`](crate::client::fluent_builders::GetConfiguredTableAnalysisRule::set_analysis_rule_type): <p>The analysis rule to be retrieved. Configured table analysis rules are uniquely identified by their configured table identifier and analysis rule type.</p>
    /// - On success, responds with [`GetConfiguredTableAnalysisRuleOutput`](crate::output::GetConfiguredTableAnalysisRuleOutput) with field(s):
    ///   - [`analysis_rule(Option<ConfiguredTableAnalysisRule>)`](crate::output::GetConfiguredTableAnalysisRuleOutput::analysis_rule): <p>The entire analysis rule output.</p>
    /// - On failure, responds with [`SdkError<GetConfiguredTableAnalysisRuleError>`](crate::error::GetConfiguredTableAnalysisRuleError)
    pub fn get_configured_table_analysis_rule(
        &self,
    ) -> fluent_builders::GetConfiguredTableAnalysisRule {
        fluent_builders::GetConfiguredTableAnalysisRule::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`GetConfiguredTableAssociation`](crate::client::fluent_builders::GetConfiguredTableAssociation) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`configured_table_association_identifier(impl Into<String>)`](crate::client::fluent_builders::GetConfiguredTableAssociation::configured_table_association_identifier) / [`set_configured_table_association_identifier(Option<String>)`](crate::client::fluent_builders::GetConfiguredTableAssociation::set_configured_table_association_identifier): <p>The unique ID for the configured table association to retrieve. Currently accepts the configured table ID.</p>
    ///   - [`membership_identifier(impl Into<String>)`](crate::client::fluent_builders::GetConfiguredTableAssociation::membership_identifier) / [`set_membership_identifier(Option<String>)`](crate::client::fluent_builders::GetConfiguredTableAssociation::set_membership_identifier): <p>A unique identifier for the membership that the configured table association belongs to. Currently accepts the membership ID.</p>
    /// - On success, responds with [`GetConfiguredTableAssociationOutput`](crate::output::GetConfiguredTableAssociationOutput) with field(s):
    ///   - [`configured_table_association(Option<ConfiguredTableAssociation>)`](crate::output::GetConfiguredTableAssociationOutput::configured_table_association): <p>The entire configured table association object.</p>
    /// - On failure, responds with [`SdkError<GetConfiguredTableAssociationError>`](crate::error::GetConfiguredTableAssociationError)
    pub fn get_configured_table_association(
        &self,
    ) -> fluent_builders::GetConfiguredTableAssociation {
        fluent_builders::GetConfiguredTableAssociation::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`GetMembership`](crate::client::fluent_builders::GetMembership) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`membership_identifier(impl Into<String>)`](crate::client::fluent_builders::GetMembership::membership_identifier) / [`set_membership_identifier(Option<String>)`](crate::client::fluent_builders::GetMembership::set_membership_identifier): <p>The identifier for a membership resource.</p>
    /// - On success, responds with [`GetMembershipOutput`](crate::output::GetMembershipOutput) with field(s):
    ///   - [`membership(Option<Membership>)`](crate::output::GetMembershipOutput::membership): <p>The membership retrieved for the provided identifier.</p>
    /// - On failure, responds with [`SdkError<GetMembershipError>`](crate::error::GetMembershipError)
    pub fn get_membership(&self) -> fluent_builders::GetMembership {
        fluent_builders::GetMembership::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`GetProtectedQuery`](crate::client::fluent_builders::GetProtectedQuery) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`membership_identifier(impl Into<String>)`](crate::client::fluent_builders::GetProtectedQuery::membership_identifier) / [`set_membership_identifier(Option<String>)`](crate::client::fluent_builders::GetProtectedQuery::set_membership_identifier): <p>The identifier for a membership in a protected query instance.</p>
    ///   - [`protected_query_identifier(impl Into<String>)`](crate::client::fluent_builders::GetProtectedQuery::protected_query_identifier) / [`set_protected_query_identifier(Option<String>)`](crate::client::fluent_builders::GetProtectedQuery::set_protected_query_identifier): <p>The identifier for a protected query instance.</p>
    /// - On success, responds with [`GetProtectedQueryOutput`](crate::output::GetProtectedQueryOutput) with field(s):
    ///   - [`protected_query(Option<ProtectedQuery>)`](crate::output::GetProtectedQueryOutput::protected_query): <p>The query processing metadata.</p>
    /// - On failure, responds with [`SdkError<GetProtectedQueryError>`](crate::error::GetProtectedQueryError)
    pub fn get_protected_query(&self) -> fluent_builders::GetProtectedQuery {
        fluent_builders::GetProtectedQuery::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`GetSchema`](crate::client::fluent_builders::GetSchema) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`collaboration_identifier(impl Into<String>)`](crate::client::fluent_builders::GetSchema::collaboration_identifier) / [`set_collaboration_identifier(Option<String>)`](crate::client::fluent_builders::GetSchema::set_collaboration_identifier): <p>A unique identifier for the collaboration that the schema belongs to. Currently accepts a collaboration ID.</p>
    ///   - [`name(impl Into<String>)`](crate::client::fluent_builders::GetSchema::name) / [`set_name(Option<String>)`](crate::client::fluent_builders::GetSchema::set_name): <p>The name of the relation to retrieve the schema for.</p>
    /// - On success, responds with [`GetSchemaOutput`](crate::output::GetSchemaOutput) with field(s):
    ///   - [`schema(Option<Schema>)`](crate::output::GetSchemaOutput::schema): <p>The entire schema object.</p>
    /// - On failure, responds with [`SdkError<GetSchemaError>`](crate::error::GetSchemaError)
    pub fn get_schema(&self) -> fluent_builders::GetSchema {
        fluent_builders::GetSchema::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`GetSchemaAnalysisRule`](crate::client::fluent_builders::GetSchemaAnalysisRule) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`collaboration_identifier(impl Into<String>)`](crate::client::fluent_builders::GetSchemaAnalysisRule::collaboration_identifier) / [`set_collaboration_identifier(Option<String>)`](crate::client::fluent_builders::GetSchemaAnalysisRule::set_collaboration_identifier): <p>A unique identifier for the collaboration that the schema belongs to. Currently accepts a collaboration ID.</p>
    ///   - [`name(impl Into<String>)`](crate::client::fluent_builders::GetSchemaAnalysisRule::name) / [`set_name(Option<String>)`](crate::client::fluent_builders::GetSchemaAnalysisRule::set_name): <p>The name of the schema to retrieve the analysis rule for.</p>
    ///   - [`r#type(AnalysisRuleType)`](crate::client::fluent_builders::GetSchemaAnalysisRule::type) / [`set_type(Option<AnalysisRuleType>)`](crate::client::fluent_builders::GetSchemaAnalysisRule::set_type): <p>The type of the schema analysis rule to retrieve. Schema analysis rules are uniquely identified by a combination of the collaboration, the schema name, and their type.</p>
    /// - On success, responds with [`GetSchemaAnalysisRuleOutput`](crate::output::GetSchemaAnalysisRuleOutput) with field(s):
    ///   - [`analysis_rule(Option<AnalysisRule>)`](crate::output::GetSchemaAnalysisRuleOutput::analysis_rule): <p>A specification about how data from the configured table can be used.</p>
    /// - On failure, responds with [`SdkError<GetSchemaAnalysisRuleError>`](crate::error::GetSchemaAnalysisRuleError)
    pub fn get_schema_analysis_rule(&self) -> fluent_builders::GetSchemaAnalysisRule {
        fluent_builders::GetSchemaAnalysisRule::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`ListCollaborations`](crate::client::fluent_builders::ListCollaborations) operation.
    /// This operation supports pagination; See [`into_paginator()`](crate::client::fluent_builders::ListCollaborations::into_paginator).
    ///
    /// - The fluent builder is configurable:
    ///   - [`next_token(impl Into<String>)`](crate::client::fluent_builders::ListCollaborations::next_token) / [`set_next_token(Option<String>)`](crate::client::fluent_builders::ListCollaborations::set_next_token): <p>The token value retrieved from a previous call to access the next page of results.</p>
    ///   - [`max_results(i32)`](crate::client::fluent_builders::ListCollaborations::max_results) / [`set_max_results(Option<i32>)`](crate::client::fluent_builders::ListCollaborations::set_max_results): <p>The maximum size of the results that is returned per call. Service chooses a default if it has not been set. Service may return a nextToken even if the maximum results has not been met.</p>
    ///   - [`member_status(FilterableMemberStatus)`](crate::client::fluent_builders::ListCollaborations::member_status) / [`set_member_status(Option<FilterableMemberStatus>)`](crate::client::fluent_builders::ListCollaborations::set_member_status): <p>The caller's status in a collaboration.</p>
    /// - On success, responds with [`ListCollaborationsOutput`](crate::output::ListCollaborationsOutput) with field(s):
    ///   - [`next_token(Option<String>)`](crate::output::ListCollaborationsOutput::next_token): <p>The token value retrieved from a previous call to access the next page of results.</p>
    ///   - [`collaboration_list(Option<Vec<CollaborationSummary>>)`](crate::output::ListCollaborationsOutput::collaboration_list): <p>The list of collaborations.</p>
    /// - On failure, responds with [`SdkError<ListCollaborationsError>`](crate::error::ListCollaborationsError)
    pub fn list_collaborations(&self) -> fluent_builders::ListCollaborations {
        fluent_builders::ListCollaborations::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`ListConfiguredTableAssociations`](crate::client::fluent_builders::ListConfiguredTableAssociations) operation.
    /// This operation supports pagination; See [`into_paginator()`](crate::client::fluent_builders::ListConfiguredTableAssociations::into_paginator).
    ///
    /// - The fluent builder is configurable:
    ///   - [`membership_identifier(impl Into<String>)`](crate::client::fluent_builders::ListConfiguredTableAssociations::membership_identifier) / [`set_membership_identifier(Option<String>)`](crate::client::fluent_builders::ListConfiguredTableAssociations::set_membership_identifier): <p>A unique identifier for the membership to list configured table associations for. Currently accepts the membership ID.</p>
    ///   - [`next_token(impl Into<String>)`](crate::client::fluent_builders::ListConfiguredTableAssociations::next_token) / [`set_next_token(Option<String>)`](crate::client::fluent_builders::ListConfiguredTableAssociations::set_next_token): <p>The token value retrieved from a previous call to access the next page of results.</p>
    ///   - [`max_results(i32)`](crate::client::fluent_builders::ListConfiguredTableAssociations::max_results) / [`set_max_results(Option<i32>)`](crate::client::fluent_builders::ListConfiguredTableAssociations::set_max_results): <p>The maximum size of the results that is returned per call.</p>
    /// - On success, responds with [`ListConfiguredTableAssociationsOutput`](crate::output::ListConfiguredTableAssociationsOutput) with field(s):
    ///   - [`configured_table_association_summaries(Option<Vec<ConfiguredTableAssociationSummary>>)`](crate::output::ListConfiguredTableAssociationsOutput::configured_table_association_summaries): <p>The retrieved list of configured table associations.</p>
    ///   - [`next_token(Option<String>)`](crate::output::ListConfiguredTableAssociationsOutput::next_token): <p>The token value retrieved from a previous call to access the next page of results.</p>
    /// - On failure, responds with [`SdkError<ListConfiguredTableAssociationsError>`](crate::error::ListConfiguredTableAssociationsError)
    pub fn list_configured_table_associations(
        &self,
    ) -> fluent_builders::ListConfiguredTableAssociations {
        fluent_builders::ListConfiguredTableAssociations::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`ListConfiguredTables`](crate::client::fluent_builders::ListConfiguredTables) operation.
    /// This operation supports pagination; See [`into_paginator()`](crate::client::fluent_builders::ListConfiguredTables::into_paginator).
    ///
    /// - The fluent builder is configurable:
    ///   - [`next_token(impl Into<String>)`](crate::client::fluent_builders::ListConfiguredTables::next_token) / [`set_next_token(Option<String>)`](crate::client::fluent_builders::ListConfiguredTables::set_next_token): <p>The token value retrieved from a previous call to access the next page of results.</p>
    ///   - [`max_results(i32)`](crate::client::fluent_builders::ListConfiguredTables::max_results) / [`set_max_results(Option<i32>)`](crate::client::fluent_builders::ListConfiguredTables::set_max_results): <p>The maximum size of the results that is returned per call.</p>
    /// - On success, responds with [`ListConfiguredTablesOutput`](crate::output::ListConfiguredTablesOutput) with field(s):
    ///   - [`configured_table_summaries(Option<Vec<ConfiguredTableSummary>>)`](crate::output::ListConfiguredTablesOutput::configured_table_summaries): <p>The configured tables listed by the request.</p>
    ///   - [`next_token(Option<String>)`](crate::output::ListConfiguredTablesOutput::next_token): <p>The token value retrieved from a previous call to access the next page of results.</p>
    /// - On failure, responds with [`SdkError<ListConfiguredTablesError>`](crate::error::ListConfiguredTablesError)
    pub fn list_configured_tables(&self) -> fluent_builders::ListConfiguredTables {
        fluent_builders::ListConfiguredTables::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`ListMembers`](crate::client::fluent_builders::ListMembers) operation.
    /// This operation supports pagination; See [`into_paginator()`](crate::client::fluent_builders::ListMembers::into_paginator).
    ///
    /// - The fluent builder is configurable:
    ///   - [`collaboration_identifier(impl Into<String>)`](crate::client::fluent_builders::ListMembers::collaboration_identifier) / [`set_collaboration_identifier(Option<String>)`](crate::client::fluent_builders::ListMembers::set_collaboration_identifier): <p>The identifier of the collaboration in which the members are listed.</p>
    ///   - [`next_token(impl Into<String>)`](crate::client::fluent_builders::ListMembers::next_token) / [`set_next_token(Option<String>)`](crate::client::fluent_builders::ListMembers::set_next_token): <p>The token value retrieved from a previous call to access the next page of results.</p>
    ///   - [`max_results(i32)`](crate::client::fluent_builders::ListMembers::max_results) / [`set_max_results(Option<i32>)`](crate::client::fluent_builders::ListMembers::set_max_results): <p>The maximum size of the results that is returned per call.</p>
    /// - On success, responds with [`ListMembersOutput`](crate::output::ListMembersOutput) with field(s):
    ///   - [`next_token(Option<String>)`](crate::output::ListMembersOutput::next_token): <p>The token value retrieved from a previous call to access the next page of results.</p>
    ///   - [`member_summaries(Option<Vec<MemberSummary>>)`](crate::output::ListMembersOutput::member_summaries): <p>The list of members returned by the ListMembers operation.</p>
    /// - On failure, responds with [`SdkError<ListMembersError>`](crate::error::ListMembersError)
    pub fn list_members(&self) -> fluent_builders::ListMembers {
        fluent_builders::ListMembers::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`ListMemberships`](crate::client::fluent_builders::ListMemberships) operation.
    /// This operation supports pagination; See [`into_paginator()`](crate::client::fluent_builders::ListMemberships::into_paginator).
    ///
    /// - The fluent builder is configurable:
    ///   - [`next_token(impl Into<String>)`](crate::client::fluent_builders::ListMemberships::next_token) / [`set_next_token(Option<String>)`](crate::client::fluent_builders::ListMemberships::set_next_token): <p>The token value retrieved from a previous call to access the next page of results.</p>
    ///   - [`max_results(i32)`](crate::client::fluent_builders::ListMemberships::max_results) / [`set_max_results(Option<i32>)`](crate::client::fluent_builders::ListMemberships::set_max_results): <p>The maximum size of the results that is returned per call.</p>
    ///   - [`status(MembershipStatus)`](crate::client::fluent_builders::ListMemberships::status) / [`set_status(Option<MembershipStatus>)`](crate::client::fluent_builders::ListMemberships::set_status): <p>A filter which will return only memberships in the specified status.</p>
    /// - On success, responds with [`ListMembershipsOutput`](crate::output::ListMembershipsOutput) with field(s):
    ///   - [`next_token(Option<String>)`](crate::output::ListMembershipsOutput::next_token): <p>The token value retrieved from a previous call to access the next page of results.</p>
    ///   - [`membership_summaries(Option<Vec<MembershipSummary>>)`](crate::output::ListMembershipsOutput::membership_summaries): <p>The list of memberships returned from the ListMemberships operation.</p>
    /// - On failure, responds with [`SdkError<ListMembershipsError>`](crate::error::ListMembershipsError)
    pub fn list_memberships(&self) -> fluent_builders::ListMemberships {
        fluent_builders::ListMemberships::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`ListProtectedQueries`](crate::client::fluent_builders::ListProtectedQueries) operation.
    /// This operation supports pagination; See [`into_paginator()`](crate::client::fluent_builders::ListProtectedQueries::into_paginator).
    ///
    /// - The fluent builder is configurable:
    ///   - [`membership_identifier(impl Into<String>)`](crate::client::fluent_builders::ListProtectedQueries::membership_identifier) / [`set_membership_identifier(Option<String>)`](crate::client::fluent_builders::ListProtectedQueries::set_membership_identifier): <p>The identifier for the membership in the collaboration.</p>
    ///   - [`status(ProtectedQueryStatus)`](crate::client::fluent_builders::ListProtectedQueries::status) / [`set_status(Option<ProtectedQueryStatus>)`](crate::client::fluent_builders::ListProtectedQueries::set_status): <p>A filter on the status of the protected query.</p>
    ///   - [`next_token(impl Into<String>)`](crate::client::fluent_builders::ListProtectedQueries::next_token) / [`set_next_token(Option<String>)`](crate::client::fluent_builders::ListProtectedQueries::set_next_token): <p>The token value retrieved from a previous call to access the next page of results.</p>
    ///   - [`max_results(i32)`](crate::client::fluent_builders::ListProtectedQueries::max_results) / [`set_max_results(Option<i32>)`](crate::client::fluent_builders::ListProtectedQueries::set_max_results): <p>The maximum size of the results that is returned per call. Service chooses a default if it has not been set. Service can return a nextToken even if the maximum results has not been met. </p>
    /// - On success, responds with [`ListProtectedQueriesOutput`](crate::output::ListProtectedQueriesOutput) with field(s):
    ///   - [`next_token(Option<String>)`](crate::output::ListProtectedQueriesOutput::next_token): <p>The token value retrieved from a previous call to access the next page of results.</p>
    ///   - [`protected_queries(Option<Vec<ProtectedQuerySummary>>)`](crate::output::ListProtectedQueriesOutput::protected_queries): <p>A list of protected queries.</p>
    /// - On failure, responds with [`SdkError<ListProtectedQueriesError>`](crate::error::ListProtectedQueriesError)
    pub fn list_protected_queries(&self) -> fluent_builders::ListProtectedQueries {
        fluent_builders::ListProtectedQueries::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`ListSchemas`](crate::client::fluent_builders::ListSchemas) operation.
    /// This operation supports pagination; See [`into_paginator()`](crate::client::fluent_builders::ListSchemas::into_paginator).
    ///
    /// - The fluent builder is configurable:
    ///   - [`collaboration_identifier(impl Into<String>)`](crate::client::fluent_builders::ListSchemas::collaboration_identifier) / [`set_collaboration_identifier(Option<String>)`](crate::client::fluent_builders::ListSchemas::set_collaboration_identifier): <p>A unique identifier for the collaboration that the schema belongs to. Currently accepts a collaboration ID.</p>
    ///   - [`schema_type(SchemaType)`](crate::client::fluent_builders::ListSchemas::schema_type) / [`set_schema_type(Option<SchemaType>)`](crate::client::fluent_builders::ListSchemas::set_schema_type): <p>If present, filter schemas by schema type. The only valid schema type is currently `TABLE`.</p>
    ///   - [`next_token(impl Into<String>)`](crate::client::fluent_builders::ListSchemas::next_token) / [`set_next_token(Option<String>)`](crate::client::fluent_builders::ListSchemas::set_next_token): <p>The token value retrieved from a previous call to access the next page of results.</p>
    ///   - [`max_results(i32)`](crate::client::fluent_builders::ListSchemas::max_results) / [`set_max_results(Option<i32>)`](crate::client::fluent_builders::ListSchemas::set_max_results): <p>The maximum size of the results that is returned per call.</p>
    /// - On success, responds with [`ListSchemasOutput`](crate::output::ListSchemasOutput) with field(s):
    ///   - [`schema_summaries(Option<Vec<SchemaSummary>>)`](crate::output::ListSchemasOutput::schema_summaries): <p>The retrieved list of schemas.</p>
    ///   - [`next_token(Option<String>)`](crate::output::ListSchemasOutput::next_token): <p>The token value retrieved from a previous call to access the next page of results.</p>
    /// - On failure, responds with [`SdkError<ListSchemasError>`](crate::error::ListSchemasError)
    pub fn list_schemas(&self) -> fluent_builders::ListSchemas {
        fluent_builders::ListSchemas::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`StartProtectedQuery`](crate::client::fluent_builders::StartProtectedQuery) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`r#type(ProtectedQueryType)`](crate::client::fluent_builders::StartProtectedQuery::type) / [`set_type(Option<ProtectedQueryType>)`](crate::client::fluent_builders::StartProtectedQuery::set_type): <p>The type of the protected query to be started.</p>
    ///   - [`membership_identifier(impl Into<String>)`](crate::client::fluent_builders::StartProtectedQuery::membership_identifier) / [`set_membership_identifier(Option<String>)`](crate::client::fluent_builders::StartProtectedQuery::set_membership_identifier): <p>A unique identifier for the membership to run this query against. Currently accepts a membership ID.</p>
    ///   - [`sql_parameters(ProtectedQuerySqlParameters)`](crate::client::fluent_builders::StartProtectedQuery::sql_parameters) / [`set_sql_parameters(Option<ProtectedQuerySqlParameters>)`](crate::client::fluent_builders::StartProtectedQuery::set_sql_parameters): <p>The protected SQL query parameters.</p>
    ///   - [`result_configuration(ProtectedQueryResultConfiguration)`](crate::client::fluent_builders::StartProtectedQuery::result_configuration) / [`set_result_configuration(Option<ProtectedQueryResultConfiguration>)`](crate::client::fluent_builders::StartProtectedQuery::set_result_configuration): <p>The details needed to write the query results.</p>
    /// - On success, responds with [`StartProtectedQueryOutput`](crate::output::StartProtectedQueryOutput) with field(s):
    ///   - [`protected_query(Option<ProtectedQuery>)`](crate::output::StartProtectedQueryOutput::protected_query): <p>The protected query.</p>
    /// - On failure, responds with [`SdkError<StartProtectedQueryError>`](crate::error::StartProtectedQueryError)
    pub fn start_protected_query(&self) -> fluent_builders::StartProtectedQuery {
        fluent_builders::StartProtectedQuery::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`UpdateCollaboration`](crate::client::fluent_builders::UpdateCollaboration) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`collaboration_identifier(impl Into<String>)`](crate::client::fluent_builders::UpdateCollaboration::collaboration_identifier) / [`set_collaboration_identifier(Option<String>)`](crate::client::fluent_builders::UpdateCollaboration::set_collaboration_identifier): <p>The identifier for the collaboration.</p>
    ///   - [`name(impl Into<String>)`](crate::client::fluent_builders::UpdateCollaboration::name) / [`set_name(Option<String>)`](crate::client::fluent_builders::UpdateCollaboration::set_name): <p>A human-readable identifier provided by the collaboration owner. Display names are not unique.</p>
    ///   - [`description(impl Into<String>)`](crate::client::fluent_builders::UpdateCollaboration::description) / [`set_description(Option<String>)`](crate::client::fluent_builders::UpdateCollaboration::set_description): <p>A description of the collaboration.</p>
    /// - On success, responds with [`UpdateCollaborationOutput`](crate::output::UpdateCollaborationOutput) with field(s):
    ///   - [`collaboration(Option<Collaboration>)`](crate::output::UpdateCollaborationOutput::collaboration): <p>The entire collaboration that has been updated.</p>
    /// - On failure, responds with [`SdkError<UpdateCollaborationError>`](crate::error::UpdateCollaborationError)
    pub fn update_collaboration(&self) -> fluent_builders::UpdateCollaboration {
        fluent_builders::UpdateCollaboration::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`UpdateConfiguredTable`](crate::client::fluent_builders::UpdateConfiguredTable) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`configured_table_identifier(impl Into<String>)`](crate::client::fluent_builders::UpdateConfiguredTable::configured_table_identifier) / [`set_configured_table_identifier(Option<String>)`](crate::client::fluent_builders::UpdateConfiguredTable::set_configured_table_identifier): <p>The identifier for the configured table to update. Currently accepts the configured table ID.</p>
    ///   - [`name(impl Into<String>)`](crate::client::fluent_builders::UpdateConfiguredTable::name) / [`set_name(Option<String>)`](crate::client::fluent_builders::UpdateConfiguredTable::set_name): <p>A new name for the configured table.</p>
    ///   - [`description(impl Into<String>)`](crate::client::fluent_builders::UpdateConfiguredTable::description) / [`set_description(Option<String>)`](crate::client::fluent_builders::UpdateConfiguredTable::set_description): <p>A new description for the configured table.</p>
    /// - On success, responds with [`UpdateConfiguredTableOutput`](crate::output::UpdateConfiguredTableOutput) with field(s):
    ///   - [`configured_table(Option<ConfiguredTable>)`](crate::output::UpdateConfiguredTableOutput::configured_table): <p>The updated configured table.</p>
    /// - On failure, responds with [`SdkError<UpdateConfiguredTableError>`](crate::error::UpdateConfiguredTableError)
    pub fn update_configured_table(&self) -> fluent_builders::UpdateConfiguredTable {
        fluent_builders::UpdateConfiguredTable::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`UpdateConfiguredTableAnalysisRule`](crate::client::fluent_builders::UpdateConfiguredTableAnalysisRule) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`configured_table_identifier(impl Into<String>)`](crate::client::fluent_builders::UpdateConfiguredTableAnalysisRule::configured_table_identifier) / [`set_configured_table_identifier(Option<String>)`](crate::client::fluent_builders::UpdateConfiguredTableAnalysisRule::set_configured_table_identifier): <p>The unique identifier for the configured table that the analysis rule applies to. Currently accepts the configured table ID.</p>
    ///   - [`analysis_rule_type(ConfiguredTableAnalysisRuleType)`](crate::client::fluent_builders::UpdateConfiguredTableAnalysisRule::analysis_rule_type) / [`set_analysis_rule_type(Option<ConfiguredTableAnalysisRuleType>)`](crate::client::fluent_builders::UpdateConfiguredTableAnalysisRule::set_analysis_rule_type): <p>The analysis rule type to be updated. Configured table analysis rules are uniquely identified by their configured table identifier and analysis rule type.</p>
    ///   - [`analysis_rule_policy(ConfiguredTableAnalysisRulePolicy)`](crate::client::fluent_builders::UpdateConfiguredTableAnalysisRule::analysis_rule_policy) / [`set_analysis_rule_policy(Option<ConfiguredTableAnalysisRulePolicy>)`](crate::client::fluent_builders::UpdateConfiguredTableAnalysisRule::set_analysis_rule_policy): <p>The new analysis rule policy for the configured table analysis rule.</p>
    /// - On success, responds with [`UpdateConfiguredTableAnalysisRuleOutput`](crate::output::UpdateConfiguredTableAnalysisRuleOutput) with field(s):
    ///   - [`analysis_rule(Option<ConfiguredTableAnalysisRule>)`](crate::output::UpdateConfiguredTableAnalysisRuleOutput::analysis_rule): <p>The entire updated analysis rule.</p>
    /// - On failure, responds with [`SdkError<UpdateConfiguredTableAnalysisRuleError>`](crate::error::UpdateConfiguredTableAnalysisRuleError)
    pub fn update_configured_table_analysis_rule(
        &self,
    ) -> fluent_builders::UpdateConfiguredTableAnalysisRule {
        fluent_builders::UpdateConfiguredTableAnalysisRule::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`UpdateConfiguredTableAssociation`](crate::client::fluent_builders::UpdateConfiguredTableAssociation) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`configured_table_association_identifier(impl Into<String>)`](crate::client::fluent_builders::UpdateConfiguredTableAssociation::configured_table_association_identifier) / [`set_configured_table_association_identifier(Option<String>)`](crate::client::fluent_builders::UpdateConfiguredTableAssociation::set_configured_table_association_identifier): <p>The unique identifier for the configured table association to update. Currently accepts the configured table association ID.</p>
    ///   - [`membership_identifier(impl Into<String>)`](crate::client::fluent_builders::UpdateConfiguredTableAssociation::membership_identifier) / [`set_membership_identifier(Option<String>)`](crate::client::fluent_builders::UpdateConfiguredTableAssociation::set_membership_identifier): <p>The unique ID for the membership that the configured table association belongs to.</p>
    ///   - [`description(impl Into<String>)`](crate::client::fluent_builders::UpdateConfiguredTableAssociation::description) / [`set_description(Option<String>)`](crate::client::fluent_builders::UpdateConfiguredTableAssociation::set_description): <p>A new description for the configured table association.</p>
    ///   - [`role_arn(impl Into<String>)`](crate::client::fluent_builders::UpdateConfiguredTableAssociation::role_arn) / [`set_role_arn(Option<String>)`](crate::client::fluent_builders::UpdateConfiguredTableAssociation::set_role_arn): <p>The service will assume this role to access catalog metadata and query the table.</p>
    /// - On success, responds with [`UpdateConfiguredTableAssociationOutput`](crate::output::UpdateConfiguredTableAssociationOutput) with field(s):
    ///   - [`configured_table_association(Option<ConfiguredTableAssociation>)`](crate::output::UpdateConfiguredTableAssociationOutput::configured_table_association): <p>The entire updated configured table association.</p>
    /// - On failure, responds with [`SdkError<UpdateConfiguredTableAssociationError>`](crate::error::UpdateConfiguredTableAssociationError)
    pub fn update_configured_table_association(
        &self,
    ) -> fluent_builders::UpdateConfiguredTableAssociation {
        fluent_builders::UpdateConfiguredTableAssociation::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`UpdateMembership`](crate::client::fluent_builders::UpdateMembership) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`membership_identifier(impl Into<String>)`](crate::client::fluent_builders::UpdateMembership::membership_identifier) / [`set_membership_identifier(Option<String>)`](crate::client::fluent_builders::UpdateMembership::set_membership_identifier): <p>The unique identifier of the membership.</p>
    ///   - [`query_log_status(MembershipQueryLogStatus)`](crate::client::fluent_builders::UpdateMembership::query_log_status) / [`set_query_log_status(Option<MembershipQueryLogStatus>)`](crate::client::fluent_builders::UpdateMembership::set_query_log_status): <p>An indicator as to whether query logging has been enabled or disabled for the collaboration.</p>
    /// - On success, responds with [`UpdateMembershipOutput`](crate::output::UpdateMembershipOutput) with field(s):
    ///   - [`membership(Option<Membership>)`](crate::output::UpdateMembershipOutput::membership): <p>The membership object.</p>
    /// - On failure, responds with [`SdkError<UpdateMembershipError>`](crate::error::UpdateMembershipError)
    pub fn update_membership(&self) -> fluent_builders::UpdateMembership {
        fluent_builders::UpdateMembership::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the [`UpdateProtectedQuery`](crate::client::fluent_builders::UpdateProtectedQuery) operation.
    ///
    /// - The fluent builder is configurable:
    ///   - [`membership_identifier(impl Into<String>)`](crate::client::fluent_builders::UpdateProtectedQuery::membership_identifier) / [`set_membership_identifier(Option<String>)`](crate::client::fluent_builders::UpdateProtectedQuery::set_membership_identifier): <p>The identifier for a member of a protected query instance.</p>
    ///   - [`protected_query_identifier(impl Into<String>)`](crate::client::fluent_builders::UpdateProtectedQuery::protected_query_identifier) / [`set_protected_query_identifier(Option<String>)`](crate::client::fluent_builders::UpdateProtectedQuery::set_protected_query_identifier): <p>The identifier for a protected query instance.</p>
    ///   - [`target_status(TargetProtectedQueryStatus)`](crate::client::fluent_builders::UpdateProtectedQuery::target_status) / [`set_target_status(Option<TargetProtectedQueryStatus>)`](crate::client::fluent_builders::UpdateProtectedQuery::set_target_status): <p>The target status of a query. Used to update the execution status of a currently running query.</p>
    /// - On success, responds with [`UpdateProtectedQueryOutput`](crate::output::UpdateProtectedQueryOutput) with field(s):
    ///   - [`protected_query(Option<ProtectedQuery>)`](crate::output::UpdateProtectedQueryOutput::protected_query): <p>The protected query output.</p>
    /// - On failure, responds with [`SdkError<UpdateProtectedQueryError>`](crate::error::UpdateProtectedQueryError)
    pub fn update_protected_query(&self) -> fluent_builders::UpdateProtectedQuery {
        fluent_builders::UpdateProtectedQuery::new(self.handle.clone())
    }
}
pub mod fluent_builders {

    //! Utilities to ergonomically construct a request to the service.
    //!
    //! Fluent builders are created through the [`Client`](crate::client::Client) by calling
    //! one if its operation methods. After parameters are set using the builder methods,
    //! the `send` method can be called to initiate the request.
    /// Fluent builder constructing a request to `BatchGetSchema`.
    ///
    /// <p>Retrieves multiple schemas by their identifiers.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct BatchGetSchema {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::batch_get_schema_input::Builder,
    }
    impl BatchGetSchema {
        /// Creates a new `BatchGetSchema`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::BatchGetSchema,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::BatchGetSchemaError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::BatchGetSchemaOutput,
            aws_smithy_http::result::SdkError<crate::error::BatchGetSchemaError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>A unique identifier for the collaboration that the schemas belong to. Currently accepts collaboration ID.</p>
        pub fn collaboration_identifier(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.collaboration_identifier(input.into());
            self
        }
        /// <p>A unique identifier for the collaboration that the schemas belong to. Currently accepts collaboration ID.</p>
        pub fn set_collaboration_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_collaboration_identifier(input);
            self
        }
        /// Appends an item to `names`.
        ///
        /// To override the contents of this collection use [`set_names`](Self::set_names).
        ///
        /// <p>The names for the schema objects to retrieve.&gt;</p>
        pub fn names(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.names(input.into());
            self
        }
        /// <p>The names for the schema objects to retrieve.&gt;</p>
        pub fn set_names(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.inner = self.inner.set_names(input);
            self
        }
    }
    /// Fluent builder constructing a request to `CreateCollaboration`.
    ///
    /// <p>Creates a new collaboration.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct CreateCollaboration {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::create_collaboration_input::Builder,
    }
    impl CreateCollaboration {
        /// Creates a new `CreateCollaboration`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::CreateCollaboration,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::CreateCollaborationError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::CreateCollaborationOutput,
            aws_smithy_http::result::SdkError<crate::error::CreateCollaborationError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// Appends an item to `members`.
        ///
        /// To override the contents of this collection use [`set_members`](Self::set_members).
        ///
        /// <p>A list of initial members, not including the creator. This list is immutable.</p>
        pub fn members(mut self, input: crate::model::MemberSpecification) -> Self {
            self.inner = self.inner.members(input);
            self
        }
        /// <p>A list of initial members, not including the creator. This list is immutable.</p>
        pub fn set_members(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::MemberSpecification>>,
        ) -> Self {
            self.inner = self.inner.set_members(input);
            self
        }
        /// <p>The display name for a collaboration.</p>
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.name(input.into());
            self
        }
        /// <p>The display name for a collaboration.</p>
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_name(input);
            self
        }
        /// <p>A description of the collaboration provided by the collaboration owner.</p>
        pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.description(input.into());
            self
        }
        /// <p>A description of the collaboration provided by the collaboration owner.</p>
        pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_description(input);
            self
        }
        /// Appends an item to `creatorMemberAbilities`.
        ///
        /// To override the contents of this collection use [`set_creator_member_abilities`](Self::set_creator_member_abilities).
        ///
        /// <p>The abilities granted to the collaboration creator.</p>
        pub fn creator_member_abilities(mut self, input: crate::model::MemberAbility) -> Self {
            self.inner = self.inner.creator_member_abilities(input);
            self
        }
        /// <p>The abilities granted to the collaboration creator.</p>
        pub fn set_creator_member_abilities(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::MemberAbility>>,
        ) -> Self {
            self.inner = self.inner.set_creator_member_abilities(input);
            self
        }
        /// <p>The display name of the collaboration creator.</p>
        pub fn creator_display_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.creator_display_name(input.into());
            self
        }
        /// <p>The display name of the collaboration creator.</p>
        pub fn set_creator_display_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_creator_display_name(input);
            self
        }
        /// <p>The settings for client-side encryption with Cryptographic Computing for Clean Rooms.</p>
        pub fn data_encryption_metadata(
            mut self,
            input: crate::model::DataEncryptionMetadata,
        ) -> Self {
            self.inner = self.inner.data_encryption_metadata(input);
            self
        }
        /// <p>The settings for client-side encryption with Cryptographic Computing for Clean Rooms.</p>
        pub fn set_data_encryption_metadata(
            mut self,
            input: std::option::Option<crate::model::DataEncryptionMetadata>,
        ) -> Self {
            self.inner = self.inner.set_data_encryption_metadata(input);
            self
        }
        /// <p>An indicator as to whether query logging has been enabled or disabled for the collaboration.</p>
        pub fn query_log_status(
            mut self,
            input: crate::model::CollaborationQueryLogStatus,
        ) -> Self {
            self.inner = self.inner.query_log_status(input);
            self
        }
        /// <p>An indicator as to whether query logging has been enabled or disabled for the collaboration.</p>
        pub fn set_query_log_status(
            mut self,
            input: std::option::Option<crate::model::CollaborationQueryLogStatus>,
        ) -> Self {
            self.inner = self.inner.set_query_log_status(input);
            self
        }
    }
    /// Fluent builder constructing a request to `CreateConfiguredTable`.
    ///
    /// <p>Creates a new configured table resource.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct CreateConfiguredTable {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::create_configured_table_input::Builder,
    }
    impl CreateConfiguredTable {
        /// Creates a new `CreateConfiguredTable`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::CreateConfiguredTable,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::CreateConfiguredTableError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::CreateConfiguredTableOutput,
            aws_smithy_http::result::SdkError<crate::error::CreateConfiguredTableError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The name of the configured table.</p>
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.name(input.into());
            self
        }
        /// <p>The name of the configured table.</p>
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_name(input);
            self
        }
        /// <p>A description for the configured table.</p>
        pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.description(input.into());
            self
        }
        /// <p>A description for the configured table.</p>
        pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_description(input);
            self
        }
        /// <p>A reference to the AWS Glue table being configured.</p>
        pub fn table_reference(mut self, input: crate::model::TableReference) -> Self {
            self.inner = self.inner.table_reference(input);
            self
        }
        /// <p>A reference to the AWS Glue table being configured.</p>
        pub fn set_table_reference(
            mut self,
            input: std::option::Option<crate::model::TableReference>,
        ) -> Self {
            self.inner = self.inner.set_table_reference(input);
            self
        }
        /// Appends an item to `allowedColumns`.
        ///
        /// To override the contents of this collection use [`set_allowed_columns`](Self::set_allowed_columns).
        ///
        /// <p>The columns of the underlying table that can be used by collaborations or analysis rules.</p>
        pub fn allowed_columns(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.allowed_columns(input.into());
            self
        }
        /// <p>The columns of the underlying table that can be used by collaborations or analysis rules.</p>
        pub fn set_allowed_columns(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.inner = self.inner.set_allowed_columns(input);
            self
        }
        /// <p>The analysis method for the configured tables. The only valid value is currently `DIRECT_QUERY`.</p>
        pub fn analysis_method(mut self, input: crate::model::AnalysisMethod) -> Self {
            self.inner = self.inner.analysis_method(input);
            self
        }
        /// <p>The analysis method for the configured tables. The only valid value is currently `DIRECT_QUERY`.</p>
        pub fn set_analysis_method(
            mut self,
            input: std::option::Option<crate::model::AnalysisMethod>,
        ) -> Self {
            self.inner = self.inner.set_analysis_method(input);
            self
        }
    }
    /// Fluent builder constructing a request to `CreateConfiguredTableAnalysisRule`.
    ///
    /// <p>Creates a new analysis rule for a configured table. Currently, only one analysis rule can be created for a given configured table.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct CreateConfiguredTableAnalysisRule {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::create_configured_table_analysis_rule_input::Builder,
    }
    impl CreateConfiguredTableAnalysisRule {
        /// Creates a new `CreateConfiguredTableAnalysisRule`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::CreateConfiguredTableAnalysisRule,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::CreateConfiguredTableAnalysisRuleError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::CreateConfiguredTableAnalysisRuleOutput,
            aws_smithy_http::result::SdkError<crate::error::CreateConfiguredTableAnalysisRuleError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The identifier for the configured table to create the analysis rule for. Currently accepts the configured table ID. </p>
        pub fn configured_table_identifier(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self.inner.configured_table_identifier(input.into());
            self
        }
        /// <p>The identifier for the configured table to create the analysis rule for. Currently accepts the configured table ID. </p>
        pub fn set_configured_table_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_configured_table_identifier(input);
            self
        }
        /// <p>The type of analysis rule. Valid values are AGGREGATION and LIST.</p>
        pub fn analysis_rule_type(
            mut self,
            input: crate::model::ConfiguredTableAnalysisRuleType,
        ) -> Self {
            self.inner = self.inner.analysis_rule_type(input);
            self
        }
        /// <p>The type of analysis rule. Valid values are AGGREGATION and LIST.</p>
        pub fn set_analysis_rule_type(
            mut self,
            input: std::option::Option<crate::model::ConfiguredTableAnalysisRuleType>,
        ) -> Self {
            self.inner = self.inner.set_analysis_rule_type(input);
            self
        }
        /// <p>The entire created configured table analysis rule object.</p>
        pub fn analysis_rule_policy(
            mut self,
            input: crate::model::ConfiguredTableAnalysisRulePolicy,
        ) -> Self {
            self.inner = self.inner.analysis_rule_policy(input);
            self
        }
        /// <p>The entire created configured table analysis rule object.</p>
        pub fn set_analysis_rule_policy(
            mut self,
            input: std::option::Option<crate::model::ConfiguredTableAnalysisRulePolicy>,
        ) -> Self {
            self.inner = self.inner.set_analysis_rule_policy(input);
            self
        }
    }
    /// Fluent builder constructing a request to `CreateConfiguredTableAssociation`.
    ///
    /// <p>Creates a configured table association. A configured table association links a configured table with a collaboration.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct CreateConfiguredTableAssociation {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::create_configured_table_association_input::Builder,
    }
    impl CreateConfiguredTableAssociation {
        /// Creates a new `CreateConfiguredTableAssociation`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::CreateConfiguredTableAssociation,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::CreateConfiguredTableAssociationError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::CreateConfiguredTableAssociationOutput,
            aws_smithy_http::result::SdkError<crate::error::CreateConfiguredTableAssociationError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The name of the configured table association. This name is used to query the underlying configured table.</p>
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.name(input.into());
            self
        }
        /// <p>The name of the configured table association. This name is used to query the underlying configured table.</p>
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_name(input);
            self
        }
        /// <p>A description for the configured table association.</p>
        pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.description(input.into());
            self
        }
        /// <p>A description for the configured table association.</p>
        pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_description(input);
            self
        }
        /// <p>A unique identifier for one of your memberships for a collaboration. The configured table is associated to the collaboration that this membership belongs to. Currently accepts a membership ID.</p>
        pub fn membership_identifier(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.membership_identifier(input.into());
            self
        }
        /// <p>A unique identifier for one of your memberships for a collaboration. The configured table is associated to the collaboration that this membership belongs to. Currently accepts a membership ID.</p>
        pub fn set_membership_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_membership_identifier(input);
            self
        }
        /// <p>A unique identifier for the configured table to be associated to. Currently accepts a configured table ID.</p>
        pub fn configured_table_identifier(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self.inner.configured_table_identifier(input.into());
            self
        }
        /// <p>A unique identifier for the configured table to be associated to. Currently accepts a configured table ID.</p>
        pub fn set_configured_table_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_configured_table_identifier(input);
            self
        }
        /// <p>The service will assume this role to access catalog metadata and query the table.</p>
        pub fn role_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.role_arn(input.into());
            self
        }
        /// <p>The service will assume this role to access catalog metadata and query the table.</p>
        pub fn set_role_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_role_arn(input);
            self
        }
    }
    /// Fluent builder constructing a request to `CreateMembership`.
    ///
    /// <p>Creates a membership for a specific collaboration identifier and joins the collaboration.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct CreateMembership {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::create_membership_input::Builder,
    }
    impl CreateMembership {
        /// Creates a new `CreateMembership`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::CreateMembership,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::CreateMembershipError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::CreateMembershipOutput,
            aws_smithy_http::result::SdkError<crate::error::CreateMembershipError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The unique ID for the associated collaboration.</p>
        pub fn collaboration_identifier(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.collaboration_identifier(input.into());
            self
        }
        /// <p>The unique ID for the associated collaboration.</p>
        pub fn set_collaboration_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_collaboration_identifier(input);
            self
        }
        /// <p>An indicator as to whether query logging has been enabled or disabled for the collaboration.</p>
        pub fn query_log_status(mut self, input: crate::model::MembershipQueryLogStatus) -> Self {
            self.inner = self.inner.query_log_status(input);
            self
        }
        /// <p>An indicator as to whether query logging has been enabled or disabled for the collaboration.</p>
        pub fn set_query_log_status(
            mut self,
            input: std::option::Option<crate::model::MembershipQueryLogStatus>,
        ) -> Self {
            self.inner = self.inner.set_query_log_status(input);
            self
        }
    }
    /// Fluent builder constructing a request to `DeleteCollaboration`.
    ///
    /// <p>Deletes a collaboration. It can only be called by the collaboration owner.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct DeleteCollaboration {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::delete_collaboration_input::Builder,
    }
    impl DeleteCollaboration {
        /// Creates a new `DeleteCollaboration`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::DeleteCollaboration,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::DeleteCollaborationError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::DeleteCollaborationOutput,
            aws_smithy_http::result::SdkError<crate::error::DeleteCollaborationError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The identifier for the collaboration.</p>
        pub fn collaboration_identifier(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.collaboration_identifier(input.into());
            self
        }
        /// <p>The identifier for the collaboration.</p>
        pub fn set_collaboration_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_collaboration_identifier(input);
            self
        }
    }
    /// Fluent builder constructing a request to `DeleteConfiguredTable`.
    ///
    /// <p>Deletes a configured table.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct DeleteConfiguredTable {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::delete_configured_table_input::Builder,
    }
    impl DeleteConfiguredTable {
        /// Creates a new `DeleteConfiguredTable`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::DeleteConfiguredTable,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::DeleteConfiguredTableError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::DeleteConfiguredTableOutput,
            aws_smithy_http::result::SdkError<crate::error::DeleteConfiguredTableError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The unique ID for the configured table to delete.</p>
        pub fn configured_table_identifier(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self.inner.configured_table_identifier(input.into());
            self
        }
        /// <p>The unique ID for the configured table to delete.</p>
        pub fn set_configured_table_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_configured_table_identifier(input);
            self
        }
    }
    /// Fluent builder constructing a request to `DeleteConfiguredTableAnalysisRule`.
    ///
    /// <p>Deletes a configured table analysis rule.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct DeleteConfiguredTableAnalysisRule {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::delete_configured_table_analysis_rule_input::Builder,
    }
    impl DeleteConfiguredTableAnalysisRule {
        /// Creates a new `DeleteConfiguredTableAnalysisRule`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::DeleteConfiguredTableAnalysisRule,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::DeleteConfiguredTableAnalysisRuleError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::DeleteConfiguredTableAnalysisRuleOutput,
            aws_smithy_http::result::SdkError<crate::error::DeleteConfiguredTableAnalysisRuleError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The unique identifier for the configured table that the analysis rule applies to. Currently accepts the configured table ID.</p>
        pub fn configured_table_identifier(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self.inner.configured_table_identifier(input.into());
            self
        }
        /// <p>The unique identifier for the configured table that the analysis rule applies to. Currently accepts the configured table ID.</p>
        pub fn set_configured_table_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_configured_table_identifier(input);
            self
        }
        /// <p>The analysis rule type to be deleted. Configured table analysis rules are uniquely identified by their configured table identifier and analysis rule type.</p>
        pub fn analysis_rule_type(
            mut self,
            input: crate::model::ConfiguredTableAnalysisRuleType,
        ) -> Self {
            self.inner = self.inner.analysis_rule_type(input);
            self
        }
        /// <p>The analysis rule type to be deleted. Configured table analysis rules are uniquely identified by their configured table identifier and analysis rule type.</p>
        pub fn set_analysis_rule_type(
            mut self,
            input: std::option::Option<crate::model::ConfiguredTableAnalysisRuleType>,
        ) -> Self {
            self.inner = self.inner.set_analysis_rule_type(input);
            self
        }
    }
    /// Fluent builder constructing a request to `DeleteConfiguredTableAssociation`.
    ///
    /// <p>Deletes a configured table association.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct DeleteConfiguredTableAssociation {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::delete_configured_table_association_input::Builder,
    }
    impl DeleteConfiguredTableAssociation {
        /// Creates a new `DeleteConfiguredTableAssociation`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::DeleteConfiguredTableAssociation,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::DeleteConfiguredTableAssociationError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::DeleteConfiguredTableAssociationOutput,
            aws_smithy_http::result::SdkError<crate::error::DeleteConfiguredTableAssociationError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The unique ID for the configured table association to be deleted. Currently accepts the configured table ID.</p>
        pub fn configured_table_association_identifier(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self
                .inner
                .configured_table_association_identifier(input.into());
            self
        }
        /// <p>The unique ID for the configured table association to be deleted. Currently accepts the configured table ID.</p>
        pub fn set_configured_table_association_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self
                .inner
                .set_configured_table_association_identifier(input);
            self
        }
        /// <p>A unique identifier for the membership that the configured table association belongs to. Currently accepts the membership ID.</p>
        pub fn membership_identifier(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.membership_identifier(input.into());
            self
        }
        /// <p>A unique identifier for the membership that the configured table association belongs to. Currently accepts the membership ID.</p>
        pub fn set_membership_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_membership_identifier(input);
            self
        }
    }
    /// Fluent builder constructing a request to `DeleteMember`.
    ///
    /// <p>Removes the specified member from a collaboration. The removed member is placed in the Removed status and can't interact with the collaboration. The removed member's data is inaccessible to active members of the collaboration.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct DeleteMember {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::delete_member_input::Builder,
    }
    impl DeleteMember {
        /// Creates a new `DeleteMember`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::DeleteMember,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::DeleteMemberError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::DeleteMemberOutput,
            aws_smithy_http::result::SdkError<crate::error::DeleteMemberError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The unique identifier for the associated collaboration.</p>
        pub fn collaboration_identifier(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.collaboration_identifier(input.into());
            self
        }
        /// <p>The unique identifier for the associated collaboration.</p>
        pub fn set_collaboration_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_collaboration_identifier(input);
            self
        }
        /// <p>The account ID of the member to remove.</p>
        pub fn account_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.account_id(input.into());
            self
        }
        /// <p>The account ID of the member to remove.</p>
        pub fn set_account_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_account_id(input);
            self
        }
    }
    /// Fluent builder constructing a request to `DeleteMembership`.
    ///
    /// <p>Deletes a specified membership. All resources under a membership must be deleted.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct DeleteMembership {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::delete_membership_input::Builder,
    }
    impl DeleteMembership {
        /// Creates a new `DeleteMembership`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::DeleteMembership,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::DeleteMembershipError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::DeleteMembershipOutput,
            aws_smithy_http::result::SdkError<crate::error::DeleteMembershipError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The identifier for a membership resource.</p>
        pub fn membership_identifier(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.membership_identifier(input.into());
            self
        }
        /// <p>The identifier for a membership resource.</p>
        pub fn set_membership_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_membership_identifier(input);
            self
        }
    }
    /// Fluent builder constructing a request to `GetCollaboration`.
    ///
    /// <p>Returns metadata about a collaboration.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct GetCollaboration {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::get_collaboration_input::Builder,
    }
    impl GetCollaboration {
        /// Creates a new `GetCollaboration`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::GetCollaboration,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::GetCollaborationError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::GetCollaborationOutput,
            aws_smithy_http::result::SdkError<crate::error::GetCollaborationError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The identifier for the collaboration.</p>
        pub fn collaboration_identifier(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.collaboration_identifier(input.into());
            self
        }
        /// <p>The identifier for the collaboration.</p>
        pub fn set_collaboration_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_collaboration_identifier(input);
            self
        }
    }
    /// Fluent builder constructing a request to `GetConfiguredTable`.
    ///
    /// <p>Retrieves a configured table.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct GetConfiguredTable {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::get_configured_table_input::Builder,
    }
    impl GetConfiguredTable {
        /// Creates a new `GetConfiguredTable`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::GetConfiguredTable,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::GetConfiguredTableError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::GetConfiguredTableOutput,
            aws_smithy_http::result::SdkError<crate::error::GetConfiguredTableError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The unique ID for the configured table to retrieve.</p>
        pub fn configured_table_identifier(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self.inner.configured_table_identifier(input.into());
            self
        }
        /// <p>The unique ID for the configured table to retrieve.</p>
        pub fn set_configured_table_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_configured_table_identifier(input);
            self
        }
    }
    /// Fluent builder constructing a request to `GetConfiguredTableAnalysisRule`.
    ///
    /// <p>Retrieves a configured table analysis rule.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct GetConfiguredTableAnalysisRule {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::get_configured_table_analysis_rule_input::Builder,
    }
    impl GetConfiguredTableAnalysisRule {
        /// Creates a new `GetConfiguredTableAnalysisRule`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::GetConfiguredTableAnalysisRule,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::GetConfiguredTableAnalysisRuleError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::GetConfiguredTableAnalysisRuleOutput,
            aws_smithy_http::result::SdkError<crate::error::GetConfiguredTableAnalysisRuleError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The unique identifier for the configured table to retrieve. Currently accepts the configured table ID.</p>
        pub fn configured_table_identifier(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self.inner.configured_table_identifier(input.into());
            self
        }
        /// <p>The unique identifier for the configured table to retrieve. Currently accepts the configured table ID.</p>
        pub fn set_configured_table_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_configured_table_identifier(input);
            self
        }
        /// <p>The analysis rule to be retrieved. Configured table analysis rules are uniquely identified by their configured table identifier and analysis rule type.</p>
        pub fn analysis_rule_type(
            mut self,
            input: crate::model::ConfiguredTableAnalysisRuleType,
        ) -> Self {
            self.inner = self.inner.analysis_rule_type(input);
            self
        }
        /// <p>The analysis rule to be retrieved. Configured table analysis rules are uniquely identified by their configured table identifier and analysis rule type.</p>
        pub fn set_analysis_rule_type(
            mut self,
            input: std::option::Option<crate::model::ConfiguredTableAnalysisRuleType>,
        ) -> Self {
            self.inner = self.inner.set_analysis_rule_type(input);
            self
        }
    }
    /// Fluent builder constructing a request to `GetConfiguredTableAssociation`.
    ///
    /// <p>Retrieves a configured table association.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct GetConfiguredTableAssociation {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::get_configured_table_association_input::Builder,
    }
    impl GetConfiguredTableAssociation {
        /// Creates a new `GetConfiguredTableAssociation`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::GetConfiguredTableAssociation,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::GetConfiguredTableAssociationError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::GetConfiguredTableAssociationOutput,
            aws_smithy_http::result::SdkError<crate::error::GetConfiguredTableAssociationError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The unique ID for the configured table association to retrieve. Currently accepts the configured table ID.</p>
        pub fn configured_table_association_identifier(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self
                .inner
                .configured_table_association_identifier(input.into());
            self
        }
        /// <p>The unique ID for the configured table association to retrieve. Currently accepts the configured table ID.</p>
        pub fn set_configured_table_association_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self
                .inner
                .set_configured_table_association_identifier(input);
            self
        }
        /// <p>A unique identifier for the membership that the configured table association belongs to. Currently accepts the membership ID.</p>
        pub fn membership_identifier(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.membership_identifier(input.into());
            self
        }
        /// <p>A unique identifier for the membership that the configured table association belongs to. Currently accepts the membership ID.</p>
        pub fn set_membership_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_membership_identifier(input);
            self
        }
    }
    /// Fluent builder constructing a request to `GetMembership`.
    ///
    /// <p>Retrieves a specified membership for an identifier.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct GetMembership {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::get_membership_input::Builder,
    }
    impl GetMembership {
        /// Creates a new `GetMembership`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::GetMembership,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::GetMembershipError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::GetMembershipOutput,
            aws_smithy_http::result::SdkError<crate::error::GetMembershipError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The identifier for a membership resource.</p>
        pub fn membership_identifier(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.membership_identifier(input.into());
            self
        }
        /// <p>The identifier for a membership resource.</p>
        pub fn set_membership_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_membership_identifier(input);
            self
        }
    }
    /// Fluent builder constructing a request to `GetProtectedQuery`.
    ///
    /// <p>Returns query processing metadata.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct GetProtectedQuery {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::get_protected_query_input::Builder,
    }
    impl GetProtectedQuery {
        /// Creates a new `GetProtectedQuery`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::GetProtectedQuery,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::GetProtectedQueryError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::GetProtectedQueryOutput,
            aws_smithy_http::result::SdkError<crate::error::GetProtectedQueryError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The identifier for a membership in a protected query instance.</p>
        pub fn membership_identifier(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.membership_identifier(input.into());
            self
        }
        /// <p>The identifier for a membership in a protected query instance.</p>
        pub fn set_membership_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_membership_identifier(input);
            self
        }
        /// <p>The identifier for a protected query instance.</p>
        pub fn protected_query_identifier(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.protected_query_identifier(input.into());
            self
        }
        /// <p>The identifier for a protected query instance.</p>
        pub fn set_protected_query_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_protected_query_identifier(input);
            self
        }
    }
    /// Fluent builder constructing a request to `GetSchema`.
    ///
    /// <p>Retrieves the schema for a relation within a collaboration.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct GetSchema {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::get_schema_input::Builder,
    }
    impl GetSchema {
        /// Creates a new `GetSchema`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::GetSchema,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::GetSchemaError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::GetSchemaOutput,
            aws_smithy_http::result::SdkError<crate::error::GetSchemaError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>A unique identifier for the collaboration that the schema belongs to. Currently accepts a collaboration ID.</p>
        pub fn collaboration_identifier(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.collaboration_identifier(input.into());
            self
        }
        /// <p>A unique identifier for the collaboration that the schema belongs to. Currently accepts a collaboration ID.</p>
        pub fn set_collaboration_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_collaboration_identifier(input);
            self
        }
        /// <p>The name of the relation to retrieve the schema for.</p>
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.name(input.into());
            self
        }
        /// <p>The name of the relation to retrieve the schema for.</p>
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_name(input);
            self
        }
    }
    /// Fluent builder constructing a request to `GetSchemaAnalysisRule`.
    ///
    /// <p>Retrieves a schema analysis rule.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct GetSchemaAnalysisRule {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::get_schema_analysis_rule_input::Builder,
    }
    impl GetSchemaAnalysisRule {
        /// Creates a new `GetSchemaAnalysisRule`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::GetSchemaAnalysisRule,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::GetSchemaAnalysisRuleError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::GetSchemaAnalysisRuleOutput,
            aws_smithy_http::result::SdkError<crate::error::GetSchemaAnalysisRuleError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>A unique identifier for the collaboration that the schema belongs to. Currently accepts a collaboration ID.</p>
        pub fn collaboration_identifier(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.collaboration_identifier(input.into());
            self
        }
        /// <p>A unique identifier for the collaboration that the schema belongs to. Currently accepts a collaboration ID.</p>
        pub fn set_collaboration_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_collaboration_identifier(input);
            self
        }
        /// <p>The name of the schema to retrieve the analysis rule for.</p>
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.name(input.into());
            self
        }
        /// <p>The name of the schema to retrieve the analysis rule for.</p>
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_name(input);
            self
        }
        /// <p>The type of the schema analysis rule to retrieve. Schema analysis rules are uniquely identified by a combination of the collaboration, the schema name, and their type.</p>
        pub fn r#type(mut self, input: crate::model::AnalysisRuleType) -> Self {
            self.inner = self.inner.r#type(input);
            self
        }
        /// <p>The type of the schema analysis rule to retrieve. Schema analysis rules are uniquely identified by a combination of the collaboration, the schema name, and their type.</p>
        pub fn set_type(
            mut self,
            input: std::option::Option<crate::model::AnalysisRuleType>,
        ) -> Self {
            self.inner = self.inner.set_type(input);
            self
        }
    }
    /// Fluent builder constructing a request to `ListCollaborations`.
    ///
    /// <p>Lists collaborations the caller owns, is active in, or has been invited to.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct ListCollaborations {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::list_collaborations_input::Builder,
    }
    impl ListCollaborations {
        /// Creates a new `ListCollaborations`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::ListCollaborations,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::ListCollaborationsError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::ListCollaborationsOutput,
            aws_smithy_http::result::SdkError<crate::error::ListCollaborationsError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// Create a paginator for this request
        ///
        /// Paginators are used by calling [`send().await`](crate::paginator::ListCollaborationsPaginator::send) which returns a [`Stream`](tokio_stream::Stream).
        pub fn into_paginator(self) -> crate::paginator::ListCollaborationsPaginator {
            crate::paginator::ListCollaborationsPaginator::new(self.handle, self.inner)
        }
        /// <p>The token value retrieved from a previous call to access the next page of results.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(input.into());
            self
        }
        /// <p>The token value retrieved from a previous call to access the next page of results.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_next_token(input);
            self
        }
        /// <p>The maximum size of the results that is returned per call. Service chooses a default if it has not been set. Service may return a nextToken even if the maximum results has not been met.</p>
        pub fn max_results(mut self, input: i32) -> Self {
            self.inner = self.inner.max_results(input);
            self
        }
        /// <p>The maximum size of the results that is returned per call. Service chooses a default if it has not been set. Service may return a nextToken even if the maximum results has not been met.</p>
        pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
            self.inner = self.inner.set_max_results(input);
            self
        }
        /// <p>The caller's status in a collaboration.</p>
        pub fn member_status(mut self, input: crate::model::FilterableMemberStatus) -> Self {
            self.inner = self.inner.member_status(input);
            self
        }
        /// <p>The caller's status in a collaboration.</p>
        pub fn set_member_status(
            mut self,
            input: std::option::Option<crate::model::FilterableMemberStatus>,
        ) -> Self {
            self.inner = self.inner.set_member_status(input);
            self
        }
    }
    /// Fluent builder constructing a request to `ListConfiguredTableAssociations`.
    ///
    /// <p>Lists configured table associations for a membership.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct ListConfiguredTableAssociations {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::list_configured_table_associations_input::Builder,
    }
    impl ListConfiguredTableAssociations {
        /// Creates a new `ListConfiguredTableAssociations`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::ListConfiguredTableAssociations,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::ListConfiguredTableAssociationsError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::ListConfiguredTableAssociationsOutput,
            aws_smithy_http::result::SdkError<crate::error::ListConfiguredTableAssociationsError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// Create a paginator for this request
        ///
        /// Paginators are used by calling [`send().await`](crate::paginator::ListConfiguredTableAssociationsPaginator::send) which returns a [`Stream`](tokio_stream::Stream).
        pub fn into_paginator(self) -> crate::paginator::ListConfiguredTableAssociationsPaginator {
            crate::paginator::ListConfiguredTableAssociationsPaginator::new(self.handle, self.inner)
        }
        /// <p>A unique identifier for the membership to list configured table associations for. Currently accepts the membership ID.</p>
        pub fn membership_identifier(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.membership_identifier(input.into());
            self
        }
        /// <p>A unique identifier for the membership to list configured table associations for. Currently accepts the membership ID.</p>
        pub fn set_membership_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_membership_identifier(input);
            self
        }
        /// <p>The token value retrieved from a previous call to access the next page of results.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(input.into());
            self
        }
        /// <p>The token value retrieved from a previous call to access the next page of results.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_next_token(input);
            self
        }
        /// <p>The maximum size of the results that is returned per call.</p>
        pub fn max_results(mut self, input: i32) -> Self {
            self.inner = self.inner.max_results(input);
            self
        }
        /// <p>The maximum size of the results that is returned per call.</p>
        pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
            self.inner = self.inner.set_max_results(input);
            self
        }
    }
    /// Fluent builder constructing a request to `ListConfiguredTables`.
    ///
    /// <p>Lists configured tables.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct ListConfiguredTables {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::list_configured_tables_input::Builder,
    }
    impl ListConfiguredTables {
        /// Creates a new `ListConfiguredTables`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::ListConfiguredTables,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::ListConfiguredTablesError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::ListConfiguredTablesOutput,
            aws_smithy_http::result::SdkError<crate::error::ListConfiguredTablesError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// Create a paginator for this request
        ///
        /// Paginators are used by calling [`send().await`](crate::paginator::ListConfiguredTablesPaginator::send) which returns a [`Stream`](tokio_stream::Stream).
        pub fn into_paginator(self) -> crate::paginator::ListConfiguredTablesPaginator {
            crate::paginator::ListConfiguredTablesPaginator::new(self.handle, self.inner)
        }
        /// <p>The token value retrieved from a previous call to access the next page of results.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(input.into());
            self
        }
        /// <p>The token value retrieved from a previous call to access the next page of results.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_next_token(input);
            self
        }
        /// <p>The maximum size of the results that is returned per call.</p>
        pub fn max_results(mut self, input: i32) -> Self {
            self.inner = self.inner.max_results(input);
            self
        }
        /// <p>The maximum size of the results that is returned per call.</p>
        pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
            self.inner = self.inner.set_max_results(input);
            self
        }
    }
    /// Fluent builder constructing a request to `ListMembers`.
    ///
    /// <p>Lists all members within a collaboration.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct ListMembers {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::list_members_input::Builder,
    }
    impl ListMembers {
        /// Creates a new `ListMembers`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::ListMembers,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::ListMembersError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::ListMembersOutput,
            aws_smithy_http::result::SdkError<crate::error::ListMembersError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// Create a paginator for this request
        ///
        /// Paginators are used by calling [`send().await`](crate::paginator::ListMembersPaginator::send) which returns a [`Stream`](tokio_stream::Stream).
        pub fn into_paginator(self) -> crate::paginator::ListMembersPaginator {
            crate::paginator::ListMembersPaginator::new(self.handle, self.inner)
        }
        /// <p>The identifier of the collaboration in which the members are listed.</p>
        pub fn collaboration_identifier(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.collaboration_identifier(input.into());
            self
        }
        /// <p>The identifier of the collaboration in which the members are listed.</p>
        pub fn set_collaboration_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_collaboration_identifier(input);
            self
        }
        /// <p>The token value retrieved from a previous call to access the next page of results.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(input.into());
            self
        }
        /// <p>The token value retrieved from a previous call to access the next page of results.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_next_token(input);
            self
        }
        /// <p>The maximum size of the results that is returned per call.</p>
        pub fn max_results(mut self, input: i32) -> Self {
            self.inner = self.inner.max_results(input);
            self
        }
        /// <p>The maximum size of the results that is returned per call.</p>
        pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
            self.inner = self.inner.set_max_results(input);
            self
        }
    }
    /// Fluent builder constructing a request to `ListMemberships`.
    ///
    /// <p>Lists all memberships resources within the caller's account.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct ListMemberships {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::list_memberships_input::Builder,
    }
    impl ListMemberships {
        /// Creates a new `ListMemberships`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::ListMemberships,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::ListMembershipsError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::ListMembershipsOutput,
            aws_smithy_http::result::SdkError<crate::error::ListMembershipsError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// Create a paginator for this request
        ///
        /// Paginators are used by calling [`send().await`](crate::paginator::ListMembershipsPaginator::send) which returns a [`Stream`](tokio_stream::Stream).
        pub fn into_paginator(self) -> crate::paginator::ListMembershipsPaginator {
            crate::paginator::ListMembershipsPaginator::new(self.handle, self.inner)
        }
        /// <p>The token value retrieved from a previous call to access the next page of results.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(input.into());
            self
        }
        /// <p>The token value retrieved from a previous call to access the next page of results.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_next_token(input);
            self
        }
        /// <p>The maximum size of the results that is returned per call.</p>
        pub fn max_results(mut self, input: i32) -> Self {
            self.inner = self.inner.max_results(input);
            self
        }
        /// <p>The maximum size of the results that is returned per call.</p>
        pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
            self.inner = self.inner.set_max_results(input);
            self
        }
        /// <p>A filter which will return only memberships in the specified status.</p>
        pub fn status(mut self, input: crate::model::MembershipStatus) -> Self {
            self.inner = self.inner.status(input);
            self
        }
        /// <p>A filter which will return only memberships in the specified status.</p>
        pub fn set_status(
            mut self,
            input: std::option::Option<crate::model::MembershipStatus>,
        ) -> Self {
            self.inner = self.inner.set_status(input);
            self
        }
    }
    /// Fluent builder constructing a request to `ListProtectedQueries`.
    ///
    /// <p>Lists protected queries, sorted by the most recent query.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct ListProtectedQueries {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::list_protected_queries_input::Builder,
    }
    impl ListProtectedQueries {
        /// Creates a new `ListProtectedQueries`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::ListProtectedQueries,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::ListProtectedQueriesError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::ListProtectedQueriesOutput,
            aws_smithy_http::result::SdkError<crate::error::ListProtectedQueriesError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// Create a paginator for this request
        ///
        /// Paginators are used by calling [`send().await`](crate::paginator::ListProtectedQueriesPaginator::send) which returns a [`Stream`](tokio_stream::Stream).
        pub fn into_paginator(self) -> crate::paginator::ListProtectedQueriesPaginator {
            crate::paginator::ListProtectedQueriesPaginator::new(self.handle, self.inner)
        }
        /// <p>The identifier for the membership in the collaboration.</p>
        pub fn membership_identifier(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.membership_identifier(input.into());
            self
        }
        /// <p>The identifier for the membership in the collaboration.</p>
        pub fn set_membership_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_membership_identifier(input);
            self
        }
        /// <p>A filter on the status of the protected query.</p>
        pub fn status(mut self, input: crate::model::ProtectedQueryStatus) -> Self {
            self.inner = self.inner.status(input);
            self
        }
        /// <p>A filter on the status of the protected query.</p>
        pub fn set_status(
            mut self,
            input: std::option::Option<crate::model::ProtectedQueryStatus>,
        ) -> Self {
            self.inner = self.inner.set_status(input);
            self
        }
        /// <p>The token value retrieved from a previous call to access the next page of results.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(input.into());
            self
        }
        /// <p>The token value retrieved from a previous call to access the next page of results.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_next_token(input);
            self
        }
        /// <p>The maximum size of the results that is returned per call. Service chooses a default if it has not been set. Service can return a nextToken even if the maximum results has not been met. </p>
        pub fn max_results(mut self, input: i32) -> Self {
            self.inner = self.inner.max_results(input);
            self
        }
        /// <p>The maximum size of the results that is returned per call. Service chooses a default if it has not been set. Service can return a nextToken even if the maximum results has not been met. </p>
        pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
            self.inner = self.inner.set_max_results(input);
            self
        }
    }
    /// Fluent builder constructing a request to `ListSchemas`.
    ///
    /// <p>Lists the schemas for relations within a collaboration.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct ListSchemas {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::list_schemas_input::Builder,
    }
    impl ListSchemas {
        /// Creates a new `ListSchemas`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::ListSchemas,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::ListSchemasError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::ListSchemasOutput,
            aws_smithy_http::result::SdkError<crate::error::ListSchemasError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// Create a paginator for this request
        ///
        /// Paginators are used by calling [`send().await`](crate::paginator::ListSchemasPaginator::send) which returns a [`Stream`](tokio_stream::Stream).
        pub fn into_paginator(self) -> crate::paginator::ListSchemasPaginator {
            crate::paginator::ListSchemasPaginator::new(self.handle, self.inner)
        }
        /// <p>A unique identifier for the collaboration that the schema belongs to. Currently accepts a collaboration ID.</p>
        pub fn collaboration_identifier(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.collaboration_identifier(input.into());
            self
        }
        /// <p>A unique identifier for the collaboration that the schema belongs to. Currently accepts a collaboration ID.</p>
        pub fn set_collaboration_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_collaboration_identifier(input);
            self
        }
        /// <p>If present, filter schemas by schema type. The only valid schema type is currently `TABLE`.</p>
        pub fn schema_type(mut self, input: crate::model::SchemaType) -> Self {
            self.inner = self.inner.schema_type(input);
            self
        }
        /// <p>If present, filter schemas by schema type. The only valid schema type is currently `TABLE`.</p>
        pub fn set_schema_type(
            mut self,
            input: std::option::Option<crate::model::SchemaType>,
        ) -> Self {
            self.inner = self.inner.set_schema_type(input);
            self
        }
        /// <p>The token value retrieved from a previous call to access the next page of results.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(input.into());
            self
        }
        /// <p>The token value retrieved from a previous call to access the next page of results.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_next_token(input);
            self
        }
        /// <p>The maximum size of the results that is returned per call.</p>
        pub fn max_results(mut self, input: i32) -> Self {
            self.inner = self.inner.max_results(input);
            self
        }
        /// <p>The maximum size of the results that is returned per call.</p>
        pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
            self.inner = self.inner.set_max_results(input);
            self
        }
    }
    /// Fluent builder constructing a request to `StartProtectedQuery`.
    ///
    /// <p>Creates a protected query that is started by AWS Clean Rooms.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct StartProtectedQuery {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::start_protected_query_input::Builder,
    }
    impl StartProtectedQuery {
        /// Creates a new `StartProtectedQuery`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::StartProtectedQuery,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::StartProtectedQueryError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::StartProtectedQueryOutput,
            aws_smithy_http::result::SdkError<crate::error::StartProtectedQueryError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The type of the protected query to be started.</p>
        pub fn r#type(mut self, input: crate::model::ProtectedQueryType) -> Self {
            self.inner = self.inner.r#type(input);
            self
        }
        /// <p>The type of the protected query to be started.</p>
        pub fn set_type(
            mut self,
            input: std::option::Option<crate::model::ProtectedQueryType>,
        ) -> Self {
            self.inner = self.inner.set_type(input);
            self
        }
        /// <p>A unique identifier for the membership to run this query against. Currently accepts a membership ID.</p>
        pub fn membership_identifier(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.membership_identifier(input.into());
            self
        }
        /// <p>A unique identifier for the membership to run this query against. Currently accepts a membership ID.</p>
        pub fn set_membership_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_membership_identifier(input);
            self
        }
        /// <p>The protected SQL query parameters.</p>
        pub fn sql_parameters(mut self, input: crate::model::ProtectedQuerySqlParameters) -> Self {
            self.inner = self.inner.sql_parameters(input);
            self
        }
        /// <p>The protected SQL query parameters.</p>
        pub fn set_sql_parameters(
            mut self,
            input: std::option::Option<crate::model::ProtectedQuerySqlParameters>,
        ) -> Self {
            self.inner = self.inner.set_sql_parameters(input);
            self
        }
        /// <p>The details needed to write the query results.</p>
        pub fn result_configuration(
            mut self,
            input: crate::model::ProtectedQueryResultConfiguration,
        ) -> Self {
            self.inner = self.inner.result_configuration(input);
            self
        }
        /// <p>The details needed to write the query results.</p>
        pub fn set_result_configuration(
            mut self,
            input: std::option::Option<crate::model::ProtectedQueryResultConfiguration>,
        ) -> Self {
            self.inner = self.inner.set_result_configuration(input);
            self
        }
    }
    /// Fluent builder constructing a request to `UpdateCollaboration`.
    ///
    /// <p>Updates collaboration metadata and can only be called by the collaboration owner.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct UpdateCollaboration {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::update_collaboration_input::Builder,
    }
    impl UpdateCollaboration {
        /// Creates a new `UpdateCollaboration`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::UpdateCollaboration,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::UpdateCollaborationError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::UpdateCollaborationOutput,
            aws_smithy_http::result::SdkError<crate::error::UpdateCollaborationError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The identifier for the collaboration.</p>
        pub fn collaboration_identifier(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.collaboration_identifier(input.into());
            self
        }
        /// <p>The identifier for the collaboration.</p>
        pub fn set_collaboration_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_collaboration_identifier(input);
            self
        }
        /// <p>A human-readable identifier provided by the collaboration owner. Display names are not unique.</p>
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.name(input.into());
            self
        }
        /// <p>A human-readable identifier provided by the collaboration owner. Display names are not unique.</p>
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_name(input);
            self
        }
        /// <p>A description of the collaboration.</p>
        pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.description(input.into());
            self
        }
        /// <p>A description of the collaboration.</p>
        pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_description(input);
            self
        }
    }
    /// Fluent builder constructing a request to `UpdateConfiguredTable`.
    ///
    /// <p>Updates a configured table.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct UpdateConfiguredTable {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::update_configured_table_input::Builder,
    }
    impl UpdateConfiguredTable {
        /// Creates a new `UpdateConfiguredTable`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::UpdateConfiguredTable,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::UpdateConfiguredTableError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::UpdateConfiguredTableOutput,
            aws_smithy_http::result::SdkError<crate::error::UpdateConfiguredTableError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The identifier for the configured table to update. Currently accepts the configured table ID.</p>
        pub fn configured_table_identifier(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self.inner.configured_table_identifier(input.into());
            self
        }
        /// <p>The identifier for the configured table to update. Currently accepts the configured table ID.</p>
        pub fn set_configured_table_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_configured_table_identifier(input);
            self
        }
        /// <p>A new name for the configured table.</p>
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.name(input.into());
            self
        }
        /// <p>A new name for the configured table.</p>
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_name(input);
            self
        }
        /// <p>A new description for the configured table.</p>
        pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.description(input.into());
            self
        }
        /// <p>A new description for the configured table.</p>
        pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_description(input);
            self
        }
    }
    /// Fluent builder constructing a request to `UpdateConfiguredTableAnalysisRule`.
    ///
    /// <p>Updates a configured table analysis rule.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct UpdateConfiguredTableAnalysisRule {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::update_configured_table_analysis_rule_input::Builder,
    }
    impl UpdateConfiguredTableAnalysisRule {
        /// Creates a new `UpdateConfiguredTableAnalysisRule`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::UpdateConfiguredTableAnalysisRule,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::UpdateConfiguredTableAnalysisRuleError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::UpdateConfiguredTableAnalysisRuleOutput,
            aws_smithy_http::result::SdkError<crate::error::UpdateConfiguredTableAnalysisRuleError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The unique identifier for the configured table that the analysis rule applies to. Currently accepts the configured table ID.</p>
        pub fn configured_table_identifier(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self.inner.configured_table_identifier(input.into());
            self
        }
        /// <p>The unique identifier for the configured table that the analysis rule applies to. Currently accepts the configured table ID.</p>
        pub fn set_configured_table_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_configured_table_identifier(input);
            self
        }
        /// <p>The analysis rule type to be updated. Configured table analysis rules are uniquely identified by their configured table identifier and analysis rule type.</p>
        pub fn analysis_rule_type(
            mut self,
            input: crate::model::ConfiguredTableAnalysisRuleType,
        ) -> Self {
            self.inner = self.inner.analysis_rule_type(input);
            self
        }
        /// <p>The analysis rule type to be updated. Configured table analysis rules are uniquely identified by their configured table identifier and analysis rule type.</p>
        pub fn set_analysis_rule_type(
            mut self,
            input: std::option::Option<crate::model::ConfiguredTableAnalysisRuleType>,
        ) -> Self {
            self.inner = self.inner.set_analysis_rule_type(input);
            self
        }
        /// <p>The new analysis rule policy for the configured table analysis rule.</p>
        pub fn analysis_rule_policy(
            mut self,
            input: crate::model::ConfiguredTableAnalysisRulePolicy,
        ) -> Self {
            self.inner = self.inner.analysis_rule_policy(input);
            self
        }
        /// <p>The new analysis rule policy for the configured table analysis rule.</p>
        pub fn set_analysis_rule_policy(
            mut self,
            input: std::option::Option<crate::model::ConfiguredTableAnalysisRulePolicy>,
        ) -> Self {
            self.inner = self.inner.set_analysis_rule_policy(input);
            self
        }
    }
    /// Fluent builder constructing a request to `UpdateConfiguredTableAssociation`.
    ///
    /// <p>Updates a configured table association.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct UpdateConfiguredTableAssociation {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::update_configured_table_association_input::Builder,
    }
    impl UpdateConfiguredTableAssociation {
        /// Creates a new `UpdateConfiguredTableAssociation`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::UpdateConfiguredTableAssociation,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::UpdateConfiguredTableAssociationError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::UpdateConfiguredTableAssociationOutput,
            aws_smithy_http::result::SdkError<crate::error::UpdateConfiguredTableAssociationError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The unique identifier for the configured table association to update. Currently accepts the configured table association ID.</p>
        pub fn configured_table_association_identifier(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self
                .inner
                .configured_table_association_identifier(input.into());
            self
        }
        /// <p>The unique identifier for the configured table association to update. Currently accepts the configured table association ID.</p>
        pub fn set_configured_table_association_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self
                .inner
                .set_configured_table_association_identifier(input);
            self
        }
        /// <p>The unique ID for the membership that the configured table association belongs to.</p>
        pub fn membership_identifier(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.membership_identifier(input.into());
            self
        }
        /// <p>The unique ID for the membership that the configured table association belongs to.</p>
        pub fn set_membership_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_membership_identifier(input);
            self
        }
        /// <p>A new description for the configured table association.</p>
        pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.description(input.into());
            self
        }
        /// <p>A new description for the configured table association.</p>
        pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_description(input);
            self
        }
        /// <p>The service will assume this role to access catalog metadata and query the table.</p>
        pub fn role_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.role_arn(input.into());
            self
        }
        /// <p>The service will assume this role to access catalog metadata and query the table.</p>
        pub fn set_role_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_role_arn(input);
            self
        }
    }
    /// Fluent builder constructing a request to `UpdateMembership`.
    ///
    /// <p>Updates a membership.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct UpdateMembership {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::update_membership_input::Builder,
    }
    impl UpdateMembership {
        /// Creates a new `UpdateMembership`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::UpdateMembership,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::UpdateMembershipError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::UpdateMembershipOutput,
            aws_smithy_http::result::SdkError<crate::error::UpdateMembershipError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The unique identifier of the membership.</p>
        pub fn membership_identifier(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.membership_identifier(input.into());
            self
        }
        /// <p>The unique identifier of the membership.</p>
        pub fn set_membership_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_membership_identifier(input);
            self
        }
        /// <p>An indicator as to whether query logging has been enabled or disabled for the collaboration.</p>
        pub fn query_log_status(mut self, input: crate::model::MembershipQueryLogStatus) -> Self {
            self.inner = self.inner.query_log_status(input);
            self
        }
        /// <p>An indicator as to whether query logging has been enabled or disabled for the collaboration.</p>
        pub fn set_query_log_status(
            mut self,
            input: std::option::Option<crate::model::MembershipQueryLogStatus>,
        ) -> Self {
            self.inner = self.inner.set_query_log_status(input);
            self
        }
    }
    /// Fluent builder constructing a request to `UpdateProtectedQuery`.
    ///
    /// <p>Updates the processing of a currently running query.</p>
    #[derive(std::clone::Clone, std::fmt::Debug)]
    pub struct UpdateProtectedQuery {
        handle: std::sync::Arc<super::Handle>,
        inner: crate::input::update_protected_query_input::Builder,
    }
    impl UpdateProtectedQuery {
        /// Creates a new `UpdateProtectedQuery`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// Consume this builder, creating a customizable operation that can be modified before being
        /// sent. The operation's inner [http::Request] can be modified as well.
        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::UpdateProtectedQuery,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::UpdateProtectedQueryError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::UpdateProtectedQueryOutput,
            aws_smithy_http::result::SdkError<crate::error::UpdateProtectedQueryError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }
        /// <p>The identifier for a member of a protected query instance.</p>
        pub fn membership_identifier(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.membership_identifier(input.into());
            self
        }
        /// <p>The identifier for a member of a protected query instance.</p>
        pub fn set_membership_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_membership_identifier(input);
            self
        }
        /// <p>The identifier for a protected query instance.</p>
        pub fn protected_query_identifier(mut self, input: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.protected_query_identifier(input.into());
            self
        }
        /// <p>The identifier for a protected query instance.</p>
        pub fn set_protected_query_identifier(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_protected_query_identifier(input);
            self
        }
        /// <p>The target status of a query. Used to update the execution status of a currently running query.</p>
        pub fn target_status(mut self, input: crate::model::TargetProtectedQueryStatus) -> Self {
            self.inner = self.inner.target_status(input);
            self
        }
        /// <p>The target status of a query. Used to update the execution status of a currently running query.</p>
        pub fn set_target_status(
            mut self,
            input: std::option::Option<crate::model::TargetProtectedQueryStatus>,
        ) -> Self {
            self.inner = self.inner.set_target_status(input);
            self
        }
    }
}

impl Client {
    /// Creates a new client from an [SDK Config](aws_types::sdk_config::SdkConfig).
    ///
    /// # Panics
    ///
    /// - This method will panic if the `sdk_config` is missing an async sleep implementation. If you experience this panic, set
    ///     the `sleep_impl` on the Config passed into this function to fix it.
    /// - This method will panic if the `sdk_config` is missing an HTTP connector. If you experience this panic, set the
    ///     `http_connector` on the Config passed into this function to fix it.
    pub fn new(sdk_config: &aws_types::sdk_config::SdkConfig) -> Self {
        Self::from_conf(sdk_config.into())
    }

    /// Creates a new client from the service [`Config`](crate::Config).
    ///
    /// # Panics
    ///
    /// - This method will panic if the `conf` is missing an async sleep implementation. If you experience this panic, set
    ///     the `sleep_impl` on the Config passed into this function to fix it.
    /// - This method will panic if the `conf` is missing an HTTP connector. If you experience this panic, set the
    ///     `http_connector` on the Config passed into this function to fix it.
    pub fn from_conf(conf: crate::Config) -> Self {
        let retry_config = conf
            .retry_config()
            .cloned()
            .unwrap_or_else(aws_smithy_types::retry::RetryConfig::disabled);
        let timeout_config = conf
            .timeout_config()
            .cloned()
            .unwrap_or_else(aws_smithy_types::timeout::TimeoutConfig::disabled);
        let sleep_impl = conf.sleep_impl();
        if (retry_config.has_retry() || timeout_config.has_timeouts()) && sleep_impl.is_none() {
            panic!("An async sleep implementation is required for retries or timeouts to work. \
                                    Set the `sleep_impl` on the Config passed into this function to fix this panic.");
        }

        let connector = conf.http_connector().and_then(|c| {
            let timeout_config = conf
                .timeout_config()
                .cloned()
                .unwrap_or_else(aws_smithy_types::timeout::TimeoutConfig::disabled);
            let connector_settings =
                aws_smithy_client::http_connector::ConnectorSettings::from_timeout_config(
                    &timeout_config,
                );
            c.connector(&connector_settings, conf.sleep_impl())
        });

        let builder = aws_smithy_client::Builder::new();

        let builder = match connector {
            // Use provided connector
            Some(c) => builder.connector(c),
            None => {
                #[cfg(any(feature = "rustls", feature = "native-tls"))]
                {
                    // Use default connector based on enabled features
                    builder.dyn_https_connector(
                        aws_smithy_client::http_connector::ConnectorSettings::from_timeout_config(
                            &timeout_config,
                        ),
                    )
                }
                #[cfg(not(any(feature = "rustls", feature = "native-tls")))]
                {
                    panic!("No HTTP connector was available. Enable the `rustls` or `native-tls` crate feature or set a connector to fix this.");
                }
            }
        };
        let mut builder = builder
            .middleware(aws_smithy_client::erase::DynMiddleware::new(
                crate::middleware::DefaultMiddleware::new(),
            ))
            .retry_config(retry_config.into())
            .operation_timeout_config(timeout_config.into());
        builder.set_sleep_impl(sleep_impl);
        let client = builder.build();

        Self {
            handle: std::sync::Arc::new(Handle { client, conf }),
        }
    }
}