aws-sdk-opensearchserverless 0.2.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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