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

/// An ergonomic service client for `AmazonSimpleNotificationService`.
///
/// This client allows ergonomic access to a `AmazonSimpleNotificationService`-shaped service.
/// Each method corresponds to an endpoint defined in the service's Smithy model,
/// and the request and response shapes are auto-generated from that same model.
///
/// # Using a Client
///
/// Once you have a client set up, you can access the service's endpoints
/// by calling the appropriate method on [`Client`]. Each such method
/// returns a request builder for that endpoint, with methods for setting
/// the various fields of the request. Once your request is complete, use
/// the `send` method to send the request. `send` returns a future, which
/// you then have to `.await` to get the service's response.
///
/// [builder pattern]: https://rust-lang.github.io/api-guidelines/type-safety.html#c-builder
/// [SigV4-signed requests]: https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html
#[derive(std::fmt::Debug)]
pub struct Client<
    C = aws_smithy_client::erase::DynConnector,
    M = aws_hyper::AwsMiddleware,
    R = aws_smithy_client::retry::Standard,
> {
    handle: std::sync::Arc<Handle<C, M, R>>,
}

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

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

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

impl<C, M, R> Client<C, M, R> {
    /// Creates a client with the given service configuration.
    pub fn with_config(client: aws_smithy_client::Client<C, M, R>, 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<C, M, R> Client<C, M, R>
where
    C: aws_smithy_client::bounds::SmithyConnector,
    M: aws_smithy_client::bounds::SmithyMiddleware<C>,
    R: aws_smithy_client::retry::NewRequestPolicy,
{
    /// Constructs a fluent builder for the `AddPermission` operation.
    ///
    /// See [`AddPermission`](crate::client::fluent_builders::AddPermission) for more information about the
    /// operation and its arguments.
    pub fn add_permission(&self) -> fluent_builders::AddPermission<C, M, R> {
        fluent_builders::AddPermission::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `CheckIfPhoneNumberIsOptedOut` operation.
    ///
    /// See [`CheckIfPhoneNumberIsOptedOut`](crate::client::fluent_builders::CheckIfPhoneNumberIsOptedOut) for more information about the
    /// operation and its arguments.
    pub fn check_if_phone_number_is_opted_out(
        &self,
    ) -> fluent_builders::CheckIfPhoneNumberIsOptedOut<C, M, R> {
        fluent_builders::CheckIfPhoneNumberIsOptedOut::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `ConfirmSubscription` operation.
    ///
    /// See [`ConfirmSubscription`](crate::client::fluent_builders::ConfirmSubscription) for more information about the
    /// operation and its arguments.
    pub fn confirm_subscription(&self) -> fluent_builders::ConfirmSubscription<C, M, R> {
        fluent_builders::ConfirmSubscription::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `CreatePlatformApplication` operation.
    ///
    /// See [`CreatePlatformApplication`](crate::client::fluent_builders::CreatePlatformApplication) for more information about the
    /// operation and its arguments.
    pub fn create_platform_application(
        &self,
    ) -> fluent_builders::CreatePlatformApplication<C, M, R> {
        fluent_builders::CreatePlatformApplication::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `CreatePlatformEndpoint` operation.
    ///
    /// See [`CreatePlatformEndpoint`](crate::client::fluent_builders::CreatePlatformEndpoint) for more information about the
    /// operation and its arguments.
    pub fn create_platform_endpoint(&self) -> fluent_builders::CreatePlatformEndpoint<C, M, R> {
        fluent_builders::CreatePlatformEndpoint::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `CreateSMSSandboxPhoneNumber` operation.
    ///
    /// See [`CreateSMSSandboxPhoneNumber`](crate::client::fluent_builders::CreateSMSSandboxPhoneNumber) for more information about the
    /// operation and its arguments.
    pub fn create_sms_sandbox_phone_number(
        &self,
    ) -> fluent_builders::CreateSMSSandboxPhoneNumber<C, M, R> {
        fluent_builders::CreateSMSSandboxPhoneNumber::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `CreateTopic` operation.
    ///
    /// See [`CreateTopic`](crate::client::fluent_builders::CreateTopic) for more information about the
    /// operation and its arguments.
    pub fn create_topic(&self) -> fluent_builders::CreateTopic<C, M, R> {
        fluent_builders::CreateTopic::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `DeleteEndpoint` operation.
    ///
    /// See [`DeleteEndpoint`](crate::client::fluent_builders::DeleteEndpoint) for more information about the
    /// operation and its arguments.
    pub fn delete_endpoint(&self) -> fluent_builders::DeleteEndpoint<C, M, R> {
        fluent_builders::DeleteEndpoint::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `DeletePlatformApplication` operation.
    ///
    /// See [`DeletePlatformApplication`](crate::client::fluent_builders::DeletePlatformApplication) for more information about the
    /// operation and its arguments.
    pub fn delete_platform_application(
        &self,
    ) -> fluent_builders::DeletePlatformApplication<C, M, R> {
        fluent_builders::DeletePlatformApplication::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `DeleteSMSSandboxPhoneNumber` operation.
    ///
    /// See [`DeleteSMSSandboxPhoneNumber`](crate::client::fluent_builders::DeleteSMSSandboxPhoneNumber) for more information about the
    /// operation and its arguments.
    pub fn delete_sms_sandbox_phone_number(
        &self,
    ) -> fluent_builders::DeleteSMSSandboxPhoneNumber<C, M, R> {
        fluent_builders::DeleteSMSSandboxPhoneNumber::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `DeleteTopic` operation.
    ///
    /// See [`DeleteTopic`](crate::client::fluent_builders::DeleteTopic) for more information about the
    /// operation and its arguments.
    pub fn delete_topic(&self) -> fluent_builders::DeleteTopic<C, M, R> {
        fluent_builders::DeleteTopic::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `GetEndpointAttributes` operation.
    ///
    /// See [`GetEndpointAttributes`](crate::client::fluent_builders::GetEndpointAttributes) for more information about the
    /// operation and its arguments.
    pub fn get_endpoint_attributes(&self) -> fluent_builders::GetEndpointAttributes<C, M, R> {
        fluent_builders::GetEndpointAttributes::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `GetPlatformApplicationAttributes` operation.
    ///
    /// See [`GetPlatformApplicationAttributes`](crate::client::fluent_builders::GetPlatformApplicationAttributes) for more information about the
    /// operation and its arguments.
    pub fn get_platform_application_attributes(
        &self,
    ) -> fluent_builders::GetPlatformApplicationAttributes<C, M, R> {
        fluent_builders::GetPlatformApplicationAttributes::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `GetSMSAttributes` operation.
    ///
    /// See [`GetSMSAttributes`](crate::client::fluent_builders::GetSMSAttributes) for more information about the
    /// operation and its arguments.
    pub fn get_sms_attributes(&self) -> fluent_builders::GetSMSAttributes<C, M, R> {
        fluent_builders::GetSMSAttributes::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `GetSMSSandboxAccountStatus` operation.
    ///
    /// See [`GetSMSSandboxAccountStatus`](crate::client::fluent_builders::GetSMSSandboxAccountStatus) for more information about the
    /// operation and its arguments.
    pub fn get_sms_sandbox_account_status(
        &self,
    ) -> fluent_builders::GetSMSSandboxAccountStatus<C, M, R> {
        fluent_builders::GetSMSSandboxAccountStatus::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `GetSubscriptionAttributes` operation.
    ///
    /// See [`GetSubscriptionAttributes`](crate::client::fluent_builders::GetSubscriptionAttributes) for more information about the
    /// operation and its arguments.
    pub fn get_subscription_attributes(
        &self,
    ) -> fluent_builders::GetSubscriptionAttributes<C, M, R> {
        fluent_builders::GetSubscriptionAttributes::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `GetTopicAttributes` operation.
    ///
    /// See [`GetTopicAttributes`](crate::client::fluent_builders::GetTopicAttributes) for more information about the
    /// operation and its arguments.
    pub fn get_topic_attributes(&self) -> fluent_builders::GetTopicAttributes<C, M, R> {
        fluent_builders::GetTopicAttributes::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `ListEndpointsByPlatformApplication` operation.
    ///
    /// See [`ListEndpointsByPlatformApplication`](crate::client::fluent_builders::ListEndpointsByPlatformApplication) for more information about the
    /// operation and its arguments.
    pub fn list_endpoints_by_platform_application(
        &self,
    ) -> fluent_builders::ListEndpointsByPlatformApplication<C, M, R> {
        fluent_builders::ListEndpointsByPlatformApplication::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `ListOriginationNumbers` operation.
    ///
    /// See [`ListOriginationNumbers`](crate::client::fluent_builders::ListOriginationNumbers) for more information about the
    /// operation and its arguments.
    pub fn list_origination_numbers(&self) -> fluent_builders::ListOriginationNumbers<C, M, R> {
        fluent_builders::ListOriginationNumbers::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `ListPhoneNumbersOptedOut` operation.
    ///
    /// See [`ListPhoneNumbersOptedOut`](crate::client::fluent_builders::ListPhoneNumbersOptedOut) for more information about the
    /// operation and its arguments.
    pub fn list_phone_numbers_opted_out(
        &self,
    ) -> fluent_builders::ListPhoneNumbersOptedOut<C, M, R> {
        fluent_builders::ListPhoneNumbersOptedOut::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `ListPlatformApplications` operation.
    ///
    /// See [`ListPlatformApplications`](crate::client::fluent_builders::ListPlatformApplications) for more information about the
    /// operation and its arguments.
    pub fn list_platform_applications(&self) -> fluent_builders::ListPlatformApplications<C, M, R> {
        fluent_builders::ListPlatformApplications::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `ListSMSSandboxPhoneNumbers` operation.
    ///
    /// See [`ListSMSSandboxPhoneNumbers`](crate::client::fluent_builders::ListSMSSandboxPhoneNumbers) for more information about the
    /// operation and its arguments.
    pub fn list_sms_sandbox_phone_numbers(
        &self,
    ) -> fluent_builders::ListSMSSandboxPhoneNumbers<C, M, R> {
        fluent_builders::ListSMSSandboxPhoneNumbers::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `ListSubscriptions` operation.
    ///
    /// See [`ListSubscriptions`](crate::client::fluent_builders::ListSubscriptions) for more information about the
    /// operation and its arguments.
    pub fn list_subscriptions(&self) -> fluent_builders::ListSubscriptions<C, M, R> {
        fluent_builders::ListSubscriptions::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `ListSubscriptionsByTopic` operation.
    ///
    /// See [`ListSubscriptionsByTopic`](crate::client::fluent_builders::ListSubscriptionsByTopic) for more information about the
    /// operation and its arguments.
    pub fn list_subscriptions_by_topic(
        &self,
    ) -> fluent_builders::ListSubscriptionsByTopic<C, M, R> {
        fluent_builders::ListSubscriptionsByTopic::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `ListTagsForResource` operation.
    ///
    /// See [`ListTagsForResource`](crate::client::fluent_builders::ListTagsForResource) for more information about the
    /// operation and its arguments.
    pub fn list_tags_for_resource(&self) -> fluent_builders::ListTagsForResource<C, M, R> {
        fluent_builders::ListTagsForResource::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `ListTopics` operation.
    ///
    /// See [`ListTopics`](crate::client::fluent_builders::ListTopics) for more information about the
    /// operation and its arguments.
    pub fn list_topics(&self) -> fluent_builders::ListTopics<C, M, R> {
        fluent_builders::ListTopics::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `OptInPhoneNumber` operation.
    ///
    /// See [`OptInPhoneNumber`](crate::client::fluent_builders::OptInPhoneNumber) for more information about the
    /// operation and its arguments.
    pub fn opt_in_phone_number(&self) -> fluent_builders::OptInPhoneNumber<C, M, R> {
        fluent_builders::OptInPhoneNumber::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `Publish` operation.
    ///
    /// See [`Publish`](crate::client::fluent_builders::Publish) for more information about the
    /// operation and its arguments.
    pub fn publish(&self) -> fluent_builders::Publish<C, M, R> {
        fluent_builders::Publish::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `RemovePermission` operation.
    ///
    /// See [`RemovePermission`](crate::client::fluent_builders::RemovePermission) for more information about the
    /// operation and its arguments.
    pub fn remove_permission(&self) -> fluent_builders::RemovePermission<C, M, R> {
        fluent_builders::RemovePermission::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `SetEndpointAttributes` operation.
    ///
    /// See [`SetEndpointAttributes`](crate::client::fluent_builders::SetEndpointAttributes) for more information about the
    /// operation and its arguments.
    pub fn set_endpoint_attributes(&self) -> fluent_builders::SetEndpointAttributes<C, M, R> {
        fluent_builders::SetEndpointAttributes::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `SetPlatformApplicationAttributes` operation.
    ///
    /// See [`SetPlatformApplicationAttributes`](crate::client::fluent_builders::SetPlatformApplicationAttributes) for more information about the
    /// operation and its arguments.
    pub fn set_platform_application_attributes(
        &self,
    ) -> fluent_builders::SetPlatformApplicationAttributes<C, M, R> {
        fluent_builders::SetPlatformApplicationAttributes::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `SetSMSAttributes` operation.
    ///
    /// See [`SetSMSAttributes`](crate::client::fluent_builders::SetSMSAttributes) for more information about the
    /// operation and its arguments.
    pub fn set_sms_attributes(&self) -> fluent_builders::SetSMSAttributes<C, M, R> {
        fluent_builders::SetSMSAttributes::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `SetSubscriptionAttributes` operation.
    ///
    /// See [`SetSubscriptionAttributes`](crate::client::fluent_builders::SetSubscriptionAttributes) for more information about the
    /// operation and its arguments.
    pub fn set_subscription_attributes(
        &self,
    ) -> fluent_builders::SetSubscriptionAttributes<C, M, R> {
        fluent_builders::SetSubscriptionAttributes::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `SetTopicAttributes` operation.
    ///
    /// See [`SetTopicAttributes`](crate::client::fluent_builders::SetTopicAttributes) for more information about the
    /// operation and its arguments.
    pub fn set_topic_attributes(&self) -> fluent_builders::SetTopicAttributes<C, M, R> {
        fluent_builders::SetTopicAttributes::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `Subscribe` operation.
    ///
    /// See [`Subscribe`](crate::client::fluent_builders::Subscribe) for more information about the
    /// operation and its arguments.
    pub fn subscribe(&self) -> fluent_builders::Subscribe<C, M, R> {
        fluent_builders::Subscribe::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `TagResource` operation.
    ///
    /// See [`TagResource`](crate::client::fluent_builders::TagResource) for more information about the
    /// operation and its arguments.
    pub fn tag_resource(&self) -> fluent_builders::TagResource<C, M, R> {
        fluent_builders::TagResource::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `Unsubscribe` operation.
    ///
    /// See [`Unsubscribe`](crate::client::fluent_builders::Unsubscribe) for more information about the
    /// operation and its arguments.
    pub fn unsubscribe(&self) -> fluent_builders::Unsubscribe<C, M, R> {
        fluent_builders::Unsubscribe::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `UntagResource` operation.
    ///
    /// See [`UntagResource`](crate::client::fluent_builders::UntagResource) for more information about the
    /// operation and its arguments.
    pub fn untag_resource(&self) -> fluent_builders::UntagResource<C, M, R> {
        fluent_builders::UntagResource::new(self.handle.clone())
    }
    /// Constructs a fluent builder for the `VerifySMSSandboxPhoneNumber` operation.
    ///
    /// See [`VerifySMSSandboxPhoneNumber`](crate::client::fluent_builders::VerifySMSSandboxPhoneNumber) for more information about the
    /// operation and its arguments.
    pub fn verify_sms_sandbox_phone_number(
        &self,
    ) -> fluent_builders::VerifySMSSandboxPhoneNumber<C, M, R> {
        fluent_builders::VerifySMSSandboxPhoneNumber::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 `AddPermission`.
    ///
    /// <p>Adds a statement to a topic's access control policy, granting access for the specified
    /// accounts to the specified actions.</p>
    #[derive(std::fmt::Debug)]
    pub struct AddPermission<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::add_permission_input::Builder,
    }
    impl<C, M, R> AddPermission<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `AddPermission`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::AddPermissionOutput,
            aws_smithy_http::result::SdkError<crate::error::AddPermissionError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::AddPermissionInputOperationOutputAlias,
                crate::output::AddPermissionOutput,
                crate::error::AddPermissionError,
                crate::input::AddPermissionInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The ARN of the topic whose access control policy you wish to modify.</p>
        pub fn topic_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.topic_arn(inp);
            self
        }
        /// <p>The ARN of the topic whose access control policy you wish to modify.</p>
        pub fn set_topic_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_topic_arn(input);
            self
        }
        /// <p>A unique identifier for the new policy statement.</p>
        pub fn label(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.label(inp);
            self
        }
        /// <p>A unique identifier for the new policy statement.</p>
        pub fn set_label(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_label(input);
            self
        }
        /// Appends an item to `AWSAccountId`.
        ///
        /// To override the contents of this collection use [`set_aws_account_id`](Self::set_aws_account_id).
        ///
        /// <p>The account IDs of the users (principals) who will be given access to the
        /// specified actions. The users must have account, but do not need to be signed up for
        /// this service.</p>
        pub fn aws_account_id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.aws_account_id(inp);
            self
        }
        /// <p>The account IDs of the users (principals) who will be given access to the
        /// specified actions. The users must have account, but do not need to be signed up for
        /// this service.</p>
        pub fn set_aws_account_id(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.inner = self.inner.set_aws_account_id(input);
            self
        }
        /// Appends an item to `ActionName`.
        ///
        /// To override the contents of this collection use [`set_action_name`](Self::set_action_name).
        ///
        /// <p>The action you want to allow for the specified principal(s).</p>
        /// <p>Valid values: Any Amazon SNS action name, for example <code>Publish</code>.</p>
        pub fn action_name(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.action_name(inp);
            self
        }
        /// <p>The action you want to allow for the specified principal(s).</p>
        /// <p>Valid values: Any Amazon SNS action name, for example <code>Publish</code>.</p>
        pub fn set_action_name(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.inner = self.inner.set_action_name(input);
            self
        }
    }
    /// Fluent builder constructing a request to `CheckIfPhoneNumberIsOptedOut`.
    ///
    /// <p>Accepts a phone number and indicates whether the phone holder has opted out of
    /// receiving SMS messages from your account. You cannot send SMS messages to a number that
    /// is opted out.</p>
    /// <p>To resume sending messages, you can opt in the number by using the
    /// <code>OptInPhoneNumber</code> action.</p>
    #[derive(std::fmt::Debug)]
    pub struct CheckIfPhoneNumberIsOptedOut<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::check_if_phone_number_is_opted_out_input::Builder,
    }
    impl<C, M, R> CheckIfPhoneNumberIsOptedOut<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `CheckIfPhoneNumberIsOptedOut`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::CheckIfPhoneNumberIsOptedOutOutput,
            aws_smithy_http::result::SdkError<crate::error::CheckIfPhoneNumberIsOptedOutError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::CheckIfPhoneNumberIsOptedOutInputOperationOutputAlias,
                crate::output::CheckIfPhoneNumberIsOptedOutOutput,
                crate::error::CheckIfPhoneNumberIsOptedOutError,
                crate::input::CheckIfPhoneNumberIsOptedOutInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The phone number for which you want to check the opt out status.</p>
        pub fn phone_number(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.phone_number(inp);
            self
        }
        /// <p>The phone number for which you want to check the opt out status.</p>
        pub fn set_phone_number(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_phone_number(input);
            self
        }
    }
    /// Fluent builder constructing a request to `ConfirmSubscription`.
    ///
    /// <p>Verifies an endpoint owner's intent to receive messages by validating the token sent
    /// to the endpoint by an earlier <code>Subscribe</code> action. If the token is valid, the
    /// action creates a new subscription and returns its Amazon Resource Name (ARN). This call
    /// requires an AWS signature only when the <code>AuthenticateOnUnsubscribe</code> flag is
    /// set to "true".</p>
    #[derive(std::fmt::Debug)]
    pub struct ConfirmSubscription<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::confirm_subscription_input::Builder,
    }
    impl<C, M, R> ConfirmSubscription<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `ConfirmSubscription`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::ConfirmSubscriptionOutput,
            aws_smithy_http::result::SdkError<crate::error::ConfirmSubscriptionError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::ConfirmSubscriptionInputOperationOutputAlias,
                crate::output::ConfirmSubscriptionOutput,
                crate::error::ConfirmSubscriptionError,
                crate::input::ConfirmSubscriptionInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The ARN of the topic for which you wish to confirm a subscription.</p>
        pub fn topic_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.topic_arn(inp);
            self
        }
        /// <p>The ARN of the topic for which you wish to confirm a subscription.</p>
        pub fn set_topic_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_topic_arn(input);
            self
        }
        /// <p>Short-lived token sent to an endpoint during the <code>Subscribe</code> action.</p>
        pub fn token(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.token(inp);
            self
        }
        /// <p>Short-lived token sent to an endpoint during the <code>Subscribe</code> action.</p>
        pub fn set_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_token(input);
            self
        }
        /// <p>Disallows unauthenticated unsubscribes of the subscription. If the value of this
        /// parameter is <code>true</code> and the request has an Amazon Web Services signature, then only the topic
        /// owner and the subscription owner can unsubscribe the endpoint. The unsubscribe action
        /// requires Amazon Web Services authentication. </p>
        pub fn authenticate_on_unsubscribe(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.authenticate_on_unsubscribe(inp);
            self
        }
        /// <p>Disallows unauthenticated unsubscribes of the subscription. If the value of this
        /// parameter is <code>true</code> and the request has an Amazon Web Services signature, then only the topic
        /// owner and the subscription owner can unsubscribe the endpoint. The unsubscribe action
        /// requires Amazon Web Services authentication. </p>
        pub fn set_authenticate_on_unsubscribe(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_authenticate_on_unsubscribe(input);
            self
        }
    }
    /// Fluent builder constructing a request to `CreatePlatformApplication`.
    ///
    /// <p>Creates a platform application object for one of the supported push notification
    /// services, such as APNS and GCM (Firebase Cloud Messaging), to which devices and mobile
    /// apps may register. You must specify <code>PlatformPrincipal</code> and
    /// <code>PlatformCredential</code> attributes when using the
    /// <code>CreatePlatformApplication</code> action.</p>
    /// <p>
    /// <code>PlatformPrincipal</code> and <code>PlatformCredential</code> are received from
    /// the notification service.</p>
    /// <ul>
    /// <li>
    /// <p>For <code>ADM</code>, <code>PlatformPrincipal</code> is <code>client id</code>
    /// and <code>PlatformCredential</code> is <code>client secret</code>.</p>
    /// </li>
    /// <li>
    /// <p>For <code>Baidu</code>, <code>PlatformPrincipal</code> is <code>API key</code>
    /// and <code>PlatformCredential</code> is <code>secret key</code>.</p>
    /// </li>
    /// <li>
    /// <p>For <code>APNS</code> and <code>APNS_SANDBOX</code>,
    /// <code>PlatformPrincipal</code> is <code>SSL certificate</code> and
    /// <code>PlatformCredential</code> is <code>private key</code>.</p>
    /// </li>
    /// <li>
    /// <p>For <code>GCM</code> (Firebase Cloud Messaging), there is no
    /// <code>PlatformPrincipal</code> and the <code>PlatformCredential</code> is
    /// <code>API key</code>.</p>
    /// </li>
    /// <li>
    /// <p>For <code>MPNS</code>, <code>PlatformPrincipal</code> is <code>TLS
    /// certificate</code> and <code>PlatformCredential</code> is <code>private
    /// key</code>.</p>
    /// </li>
    /// <li>
    /// <p>For <code>WNS</code>, <code>PlatformPrincipal</code> is <code>Package Security
    /// Identifier</code> and <code>PlatformCredential</code> is <code>secret
    /// key</code>.</p>
    /// </li>
    /// </ul>
    /// <p>You can use the returned <code>PlatformApplicationArn</code> as an attribute for the
    /// <code>CreatePlatformEndpoint</code> action.</p>
    #[derive(std::fmt::Debug)]
    pub struct CreatePlatformApplication<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::create_platform_application_input::Builder,
    }
    impl<C, M, R> CreatePlatformApplication<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `CreatePlatformApplication`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::CreatePlatformApplicationOutput,
            aws_smithy_http::result::SdkError<crate::error::CreatePlatformApplicationError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::CreatePlatformApplicationInputOperationOutputAlias,
                crate::output::CreatePlatformApplicationOutput,
                crate::error::CreatePlatformApplicationError,
                crate::input::CreatePlatformApplicationInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>Application names must be made up of only uppercase and lowercase ASCII letters,
        /// numbers, underscores, hyphens, and periods, and must be between 1 and 256 characters
        /// long.</p>
        pub fn name(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.name(inp);
            self
        }
        /// <p>Application names must be made up of only uppercase and lowercase ASCII letters,
        /// numbers, underscores, hyphens, and periods, and must be between 1 and 256 characters
        /// long.</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 following platforms are supported: ADM (Amazon Device Messaging), APNS (Apple Push
        /// Notification Service), APNS_SANDBOX, and GCM (Firebase Cloud Messaging).</p>
        pub fn platform(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.platform(inp);
            self
        }
        /// <p>The following platforms are supported: ADM (Amazon Device Messaging), APNS (Apple Push
        /// Notification Service), APNS_SANDBOX, and GCM (Firebase Cloud Messaging).</p>
        pub fn set_platform(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_platform(input);
            self
        }
        /// Adds a key-value pair to `Attributes`.
        ///
        /// To override the contents of this collection use [`set_attributes`](Self::set_attributes).
        ///
        /// <p>For a list of attributes, see <a href="https://docs.aws.amazon.com/sns/latest/api/API_SetPlatformApplicationAttributes.html">SetPlatformApplicationAttributes</a>.</p>
        pub fn attributes(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self.inner.attributes(k, v);
            self
        }
        /// <p>For a list of attributes, see <a href="https://docs.aws.amazon.com/sns/latest/api/API_SetPlatformApplicationAttributes.html">SetPlatformApplicationAttributes</a>.</p>
        pub fn set_attributes(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, std::string::String>,
            >,
        ) -> Self {
            self.inner = self.inner.set_attributes(input);
            self
        }
    }
    /// Fluent builder constructing a request to `CreatePlatformEndpoint`.
    ///
    /// <p>Creates an endpoint for a device and mobile app on one of the supported push
    /// notification services, such as GCM (Firebase Cloud Messaging) and APNS.
    /// <code>CreatePlatformEndpoint</code> requires the <code>PlatformApplicationArn</code>
    /// that is returned from <code>CreatePlatformApplication</code>. You can use the returned
    /// <code>EndpointArn</code> to send a message to a mobile app or by the
    /// <code>Subscribe</code> action for subscription to a topic. The
    /// <code>CreatePlatformEndpoint</code> action is idempotent, so if the requester
    /// already owns an endpoint with the same device token and attributes, that endpoint's ARN
    /// is returned without creating a new endpoint. For more information, see <a href="https://docs.aws.amazon.com/sns/latest/dg/SNSMobilePush.html">Using Amazon SNS Mobile Push
    /// Notifications</a>. </p>
    /// <p>When using <code>CreatePlatformEndpoint</code> with Baidu, two attributes must be
    /// provided: ChannelId and UserId. The token field must also contain the ChannelId. For
    /// more information, see <a href="https://docs.aws.amazon.com/sns/latest/dg/SNSMobilePushBaiduEndpoint.html">Creating an Amazon SNS Endpoint
    /// for Baidu</a>. </p>
    #[derive(std::fmt::Debug)]
    pub struct CreatePlatformEndpoint<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::create_platform_endpoint_input::Builder,
    }
    impl<C, M, R> CreatePlatformEndpoint<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `CreatePlatformEndpoint`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::CreatePlatformEndpointOutput,
            aws_smithy_http::result::SdkError<crate::error::CreatePlatformEndpointError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::CreatePlatformEndpointInputOperationOutputAlias,
                crate::output::CreatePlatformEndpointOutput,
                crate::error::CreatePlatformEndpointError,
                crate::input::CreatePlatformEndpointInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>PlatformApplicationArn returned from CreatePlatformApplication is used to create a an
        /// endpoint.</p>
        pub fn platform_application_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.platform_application_arn(inp);
            self
        }
        /// <p>PlatformApplicationArn returned from CreatePlatformApplication is used to create a an
        /// endpoint.</p>
        pub fn set_platform_application_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_platform_application_arn(input);
            self
        }
        /// <p>Unique identifier created by the notification service for an app on a device. The
        /// specific name for Token will vary, depending on which notification service is being
        /// used. For example, when using APNS as the notification service, you need the device
        /// token. Alternatively, when using GCM (Firebase Cloud Messaging) or ADM, the device token
        /// equivalent is called the registration ID.</p>
        pub fn token(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.token(inp);
            self
        }
        /// <p>Unique identifier created by the notification service for an app on a device. The
        /// specific name for Token will vary, depending on which notification service is being
        /// used. For example, when using APNS as the notification service, you need the device
        /// token. Alternatively, when using GCM (Firebase Cloud Messaging) or ADM, the device token
        /// equivalent is called the registration ID.</p>
        pub fn set_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_token(input);
            self
        }
        /// <p>Arbitrary user data to associate with the endpoint. Amazon SNS does not use this data. The
        /// data must be in UTF-8 format and less than 2KB.</p>
        pub fn custom_user_data(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.custom_user_data(inp);
            self
        }
        /// <p>Arbitrary user data to associate with the endpoint. Amazon SNS does not use this data. The
        /// data must be in UTF-8 format and less than 2KB.</p>
        pub fn set_custom_user_data(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_custom_user_data(input);
            self
        }
        /// Adds a key-value pair to `Attributes`.
        ///
        /// To override the contents of this collection use [`set_attributes`](Self::set_attributes).
        ///
        /// <p>For a list of attributes, see <a href="https://docs.aws.amazon.com/sns/latest/api/API_SetEndpointAttributes.html">SetEndpointAttributes</a>.</p>
        pub fn attributes(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self.inner.attributes(k, v);
            self
        }
        /// <p>For a list of attributes, see <a href="https://docs.aws.amazon.com/sns/latest/api/API_SetEndpointAttributes.html">SetEndpointAttributes</a>.</p>
        pub fn set_attributes(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, std::string::String>,
            >,
        ) -> Self {
            self.inner = self.inner.set_attributes(input);
            self
        }
    }
    /// Fluent builder constructing a request to `CreateSMSSandboxPhoneNumber`.
    ///
    /// <p>Adds a destination phone number to an account in the SMS sandbox and sends a
    /// one-time password (OTP) to that phone number.</p>
    /// <p>When you start using Amazon SNS to send SMS messages, your account is in the
    /// <i>SMS sandbox</i>. The SMS sandbox provides a safe environment for
    /// you to try Amazon SNS features without risking your reputation as an SMS sender. While your
    /// account is in the SMS sandbox, you can use all of the features of Amazon SNS. However, you can send
    /// SMS messages only to verified destination phone numbers. For more information, including how to
    /// move out of the sandbox to send messages without restrictions,
    /// see <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-sms-sandbox.html">SMS sandbox</a> in
    /// the <i>Amazon SNS Developer Guide</i>.</p>
    #[derive(std::fmt::Debug)]
    pub struct CreateSMSSandboxPhoneNumber<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::create_sms_sandbox_phone_number_input::Builder,
    }
    impl<C, M, R> CreateSMSSandboxPhoneNumber<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `CreateSMSSandboxPhoneNumber`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::CreateSmsSandboxPhoneNumberOutput,
            aws_smithy_http::result::SdkError<crate::error::CreateSMSSandboxPhoneNumberError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::CreateSmsSandboxPhoneNumberInputOperationOutputAlias,
                crate::output::CreateSmsSandboxPhoneNumberOutput,
                crate::error::CreateSMSSandboxPhoneNumberError,
                crate::input::CreateSmsSandboxPhoneNumberInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The destination phone number to verify. On verification, Amazon SNS adds this phone number
        /// to the list of verified phone numbers that you can send SMS messages to.</p>
        pub fn phone_number(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.phone_number(inp);
            self
        }
        /// <p>The destination phone number to verify. On verification, Amazon SNS adds this phone number
        /// to the list of verified phone numbers that you can send SMS messages to.</p>
        pub fn set_phone_number(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_phone_number(input);
            self
        }
        /// <p>The language to use for sending the OTP. The default value is
        /// <code>en-US</code>.</p>
        pub fn language_code(mut self, inp: crate::model::LanguageCodeString) -> Self {
            self.inner = self.inner.language_code(inp);
            self
        }
        /// <p>The language to use for sending the OTP. The default value is
        /// <code>en-US</code>.</p>
        pub fn set_language_code(
            mut self,
            input: std::option::Option<crate::model::LanguageCodeString>,
        ) -> Self {
            self.inner = self.inner.set_language_code(input);
            self
        }
    }
    /// Fluent builder constructing a request to `CreateTopic`.
    ///
    /// <p>Creates a topic to which notifications can be published. Users can create at most
    /// 100,000 standard topics (at most 1,000 FIFO topics). For more information, see <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-create-topic.html">Creating an Amazon SNS
    /// topic</a> in the <i>Amazon SNS Developer Guide</i>. This action is
    /// idempotent, so if the requester already owns a topic with the specified name, that
    /// topic's ARN is returned without creating a new topic.</p>
    #[derive(std::fmt::Debug)]
    pub struct CreateTopic<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::create_topic_input::Builder,
    }
    impl<C, M, R> CreateTopic<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `CreateTopic`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::CreateTopicOutput,
            aws_smithy_http::result::SdkError<crate::error::CreateTopicError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::CreateTopicInputOperationOutputAlias,
                crate::output::CreateTopicOutput,
                crate::error::CreateTopicError,
                crate::input::CreateTopicInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The name of the topic you want to create.</p>
        /// <p>Constraints: Topic names must be made up of only uppercase and lowercase ASCII
        /// letters, numbers, underscores, and hyphens, and must be between 1 and 256 characters
        /// long.</p>
        /// <p>For a FIFO (first-in-first-out) topic, the name must end with the <code>.fifo</code>
        /// suffix. </p>
        pub fn name(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.name(inp);
            self
        }
        /// <p>The name of the topic you want to create.</p>
        /// <p>Constraints: Topic names must be made up of only uppercase and lowercase ASCII
        /// letters, numbers, underscores, and hyphens, and must be between 1 and 256 characters
        /// long.</p>
        /// <p>For a FIFO (first-in-first-out) topic, the name must end with the <code>.fifo</code>
        /// suffix. </p>
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_name(input);
            self
        }
        /// Adds a key-value pair to `Attributes`.
        ///
        /// To override the contents of this collection use [`set_attributes`](Self::set_attributes).
        ///
        /// <p>A map of attributes with their corresponding values.</p>
        /// <p>The following lists the names, descriptions, and values of the special request
        /// parameters that the <code>CreateTopic</code> action uses:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>DeliveryPolicy</code> – The policy that defines how Amazon SNS retries
        /// failed deliveries to HTTP/S endpoints.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>DisplayName</code> – The display name to use for a topic with SMS
        /// subscriptions.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>FifoTopic</code> – Set to true to create a FIFO topic.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>Policy</code> – The policy that defines who can access your
        /// topic. By default, only the topic owner can publish or subscribe to the
        /// topic.</p>
        /// </li>
        /// </ul>
        ///
        /// <p>The following attribute applies only to <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-server-side-encryption.html">server-side
        /// encryption</a>:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>KmsMasterKeyId</code> – The ID of an Amazon Web Services managed customer master
        /// key (CMK) for Amazon SNS or a custom CMK. For more information, see <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-server-side-encryption.html#sse-key-terms">Key
        /// Terms</a>. For more examples, see <a href="https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html#API_DescribeKey_RequestParameters">KeyId</a> in the <i>Key Management Service API
        /// Reference</i>. </p>
        /// </li>
        /// </ul>
        ///
        ///
        /// <p>The following attributes apply only to <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-fifo-topics.html">FIFO topics</a>:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>FifoTopic</code> – When this is set to <code>true</code>, a FIFO
        /// topic is created.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>ContentBasedDeduplication</code> – Enables content-based deduplication for
        /// FIFO topics.</p>
        ///
        /// <ul>
        /// <li>
        /// <p>By default, <code>ContentBasedDeduplication</code> is set to <code>false</code>.
        /// If you create a FIFO topic and this attribute is <code>false</code>, you must
        /// specify a value for the <code>MessageDeduplicationId</code> parameter for the
        /// <a href="https://docs.aws.amazon.com/sns/latest/api/API_Publish.html">Publish</a> action. </p>
        /// </li>
        /// <li>
        /// <p>When you set <code>ContentBasedDeduplication</code> to <code>true</code>,
        /// Amazon SNS uses a SHA-256 hash to generate the <code>MessageDeduplicationId</code> using
        /// the body of the message (but not the attributes of the message).</p>
        /// <p>(Optional) To override the generated value, you can specify a value
        /// for the <code>MessageDeduplicationId</code> parameter for the <code>Publish</code>
        /// action.</p>
        /// </li>
        /// </ul>
        /// </li>
        /// </ul>
        pub fn attributes(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self.inner.attributes(k, v);
            self
        }
        /// <p>A map of attributes with their corresponding values.</p>
        /// <p>The following lists the names, descriptions, and values of the special request
        /// parameters that the <code>CreateTopic</code> action uses:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>DeliveryPolicy</code> – The policy that defines how Amazon SNS retries
        /// failed deliveries to HTTP/S endpoints.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>DisplayName</code> – The display name to use for a topic with SMS
        /// subscriptions.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>FifoTopic</code> – Set to true to create a FIFO topic.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>Policy</code> – The policy that defines who can access your
        /// topic. By default, only the topic owner can publish or subscribe to the
        /// topic.</p>
        /// </li>
        /// </ul>
        ///
        /// <p>The following attribute applies only to <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-server-side-encryption.html">server-side
        /// encryption</a>:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>KmsMasterKeyId</code> – The ID of an Amazon Web Services managed customer master
        /// key (CMK) for Amazon SNS or a custom CMK. For more information, see <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-server-side-encryption.html#sse-key-terms">Key
        /// Terms</a>. For more examples, see <a href="https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html#API_DescribeKey_RequestParameters">KeyId</a> in the <i>Key Management Service API
        /// Reference</i>. </p>
        /// </li>
        /// </ul>
        ///
        ///
        /// <p>The following attributes apply only to <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-fifo-topics.html">FIFO topics</a>:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>FifoTopic</code> – When this is set to <code>true</code>, a FIFO
        /// topic is created.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>ContentBasedDeduplication</code> – Enables content-based deduplication for
        /// FIFO topics.</p>
        ///
        /// <ul>
        /// <li>
        /// <p>By default, <code>ContentBasedDeduplication</code> is set to <code>false</code>.
        /// If you create a FIFO topic and this attribute is <code>false</code>, you must
        /// specify a value for the <code>MessageDeduplicationId</code> parameter for the
        /// <a href="https://docs.aws.amazon.com/sns/latest/api/API_Publish.html">Publish</a> action. </p>
        /// </li>
        /// <li>
        /// <p>When you set <code>ContentBasedDeduplication</code> to <code>true</code>,
        /// Amazon SNS uses a SHA-256 hash to generate the <code>MessageDeduplicationId</code> using
        /// the body of the message (but not the attributes of the message).</p>
        /// <p>(Optional) To override the generated value, you can specify a value
        /// for the <code>MessageDeduplicationId</code> parameter for the <code>Publish</code>
        /// action.</p>
        /// </li>
        /// </ul>
        /// </li>
        /// </ul>
        pub fn set_attributes(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, std::string::String>,
            >,
        ) -> Self {
            self.inner = self.inner.set_attributes(input);
            self
        }
        /// Appends an item to `Tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// <p>The list of tags to add to a new topic.</p>
        /// <note>
        /// <p>To be able to tag a topic on creation, you must have the
        /// <code>sns:CreateTopic</code> and <code>sns:TagResource</code>
        /// permissions.</p>
        /// </note>
        pub fn tags(mut self, inp: impl Into<crate::model::Tag>) -> Self {
            self.inner = self.inner.tags(inp);
            self
        }
        /// <p>The list of tags to add to a new topic.</p>
        /// <note>
        /// <p>To be able to tag a topic on creation, you must have the
        /// <code>sns:CreateTopic</code> and <code>sns:TagResource</code>
        /// permissions.</p>
        /// </note>
        pub fn set_tags(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
        ) -> Self {
            self.inner = self.inner.set_tags(input);
            self
        }
    }
    /// Fluent builder constructing a request to `DeleteEndpoint`.
    ///
    /// <p>Deletes the endpoint for a device and mobile app from Amazon SNS. This action is
    /// idempotent. For more information, see <a href="https://docs.aws.amazon.com/sns/latest/dg/SNSMobilePush.html">Using Amazon SNS Mobile Push
    /// Notifications</a>. </p>
    /// <p>When you delete an endpoint that is also subscribed to a topic, then you must also
    /// unsubscribe the endpoint from the topic.</p>
    #[derive(std::fmt::Debug)]
    pub struct DeleteEndpoint<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::delete_endpoint_input::Builder,
    }
    impl<C, M, R> DeleteEndpoint<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `DeleteEndpoint`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::DeleteEndpointOutput,
            aws_smithy_http::result::SdkError<crate::error::DeleteEndpointError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::DeleteEndpointInputOperationOutputAlias,
                crate::output::DeleteEndpointOutput,
                crate::error::DeleteEndpointError,
                crate::input::DeleteEndpointInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>EndpointArn of endpoint to delete.</p>
        pub fn endpoint_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.endpoint_arn(inp);
            self
        }
        /// <p>EndpointArn of endpoint to delete.</p>
        pub fn set_endpoint_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_endpoint_arn(input);
            self
        }
    }
    /// Fluent builder constructing a request to `DeletePlatformApplication`.
    ///
    /// <p>Deletes a platform application object for one of the supported push notification
    /// services, such as APNS and GCM (Firebase Cloud Messaging). For more information, see
    /// <a href="https://docs.aws.amazon.com/sns/latest/dg/SNSMobilePush.html">Using Amazon SNS
    /// Mobile Push Notifications</a>. </p>
    #[derive(std::fmt::Debug)]
    pub struct DeletePlatformApplication<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::delete_platform_application_input::Builder,
    }
    impl<C, M, R> DeletePlatformApplication<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `DeletePlatformApplication`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::DeletePlatformApplicationOutput,
            aws_smithy_http::result::SdkError<crate::error::DeletePlatformApplicationError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::DeletePlatformApplicationInputOperationOutputAlias,
                crate::output::DeletePlatformApplicationOutput,
                crate::error::DeletePlatformApplicationError,
                crate::input::DeletePlatformApplicationInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>PlatformApplicationArn of platform application object to delete.</p>
        pub fn platform_application_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.platform_application_arn(inp);
            self
        }
        /// <p>PlatformApplicationArn of platform application object to delete.</p>
        pub fn set_platform_application_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_platform_application_arn(input);
            self
        }
    }
    /// Fluent builder constructing a request to `DeleteSMSSandboxPhoneNumber`.
    ///
    /// <p>Deletes an account's verified or pending phone number from the SMS sandbox.</p>
    /// <p>When you start using Amazon SNS to send SMS messages, your account is in the
    /// <i>SMS sandbox</i>. The SMS sandbox provides a safe environment for
    /// you to try Amazon SNS features without risking your reputation as an SMS sender. While your
    /// account is in the SMS sandbox, you can use all of the features of Amazon SNS. However, you can send
    /// SMS messages only to verified destination phone numbers. For more information, including how to
    /// move out of the sandbox to send messages without restrictions,
    /// see <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-sms-sandbox.html">SMS sandbox</a> in
    /// the <i>Amazon SNS Developer Guide</i>.</p>
    #[derive(std::fmt::Debug)]
    pub struct DeleteSMSSandboxPhoneNumber<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::delete_sms_sandbox_phone_number_input::Builder,
    }
    impl<C, M, R> DeleteSMSSandboxPhoneNumber<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `DeleteSMSSandboxPhoneNumber`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::DeleteSmsSandboxPhoneNumberOutput,
            aws_smithy_http::result::SdkError<crate::error::DeleteSMSSandboxPhoneNumberError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::DeleteSmsSandboxPhoneNumberInputOperationOutputAlias,
                crate::output::DeleteSmsSandboxPhoneNumberOutput,
                crate::error::DeleteSMSSandboxPhoneNumberError,
                crate::input::DeleteSmsSandboxPhoneNumberInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The destination phone number to delete.</p>
        pub fn phone_number(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.phone_number(inp);
            self
        }
        /// <p>The destination phone number to delete.</p>
        pub fn set_phone_number(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_phone_number(input);
            self
        }
    }
    /// Fluent builder constructing a request to `DeleteTopic`.
    ///
    /// <p>Deletes a topic and all its subscriptions. Deleting a topic might prevent some
    /// messages previously sent to the topic from being delivered to subscribers. This action
    /// is idempotent, so deleting a topic that does not exist does not result in an
    /// error.</p>
    #[derive(std::fmt::Debug)]
    pub struct DeleteTopic<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::delete_topic_input::Builder,
    }
    impl<C, M, R> DeleteTopic<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `DeleteTopic`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::DeleteTopicOutput,
            aws_smithy_http::result::SdkError<crate::error::DeleteTopicError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::DeleteTopicInputOperationOutputAlias,
                crate::output::DeleteTopicOutput,
                crate::error::DeleteTopicError,
                crate::input::DeleteTopicInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The ARN of the topic you want to delete.</p>
        pub fn topic_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.topic_arn(inp);
            self
        }
        /// <p>The ARN of the topic you want to delete.</p>
        pub fn set_topic_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_topic_arn(input);
            self
        }
    }
    /// Fluent builder constructing a request to `GetEndpointAttributes`.
    ///
    /// <p>Retrieves the endpoint attributes for a device on one of the supported push
    /// notification services, such as GCM (Firebase Cloud Messaging) and APNS. For more
    /// information, see <a href="https://docs.aws.amazon.com/sns/latest/dg/SNSMobilePush.html">Using Amazon SNS Mobile Push Notifications</a>. </p>
    #[derive(std::fmt::Debug)]
    pub struct GetEndpointAttributes<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::get_endpoint_attributes_input::Builder,
    }
    impl<C, M, R> GetEndpointAttributes<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `GetEndpointAttributes`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::GetEndpointAttributesOutput,
            aws_smithy_http::result::SdkError<crate::error::GetEndpointAttributesError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::GetEndpointAttributesInputOperationOutputAlias,
                crate::output::GetEndpointAttributesOutput,
                crate::error::GetEndpointAttributesError,
                crate::input::GetEndpointAttributesInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>EndpointArn for GetEndpointAttributes input.</p>
        pub fn endpoint_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.endpoint_arn(inp);
            self
        }
        /// <p>EndpointArn for GetEndpointAttributes input.</p>
        pub fn set_endpoint_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_endpoint_arn(input);
            self
        }
    }
    /// Fluent builder constructing a request to `GetPlatformApplicationAttributes`.
    ///
    /// <p>Retrieves the attributes of the platform application object for the supported push
    /// notification services, such as APNS and GCM (Firebase Cloud Messaging). For more
    /// information, see <a href="https://docs.aws.amazon.com/sns/latest/dg/SNSMobilePush.html">Using Amazon SNS Mobile Push Notifications</a>. </p>
    #[derive(std::fmt::Debug)]
    pub struct GetPlatformApplicationAttributes<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::get_platform_application_attributes_input::Builder,
    }
    impl<C, M, R> GetPlatformApplicationAttributes<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `GetPlatformApplicationAttributes`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::GetPlatformApplicationAttributesOutput,
            aws_smithy_http::result::SdkError<crate::error::GetPlatformApplicationAttributesError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::GetPlatformApplicationAttributesInputOperationOutputAlias,
                crate::output::GetPlatformApplicationAttributesOutput,
                crate::error::GetPlatformApplicationAttributesError,
                crate::input::GetPlatformApplicationAttributesInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>PlatformApplicationArn for GetPlatformApplicationAttributesInput.</p>
        pub fn platform_application_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.platform_application_arn(inp);
            self
        }
        /// <p>PlatformApplicationArn for GetPlatformApplicationAttributesInput.</p>
        pub fn set_platform_application_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_platform_application_arn(input);
            self
        }
    }
    /// Fluent builder constructing a request to `GetSMSAttributes`.
    ///
    /// <p>Returns the settings for sending SMS messages from your account.</p>
    /// <p>These settings are set with the <code>SetSMSAttributes</code> action.</p>
    #[derive(std::fmt::Debug)]
    pub struct GetSMSAttributes<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::get_sms_attributes_input::Builder,
    }
    impl<C, M, R> GetSMSAttributes<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `GetSMSAttributes`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::GetSmsAttributesOutput,
            aws_smithy_http::result::SdkError<crate::error::GetSMSAttributesError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::GetSmsAttributesInputOperationOutputAlias,
                crate::output::GetSmsAttributesOutput,
                crate::error::GetSMSAttributesError,
                crate::input::GetSmsAttributesInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// Appends an item to `attributes`.
        ///
        /// To override the contents of this collection use [`set_attributes`](Self::set_attributes).
        ///
        /// <p>A list of the individual attribute names, such as <code>MonthlySpendLimit</code>, for
        /// which you want values.</p>
        /// <p>For all attribute names, see <a href="https://docs.aws.amazon.com/sns/latest/api/API_SetSMSAttributes.html">SetSMSAttributes</a>.</p>
        /// <p>If you don't use this parameter, Amazon SNS returns all SMS attributes.</p>
        pub fn attributes(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.attributes(inp);
            self
        }
        /// <p>A list of the individual attribute names, such as <code>MonthlySpendLimit</code>, for
        /// which you want values.</p>
        /// <p>For all attribute names, see <a href="https://docs.aws.amazon.com/sns/latest/api/API_SetSMSAttributes.html">SetSMSAttributes</a>.</p>
        /// <p>If you don't use this parameter, Amazon SNS returns all SMS attributes.</p>
        pub fn set_attributes(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.inner = self.inner.set_attributes(input);
            self
        }
    }
    /// Fluent builder constructing a request to `GetSMSSandboxAccountStatus`.
    ///
    /// <p>Retrieves the SMS sandbox status for the calling account in the target Region.</p>
    /// <p>When you start using Amazon SNS to send SMS messages, your account is in the
    /// <i>SMS sandbox</i>. The SMS sandbox provides a safe environment for
    /// you to try Amazon SNS features without risking your reputation as an SMS sender. While your
    /// account is in the SMS sandbox, you can use all of the features of Amazon SNS. However, you can send
    /// SMS messages only to verified destination phone numbers. For more information, including how to
    /// move out of the sandbox to send messages without restrictions,
    /// see <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-sms-sandbox.html">SMS sandbox</a> in
    /// the <i>Amazon SNS Developer Guide</i>.</p>
    #[derive(std::fmt::Debug)]
    pub struct GetSMSSandboxAccountStatus<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::get_sms_sandbox_account_status_input::Builder,
    }
    impl<C, M, R> GetSMSSandboxAccountStatus<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `GetSMSSandboxAccountStatus`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::GetSmsSandboxAccountStatusOutput,
            aws_smithy_http::result::SdkError<crate::error::GetSMSSandboxAccountStatusError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::GetSmsSandboxAccountStatusInputOperationOutputAlias,
                crate::output::GetSmsSandboxAccountStatusOutput,
                crate::error::GetSMSSandboxAccountStatusError,
                crate::input::GetSmsSandboxAccountStatusInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
    }
    /// Fluent builder constructing a request to `GetSubscriptionAttributes`.
    ///
    /// <p>Returns all of the properties of a subscription.</p>
    #[derive(std::fmt::Debug)]
    pub struct GetSubscriptionAttributes<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::get_subscription_attributes_input::Builder,
    }
    impl<C, M, R> GetSubscriptionAttributes<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `GetSubscriptionAttributes`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::GetSubscriptionAttributesOutput,
            aws_smithy_http::result::SdkError<crate::error::GetSubscriptionAttributesError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::GetSubscriptionAttributesInputOperationOutputAlias,
                crate::output::GetSubscriptionAttributesOutput,
                crate::error::GetSubscriptionAttributesError,
                crate::input::GetSubscriptionAttributesInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The ARN of the subscription whose properties you want to get.</p>
        pub fn subscription_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.subscription_arn(inp);
            self
        }
        /// <p>The ARN of the subscription whose properties you want to get.</p>
        pub fn set_subscription_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_subscription_arn(input);
            self
        }
    }
    /// Fluent builder constructing a request to `GetTopicAttributes`.
    ///
    /// <p>Returns all of the properties of a topic. Topic properties returned might differ based
    /// on the authorization of the user.</p>
    #[derive(std::fmt::Debug)]
    pub struct GetTopicAttributes<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::get_topic_attributes_input::Builder,
    }
    impl<C, M, R> GetTopicAttributes<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `GetTopicAttributes`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::GetTopicAttributesOutput,
            aws_smithy_http::result::SdkError<crate::error::GetTopicAttributesError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::GetTopicAttributesInputOperationOutputAlias,
                crate::output::GetTopicAttributesOutput,
                crate::error::GetTopicAttributesError,
                crate::input::GetTopicAttributesInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The ARN of the topic whose properties you want to get.</p>
        pub fn topic_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.topic_arn(inp);
            self
        }
        /// <p>The ARN of the topic whose properties you want to get.</p>
        pub fn set_topic_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_topic_arn(input);
            self
        }
    }
    /// Fluent builder constructing a request to `ListEndpointsByPlatformApplication`.
    ///
    /// <p>Lists the endpoints and endpoint attributes for devices in a supported push
    /// notification service, such as GCM (Firebase Cloud Messaging) and APNS. The results for
    /// <code>ListEndpointsByPlatformApplication</code> are paginated and return a limited
    /// list of endpoints, up to 100. If additional records are available after the first page
    /// results, then a NextToken string will be returned. To receive the next page, you call
    /// <code>ListEndpointsByPlatformApplication</code> again using the NextToken string
    /// received from the previous call. When there are no more records to return, NextToken
    /// will be null. For more information, see <a href="https://docs.aws.amazon.com/sns/latest/dg/SNSMobilePush.html">Using Amazon SNS Mobile Push
    /// Notifications</a>. </p>
    /// <p>This action is throttled at 30 transactions per second (TPS).</p>
    #[derive(std::fmt::Debug)]
    pub struct ListEndpointsByPlatformApplication<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::list_endpoints_by_platform_application_input::Builder,
    }
    impl<C, M, R> ListEndpointsByPlatformApplication<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `ListEndpointsByPlatformApplication`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::ListEndpointsByPlatformApplicationOutput,
            aws_smithy_http::result::SdkError<
                crate::error::ListEndpointsByPlatformApplicationError,
            >,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::ListEndpointsByPlatformApplicationInputOperationOutputAlias,
                crate::output::ListEndpointsByPlatformApplicationOutput,
                crate::error::ListEndpointsByPlatformApplicationError,
                crate::input::ListEndpointsByPlatformApplicationInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>PlatformApplicationArn for ListEndpointsByPlatformApplicationInput action.</p>
        pub fn platform_application_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.platform_application_arn(inp);
            self
        }
        /// <p>PlatformApplicationArn for ListEndpointsByPlatformApplicationInput action.</p>
        pub fn set_platform_application_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_platform_application_arn(input);
            self
        }
        /// <p>NextToken string is used when calling ListEndpointsByPlatformApplication action to
        /// retrieve additional records that are available after the first page results.</p>
        pub fn next_token(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(inp);
            self
        }
        /// <p>NextToken string is used when calling ListEndpointsByPlatformApplication action to
        /// retrieve additional records that are available after the first page 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
        }
    }
    /// Fluent builder constructing a request to `ListOriginationNumbers`.
    ///
    /// <p>Lists the calling account's dedicated origination numbers and their metadata. For
    /// more information about origination numbers, see <a href="https://docs.aws.amazon.com/sns/latest/dg/channels-sms-originating-identities-origination-numbers.html">Origination numbers</a> in the <i>Amazon SNS Developer
    /// Guide</i>.</p>
    #[derive(std::fmt::Debug)]
    pub struct ListOriginationNumbers<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::list_origination_numbers_input::Builder,
    }
    impl<C, M, R> ListOriginationNumbers<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `ListOriginationNumbers`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::ListOriginationNumbersOutput,
            aws_smithy_http::result::SdkError<crate::error::ListOriginationNumbersError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::ListOriginationNumbersInputOperationOutputAlias,
                crate::output::ListOriginationNumbersOutput,
                crate::error::ListOriginationNumbersError,
                crate::input::ListOriginationNumbersInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>Token that the previous <code>ListOriginationNumbers</code> request returns.</p>
        pub fn next_token(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(inp);
            self
        }
        /// <p>Token that the previous <code>ListOriginationNumbers</code> request returns.</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 number of origination numbers to return.</p>
        pub fn max_results(mut self, inp: i32) -> Self {
            self.inner = self.inner.max_results(inp);
            self
        }
        /// <p>The maximum number of origination numbers to return.</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 `ListPhoneNumbersOptedOut`.
    ///
    /// <p>Returns a list of phone numbers that are opted out, meaning you cannot send SMS
    /// messages to them.</p>
    /// <p>The results for <code>ListPhoneNumbersOptedOut</code> are paginated, and each page
    /// returns up to 100 phone numbers. If additional phone numbers are available after the
    /// first page of results, then a <code>NextToken</code> string will be returned. To receive
    /// the next page, you call <code>ListPhoneNumbersOptedOut</code> again using the
    /// <code>NextToken</code> string received from the previous call. When there are no
    /// more records to return, <code>NextToken</code> will be null.</p>
    #[derive(std::fmt::Debug)]
    pub struct ListPhoneNumbersOptedOut<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::list_phone_numbers_opted_out_input::Builder,
    }
    impl<C, M, R> ListPhoneNumbersOptedOut<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `ListPhoneNumbersOptedOut`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::ListPhoneNumbersOptedOutOutput,
            aws_smithy_http::result::SdkError<crate::error::ListPhoneNumbersOptedOutError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::ListPhoneNumbersOptedOutInputOperationOutputAlias,
                crate::output::ListPhoneNumbersOptedOutOutput,
                crate::error::ListPhoneNumbersOptedOutError,
                crate::input::ListPhoneNumbersOptedOutInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>A <code>NextToken</code> string is used when you call the
        /// <code>ListPhoneNumbersOptedOut</code> action to retrieve additional records that are
        /// available after the first page of results.</p>
        pub fn next_token(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(inp);
            self
        }
        /// <p>A <code>NextToken</code> string is used when you call the
        /// <code>ListPhoneNumbersOptedOut</code> action to retrieve additional records that are
        /// available after the first 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
        }
    }
    /// Fluent builder constructing a request to `ListPlatformApplications`.
    ///
    /// <p>Lists the platform application objects for the supported push notification services,
    /// such as APNS and GCM (Firebase Cloud Messaging). The results for
    /// <code>ListPlatformApplications</code> are paginated and return a limited list of
    /// applications, up to 100. If additional records are available after the first page
    /// results, then a NextToken string will be returned. To receive the next page, you call
    /// <code>ListPlatformApplications</code> using the NextToken string received from the
    /// previous call. When there are no more records to return, <code>NextToken</code> will be
    /// null. For more information, see <a href="https://docs.aws.amazon.com/sns/latest/dg/SNSMobilePush.html">Using Amazon SNS Mobile Push
    /// Notifications</a>. </p>
    /// <p>This action is throttled at 15 transactions per second (TPS).</p>
    #[derive(std::fmt::Debug)]
    pub struct ListPlatformApplications<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::list_platform_applications_input::Builder,
    }
    impl<C, M, R> ListPlatformApplications<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `ListPlatformApplications`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::ListPlatformApplicationsOutput,
            aws_smithy_http::result::SdkError<crate::error::ListPlatformApplicationsError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::ListPlatformApplicationsInputOperationOutputAlias,
                crate::output::ListPlatformApplicationsOutput,
                crate::error::ListPlatformApplicationsError,
                crate::input::ListPlatformApplicationsInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>NextToken string is used when calling ListPlatformApplications action to retrieve
        /// additional records that are available after the first page results.</p>
        pub fn next_token(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(inp);
            self
        }
        /// <p>NextToken string is used when calling ListPlatformApplications action to retrieve
        /// additional records that are available after the first page 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
        }
    }
    /// Fluent builder constructing a request to `ListSMSSandboxPhoneNumbers`.
    ///
    /// <p>Lists the calling account's current verified and pending destination phone numbers
    /// in the SMS sandbox.</p>
    /// <p>When you start using Amazon SNS to send SMS messages, your account is in the
    /// <i>SMS sandbox</i>. The SMS sandbox provides a safe environment for
    /// you to try Amazon SNS features without risking your reputation as an SMS sender. While your
    /// account is in the SMS sandbox, you can use all of the features of Amazon SNS. However, you can send
    /// SMS messages only to verified destination phone numbers. For more information, including how to
    /// move out of the sandbox to send messages without restrictions,
    /// see <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-sms-sandbox.html">SMS sandbox</a> in
    /// the <i>Amazon SNS Developer Guide</i>.</p>
    #[derive(std::fmt::Debug)]
    pub struct ListSMSSandboxPhoneNumbers<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::list_sms_sandbox_phone_numbers_input::Builder,
    }
    impl<C, M, R> ListSMSSandboxPhoneNumbers<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `ListSMSSandboxPhoneNumbers`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::ListSmsSandboxPhoneNumbersOutput,
            aws_smithy_http::result::SdkError<crate::error::ListSMSSandboxPhoneNumbersError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::ListSmsSandboxPhoneNumbersInputOperationOutputAlias,
                crate::output::ListSmsSandboxPhoneNumbersOutput,
                crate::error::ListSMSSandboxPhoneNumbersError,
                crate::input::ListSmsSandboxPhoneNumbersInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>Token that the previous <code>ListSMSSandboxPhoneNumbersInput</code> request
        /// returns.</p>
        pub fn next_token(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(inp);
            self
        }
        /// <p>Token that the previous <code>ListSMSSandboxPhoneNumbersInput</code> request
        /// returns.</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 number of phone numbers to return.</p>
        pub fn max_results(mut self, inp: i32) -> Self {
            self.inner = self.inner.max_results(inp);
            self
        }
        /// <p>The maximum number of phone numbers to return.</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 `ListSubscriptions`.
    ///
    /// <p>Returns a list of the requester's subscriptions. Each call returns a limited list of
    /// subscriptions, up to 100. If there are more subscriptions, a <code>NextToken</code> is
    /// also returned. Use the <code>NextToken</code> parameter in a new
    /// <code>ListSubscriptions</code> call to get further results.</p>
    /// <p>This action is throttled at 30 transactions per second (TPS).</p>
    #[derive(std::fmt::Debug)]
    pub struct ListSubscriptions<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::list_subscriptions_input::Builder,
    }
    impl<C, M, R> ListSubscriptions<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `ListSubscriptions`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::ListSubscriptionsOutput,
            aws_smithy_http::result::SdkError<crate::error::ListSubscriptionsError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::ListSubscriptionsInputOperationOutputAlias,
                crate::output::ListSubscriptionsOutput,
                crate::error::ListSubscriptionsError,
                crate::input::ListSubscriptionsInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>Token returned by the previous <code>ListSubscriptions</code> request.</p>
        pub fn next_token(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(inp);
            self
        }
        /// <p>Token returned by the previous <code>ListSubscriptions</code> request.</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
        }
    }
    /// Fluent builder constructing a request to `ListSubscriptionsByTopic`.
    ///
    /// <p>Returns a list of the subscriptions to a specific topic. Each call returns a limited
    /// list of subscriptions, up to 100. If there are more subscriptions, a
    /// <code>NextToken</code> is also returned. Use the <code>NextToken</code> parameter in
    /// a new <code>ListSubscriptionsByTopic</code> call to get further results.</p>
    /// <p>This action is throttled at 30 transactions per second (TPS).</p>
    #[derive(std::fmt::Debug)]
    pub struct ListSubscriptionsByTopic<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::list_subscriptions_by_topic_input::Builder,
    }
    impl<C, M, R> ListSubscriptionsByTopic<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `ListSubscriptionsByTopic`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::ListSubscriptionsByTopicOutput,
            aws_smithy_http::result::SdkError<crate::error::ListSubscriptionsByTopicError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::ListSubscriptionsByTopicInputOperationOutputAlias,
                crate::output::ListSubscriptionsByTopicOutput,
                crate::error::ListSubscriptionsByTopicError,
                crate::input::ListSubscriptionsByTopicInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The ARN of the topic for which you wish to find subscriptions.</p>
        pub fn topic_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.topic_arn(inp);
            self
        }
        /// <p>The ARN of the topic for which you wish to find subscriptions.</p>
        pub fn set_topic_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_topic_arn(input);
            self
        }
        /// <p>Token returned by the previous <code>ListSubscriptionsByTopic</code> request.</p>
        pub fn next_token(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(inp);
            self
        }
        /// <p>Token returned by the previous <code>ListSubscriptionsByTopic</code> request.</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
        }
    }
    /// Fluent builder constructing a request to `ListTagsForResource`.
    ///
    /// <p>List all tags added to the specified Amazon SNS topic. For an overview, see <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-tags.html">Amazon SNS Tags</a> in the
    /// <i>Amazon Simple Notification Service Developer Guide</i>.</p>
    #[derive(std::fmt::Debug)]
    pub struct ListTagsForResource<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::list_tags_for_resource_input::Builder,
    }
    impl<C, M, R> ListTagsForResource<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `ListTagsForResource`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::ListTagsForResourceOutput,
            aws_smithy_http::result::SdkError<crate::error::ListTagsForResourceError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::ListTagsForResourceInputOperationOutputAlias,
                crate::output::ListTagsForResourceOutput,
                crate::error::ListTagsForResourceError,
                crate::input::ListTagsForResourceInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The ARN of the topic for which to list tags.</p>
        pub fn resource_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.resource_arn(inp);
            self
        }
        /// <p>The ARN of the topic for which to list tags.</p>
        pub fn set_resource_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_resource_arn(input);
            self
        }
    }
    /// Fluent builder constructing a request to `ListTopics`.
    ///
    /// <p>Returns a list of the requester's topics. Each call returns a limited list of topics,
    /// up to 100. If there are more topics, a <code>NextToken</code> is also returned. Use the
    /// <code>NextToken</code> parameter in a new <code>ListTopics</code> call to get
    /// further results.</p>
    /// <p>This action is throttled at 30 transactions per second (TPS).</p>
    #[derive(std::fmt::Debug)]
    pub struct ListTopics<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::list_topics_input::Builder,
    }
    impl<C, M, R> ListTopics<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `ListTopics`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::ListTopicsOutput,
            aws_smithy_http::result::SdkError<crate::error::ListTopicsError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::ListTopicsInputOperationOutputAlias,
                crate::output::ListTopicsOutput,
                crate::error::ListTopicsError,
                crate::input::ListTopicsInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>Token returned by the previous <code>ListTopics</code> request.</p>
        pub fn next_token(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.next_token(inp);
            self
        }
        /// <p>Token returned by the previous <code>ListTopics</code> request.</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
        }
    }
    /// Fluent builder constructing a request to `OptInPhoneNumber`.
    ///
    /// <p>Use this request to opt in a phone number that is opted out, which enables you to
    /// resume sending SMS messages to the number.</p>
    /// <p>You can opt in a phone number only once every 30 days.</p>
    #[derive(std::fmt::Debug)]
    pub struct OptInPhoneNumber<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::opt_in_phone_number_input::Builder,
    }
    impl<C, M, R> OptInPhoneNumber<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `OptInPhoneNumber`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::OptInPhoneNumberOutput,
            aws_smithy_http::result::SdkError<crate::error::OptInPhoneNumberError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::OptInPhoneNumberInputOperationOutputAlias,
                crate::output::OptInPhoneNumberOutput,
                crate::error::OptInPhoneNumberError,
                crate::input::OptInPhoneNumberInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The phone number to opt in. Use E.164 format.</p>
        pub fn phone_number(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.phone_number(inp);
            self
        }
        /// <p>The phone number to opt in. Use E.164 format.</p>
        pub fn set_phone_number(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_phone_number(input);
            self
        }
    }
    /// Fluent builder constructing a request to `Publish`.
    ///
    /// <p>Sends a message to an Amazon SNS topic, a text message (SMS message) directly to a phone
    /// number, or a message to a mobile platform endpoint (when you specify the
    /// <code>TargetArn</code>).</p>
    /// <p>If you send a message to a topic, Amazon SNS delivers the message to each endpoint that is
    /// subscribed to the topic. The format of the message depends on the notification protocol
    /// for each subscribed endpoint.</p>
    /// <p>When a <code>messageId</code> is returned, the message has been saved and Amazon SNS
    /// will attempt to deliver it shortly.</p>
    /// <p>To use the <code>Publish</code> action for sending a message to a mobile endpoint,
    /// such as an app on a Kindle device or mobile phone, you must specify the EndpointArn for
    /// the TargetArn parameter. The EndpointArn is returned when making a call with the
    /// <code>CreatePlatformEndpoint</code> action. </p>
    /// <p>For more information about formatting messages, see <a href="https://docs.aws.amazon.com/sns/latest/dg/mobile-push-send-custommessage.html">Send Custom
    /// Platform-Specific Payloads in Messages to Mobile Devices</a>. </p>
    /// <important>
    /// <p>You can publish messages only to topics and endpoints in the same Region.</p>
    /// </important>
    #[derive(std::fmt::Debug)]
    pub struct Publish<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::publish_input::Builder,
    }
    impl<C, M, R> Publish<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `Publish`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::PublishOutput,
            aws_smithy_http::result::SdkError<crate::error::PublishError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::PublishInputOperationOutputAlias,
                crate::output::PublishOutput,
                crate::error::PublishError,
                crate::input::PublishInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The topic you want to publish to.</p>
        /// <p>If you don't specify a value for the <code>TopicArn</code> parameter, you must specify
        /// a value for the <code>PhoneNumber</code> or <code>TargetArn</code> parameters.</p>
        pub fn topic_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.topic_arn(inp);
            self
        }
        /// <p>The topic you want to publish to.</p>
        /// <p>If you don't specify a value for the <code>TopicArn</code> parameter, you must specify
        /// a value for the <code>PhoneNumber</code> or <code>TargetArn</code> parameters.</p>
        pub fn set_topic_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_topic_arn(input);
            self
        }
        /// <p>If you don't specify a value for the <code>TargetArn</code> parameter, you must
        /// specify a value for the <code>PhoneNumber</code> or <code>TopicArn</code>
        /// parameters.</p>
        pub fn target_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.target_arn(inp);
            self
        }
        /// <p>If you don't specify a value for the <code>TargetArn</code> parameter, you must
        /// specify a value for the <code>PhoneNumber</code> or <code>TopicArn</code>
        /// parameters.</p>
        pub fn set_target_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_target_arn(input);
            self
        }
        /// <p>The phone number to which you want to deliver an SMS message. Use E.164 format.</p>
        /// <p>If you don't specify a value for the <code>PhoneNumber</code> parameter, you must
        /// specify a value for the <code>TargetArn</code> or <code>TopicArn</code>
        /// parameters.</p>
        pub fn phone_number(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.phone_number(inp);
            self
        }
        /// <p>The phone number to which you want to deliver an SMS message. Use E.164 format.</p>
        /// <p>If you don't specify a value for the <code>PhoneNumber</code> parameter, you must
        /// specify a value for the <code>TargetArn</code> or <code>TopicArn</code>
        /// parameters.</p>
        pub fn set_phone_number(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_phone_number(input);
            self
        }
        /// <p>The message you want to send.</p>
        /// <p>If you are publishing to a topic and you want to send the same message to all
        /// transport protocols, include the text of the message as a String value. If you want to
        /// send different messages for each transport protocol, set the value of the
        /// <code>MessageStructure</code> parameter to <code>json</code> and use a JSON object
        /// for the <code>Message</code> parameter.
        /// </p>
        /// <p></p>
        /// <p>Constraints:</p>
        /// <ul>
        /// <li>
        /// <p>With the exception of SMS, messages must be UTF-8 encoded strings and at most
        /// 256 KB in size (262,144 bytes, not 262,144 characters).</p>
        /// </li>
        /// <li>
        /// <p>For SMS, each message can contain up to 140 characters. This character limit
        /// depends on the encoding schema. For example, an SMS message can contain 160 GSM
        /// characters, 140 ASCII characters, or 70 UCS-2 characters.</p>
        /// <p>If you publish a message that exceeds this size limit, Amazon SNS sends the message
        /// as multiple messages, each fitting within the size limit. Messages aren't
        /// truncated mid-word but are cut off at whole-word boundaries.</p>
        /// <p>The total size limit for a single SMS <code>Publish</code> action is 1,600
        /// characters.</p>
        /// </li>
        /// </ul>
        /// <p>JSON-specific constraints:</p>
        /// <ul>
        /// <li>
        /// <p>Keys in the JSON object that correspond to supported transport protocols must
        /// have simple JSON string values.</p>
        /// </li>
        /// <li>
        /// <p>The values will be parsed (unescaped) before they are used in outgoing
        /// messages.</p>
        /// </li>
        /// <li>
        /// <p>Outbound notifications are JSON encoded (meaning that the characters will be
        /// reescaped for sending).</p>
        /// </li>
        /// <li>
        /// <p>Values have a minimum length of 0 (the empty string, "", is allowed).</p>
        /// </li>
        /// <li>
        /// <p>Values have a maximum length bounded by the overall message size (so,
        /// including multiple protocols may limit message sizes).</p>
        /// </li>
        /// <li>
        /// <p>Non-string values will cause the key to be ignored.</p>
        /// </li>
        /// <li>
        /// <p>Keys that do not correspond to supported transport protocols are
        /// ignored.</p>
        /// </li>
        /// <li>
        /// <p>Duplicate keys are not allowed.</p>
        /// </li>
        /// <li>
        /// <p>Failure to parse or validate any key or value in the message will cause the
        /// <code>Publish</code> call to return an error (no partial delivery).</p>
        /// </li>
        /// </ul>
        pub fn message(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.message(inp);
            self
        }
        /// <p>The message you want to send.</p>
        /// <p>If you are publishing to a topic and you want to send the same message to all
        /// transport protocols, include the text of the message as a String value. If you want to
        /// send different messages for each transport protocol, set the value of the
        /// <code>MessageStructure</code> parameter to <code>json</code> and use a JSON object
        /// for the <code>Message</code> parameter.
        /// </p>
        /// <p></p>
        /// <p>Constraints:</p>
        /// <ul>
        /// <li>
        /// <p>With the exception of SMS, messages must be UTF-8 encoded strings and at most
        /// 256 KB in size (262,144 bytes, not 262,144 characters).</p>
        /// </li>
        /// <li>
        /// <p>For SMS, each message can contain up to 140 characters. This character limit
        /// depends on the encoding schema. For example, an SMS message can contain 160 GSM
        /// characters, 140 ASCII characters, or 70 UCS-2 characters.</p>
        /// <p>If you publish a message that exceeds this size limit, Amazon SNS sends the message
        /// as multiple messages, each fitting within the size limit. Messages aren't
        /// truncated mid-word but are cut off at whole-word boundaries.</p>
        /// <p>The total size limit for a single SMS <code>Publish</code> action is 1,600
        /// characters.</p>
        /// </li>
        /// </ul>
        /// <p>JSON-specific constraints:</p>
        /// <ul>
        /// <li>
        /// <p>Keys in the JSON object that correspond to supported transport protocols must
        /// have simple JSON string values.</p>
        /// </li>
        /// <li>
        /// <p>The values will be parsed (unescaped) before they are used in outgoing
        /// messages.</p>
        /// </li>
        /// <li>
        /// <p>Outbound notifications are JSON encoded (meaning that the characters will be
        /// reescaped for sending).</p>
        /// </li>
        /// <li>
        /// <p>Values have a minimum length of 0 (the empty string, "", is allowed).</p>
        /// </li>
        /// <li>
        /// <p>Values have a maximum length bounded by the overall message size (so,
        /// including multiple protocols may limit message sizes).</p>
        /// </li>
        /// <li>
        /// <p>Non-string values will cause the key to be ignored.</p>
        /// </li>
        /// <li>
        /// <p>Keys that do not correspond to supported transport protocols are
        /// ignored.</p>
        /// </li>
        /// <li>
        /// <p>Duplicate keys are not allowed.</p>
        /// </li>
        /// <li>
        /// <p>Failure to parse or validate any key or value in the message will cause the
        /// <code>Publish</code> call to return an error (no partial delivery).</p>
        /// </li>
        /// </ul>
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_message(input);
            self
        }
        /// <p>Optional parameter to be used as the "Subject" line when the message is delivered to
        /// email endpoints. This field will also be included, if present, in the standard JSON
        /// messages delivered to other endpoints.</p>
        /// <p>Constraints: Subjects must be ASCII text that begins with a letter, number, or
        /// punctuation mark; must not include line breaks or control characters; and must be less
        /// than 100 characters long.</p>
        pub fn subject(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.subject(inp);
            self
        }
        /// <p>Optional parameter to be used as the "Subject" line when the message is delivered to
        /// email endpoints. This field will also be included, if present, in the standard JSON
        /// messages delivered to other endpoints.</p>
        /// <p>Constraints: Subjects must be ASCII text that begins with a letter, number, or
        /// punctuation mark; must not include line breaks or control characters; and must be less
        /// than 100 characters long.</p>
        pub fn set_subject(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_subject(input);
            self
        }
        /// <p>Set <code>MessageStructure</code> to <code>json</code> if you want to send a different
        /// message for each protocol. For example, using one publish action, you can send a short
        /// message to your SMS subscribers and a longer message to your email subscribers. If you
        /// set <code>MessageStructure</code> to <code>json</code>, the value of the
        /// <code>Message</code> parameter must: </p>
        /// <ul>
        /// <li>
        /// <p>be a syntactically valid JSON object; and</p>
        /// </li>
        /// <li>
        /// <p>contain at least a top-level JSON key of "default" with a value that is a
        /// string.</p>
        /// </li>
        /// </ul>
        /// <p>You can define other top-level keys that define the message you want to send to a
        /// specific transport protocol (e.g., "http").</p>
        /// <p>Valid value: <code>json</code>
        /// </p>
        pub fn message_structure(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.message_structure(inp);
            self
        }
        /// <p>Set <code>MessageStructure</code> to <code>json</code> if you want to send a different
        /// message for each protocol. For example, using one publish action, you can send a short
        /// message to your SMS subscribers and a longer message to your email subscribers. If you
        /// set <code>MessageStructure</code> to <code>json</code>, the value of the
        /// <code>Message</code> parameter must: </p>
        /// <ul>
        /// <li>
        /// <p>be a syntactically valid JSON object; and</p>
        /// </li>
        /// <li>
        /// <p>contain at least a top-level JSON key of "default" with a value that is a
        /// string.</p>
        /// </li>
        /// </ul>
        /// <p>You can define other top-level keys that define the message you want to send to a
        /// specific transport protocol (e.g., "http").</p>
        /// <p>Valid value: <code>json</code>
        /// </p>
        pub fn set_message_structure(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_message_structure(input);
            self
        }
        /// Adds a key-value pair to `MessageAttributes`.
        ///
        /// To override the contents of this collection use [`set_message_attributes`](Self::set_message_attributes).
        ///
        /// <p>Message attributes for Publish action.</p>
        pub fn message_attributes(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<crate::model::MessageAttributeValue>,
        ) -> Self {
            self.inner = self.inner.message_attributes(k, v);
            self
        }
        /// <p>Message attributes for Publish action.</p>
        pub fn set_message_attributes(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, crate::model::MessageAttributeValue>,
            >,
        ) -> Self {
            self.inner = self.inner.set_message_attributes(input);
            self
        }
        /// <p>This parameter applies only to FIFO (first-in-first-out) topics. The
        /// <code>MessageDeduplicationId</code> can contain up to 128 alphanumeric characters
        /// (a-z, A-Z, 0-9) and punctuation
        /// <code>(!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~)</code>.</p>
        /// <p>Every message must have a unique <code>MessageDeduplicationId</code>, which is a token
        /// used for deduplication of sent messages. If a message with a particular
        /// <code>MessageDeduplicationId</code> is sent successfully, any message sent with the
        /// same <code>MessageDeduplicationId</code> during the 5-minute deduplication interval is
        /// treated as a duplicate. </p>
        /// <p>If the topic has <code>ContentBasedDeduplication</code> set, the system generates a
        /// <code>MessageDeduplicationId</code> based on the contents of the message. Your
        /// <code>MessageDeduplicationId</code> overrides the generated one.</p>
        pub fn message_deduplication_id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.message_deduplication_id(inp);
            self
        }
        /// <p>This parameter applies only to FIFO (first-in-first-out) topics. The
        /// <code>MessageDeduplicationId</code> can contain up to 128 alphanumeric characters
        /// (a-z, A-Z, 0-9) and punctuation
        /// <code>(!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~)</code>.</p>
        /// <p>Every message must have a unique <code>MessageDeduplicationId</code>, which is a token
        /// used for deduplication of sent messages. If a message with a particular
        /// <code>MessageDeduplicationId</code> is sent successfully, any message sent with the
        /// same <code>MessageDeduplicationId</code> during the 5-minute deduplication interval is
        /// treated as a duplicate. </p>
        /// <p>If the topic has <code>ContentBasedDeduplication</code> set, the system generates a
        /// <code>MessageDeduplicationId</code> based on the contents of the message. Your
        /// <code>MessageDeduplicationId</code> overrides the generated one.</p>
        pub fn set_message_deduplication_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_message_deduplication_id(input);
            self
        }
        /// <p>This parameter applies only to FIFO (first-in-first-out) topics. The
        /// <code>MessageGroupId</code> can contain up to 128 alphanumeric characters (a-z, A-Z,
        /// 0-9) and punctuation <code>(!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~)</code>.</p>
        /// <p>The <code>MessageGroupId</code> is a tag that specifies that a message belongs to a
        /// specific message group. Messages that belong to the same message group are processed in
        /// a FIFO manner (however, messages in different message groups might be processed out of
        /// order). Every message must include a <code>MessageGroupId</code>.</p>
        pub fn message_group_id(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.message_group_id(inp);
            self
        }
        /// <p>This parameter applies only to FIFO (first-in-first-out) topics. The
        /// <code>MessageGroupId</code> can contain up to 128 alphanumeric characters (a-z, A-Z,
        /// 0-9) and punctuation <code>(!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~)</code>.</p>
        /// <p>The <code>MessageGroupId</code> is a tag that specifies that a message belongs to a
        /// specific message group. Messages that belong to the same message group are processed in
        /// a FIFO manner (however, messages in different message groups might be processed out of
        /// order). Every message must include a <code>MessageGroupId</code>.</p>
        pub fn set_message_group_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_message_group_id(input);
            self
        }
    }
    /// Fluent builder constructing a request to `RemovePermission`.
    ///
    /// <p>Removes a statement from a topic's access control policy.</p>
    #[derive(std::fmt::Debug)]
    pub struct RemovePermission<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::remove_permission_input::Builder,
    }
    impl<C, M, R> RemovePermission<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `RemovePermission`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::RemovePermissionOutput,
            aws_smithy_http::result::SdkError<crate::error::RemovePermissionError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::RemovePermissionInputOperationOutputAlias,
                crate::output::RemovePermissionOutput,
                crate::error::RemovePermissionError,
                crate::input::RemovePermissionInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The ARN of the topic whose access control policy you wish to modify.</p>
        pub fn topic_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.topic_arn(inp);
            self
        }
        /// <p>The ARN of the topic whose access control policy you wish to modify.</p>
        pub fn set_topic_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_topic_arn(input);
            self
        }
        /// <p>The unique label of the statement you want to remove.</p>
        pub fn label(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.label(inp);
            self
        }
        /// <p>The unique label of the statement you want to remove.</p>
        pub fn set_label(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_label(input);
            self
        }
    }
    /// Fluent builder constructing a request to `SetEndpointAttributes`.
    ///
    /// <p>Sets the attributes for an endpoint for a device on one of the supported push
    /// notification services, such as GCM (Firebase Cloud Messaging) and APNS. For more
    /// information, see <a href="https://docs.aws.amazon.com/sns/latest/dg/SNSMobilePush.html">Using Amazon SNS Mobile Push Notifications</a>. </p>
    #[derive(std::fmt::Debug)]
    pub struct SetEndpointAttributes<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::set_endpoint_attributes_input::Builder,
    }
    impl<C, M, R> SetEndpointAttributes<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `SetEndpointAttributes`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::SetEndpointAttributesOutput,
            aws_smithy_http::result::SdkError<crate::error::SetEndpointAttributesError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::SetEndpointAttributesInputOperationOutputAlias,
                crate::output::SetEndpointAttributesOutput,
                crate::error::SetEndpointAttributesError,
                crate::input::SetEndpointAttributesInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>EndpointArn used for SetEndpointAttributes action.</p>
        pub fn endpoint_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.endpoint_arn(inp);
            self
        }
        /// <p>EndpointArn used for SetEndpointAttributes action.</p>
        pub fn set_endpoint_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_endpoint_arn(input);
            self
        }
        /// Adds a key-value pair to `Attributes`.
        ///
        /// To override the contents of this collection use [`set_attributes`](Self::set_attributes).
        ///
        /// <p>A map of the endpoint attributes. Attributes in this map include the following:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>CustomUserData</code> – arbitrary user data to associate with the
        /// endpoint. Amazon SNS does not use this data. The data must be in UTF-8 format and
        /// less than 2KB.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>Enabled</code> – flag that enables/disables delivery to the
        /// endpoint. Amazon SNS will set this to false when a notification service indicates to
        /// Amazon SNS that the endpoint is invalid. Users can set it back to true, typically
        /// after updating Token.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>Token</code> – device token, also referred to as a registration id,
        /// for an app and mobile device. This is returned from the notification service
        /// when an app and mobile device are registered with the notification
        /// service.</p>
        /// </li>
        /// </ul>
        pub fn attributes(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self.inner.attributes(k, v);
            self
        }
        /// <p>A map of the endpoint attributes. Attributes in this map include the following:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>CustomUserData</code> – arbitrary user data to associate with the
        /// endpoint. Amazon SNS does not use this data. The data must be in UTF-8 format and
        /// less than 2KB.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>Enabled</code> – flag that enables/disables delivery to the
        /// endpoint. Amazon SNS will set this to false when a notification service indicates to
        /// Amazon SNS that the endpoint is invalid. Users can set it back to true, typically
        /// after updating Token.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>Token</code> – device token, also referred to as a registration id,
        /// for an app and mobile device. This is returned from the notification service
        /// when an app and mobile device are registered with the notification
        /// service.</p>
        /// </li>
        /// </ul>
        pub fn set_attributes(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, std::string::String>,
            >,
        ) -> Self {
            self.inner = self.inner.set_attributes(input);
            self
        }
    }
    /// Fluent builder constructing a request to `SetPlatformApplicationAttributes`.
    ///
    /// <p>Sets the attributes of the platform application object for the supported push
    /// notification services, such as APNS and GCM (Firebase Cloud Messaging). For more
    /// information, see <a href="https://docs.aws.amazon.com/sns/latest/dg/SNSMobilePush.html">Using Amazon SNS Mobile Push Notifications</a>. For information on configuring
    /// attributes for message delivery status, see <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-msg-status.html">Using Amazon SNS Application Attributes for
    /// Message Delivery Status</a>. </p>
    #[derive(std::fmt::Debug)]
    pub struct SetPlatformApplicationAttributes<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::set_platform_application_attributes_input::Builder,
    }
    impl<C, M, R> SetPlatformApplicationAttributes<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `SetPlatformApplicationAttributes`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::SetPlatformApplicationAttributesOutput,
            aws_smithy_http::result::SdkError<crate::error::SetPlatformApplicationAttributesError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::SetPlatformApplicationAttributesInputOperationOutputAlias,
                crate::output::SetPlatformApplicationAttributesOutput,
                crate::error::SetPlatformApplicationAttributesError,
                crate::input::SetPlatformApplicationAttributesInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>PlatformApplicationArn for SetPlatformApplicationAttributes action.</p>
        pub fn platform_application_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.platform_application_arn(inp);
            self
        }
        /// <p>PlatformApplicationArn for SetPlatformApplicationAttributes action.</p>
        pub fn set_platform_application_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_platform_application_arn(input);
            self
        }
        /// Adds a key-value pair to `Attributes`.
        ///
        /// To override the contents of this collection use [`set_attributes`](Self::set_attributes).
        ///
        /// <p>A map of the platform application attributes. Attributes in this map include the
        /// following:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>PlatformCredential</code> – The credential received from the
        /// notification service. For <code>APNS</code> and <code>APNS_SANDBOX</code>,
        /// <code>PlatformCredential</code> is <code>private key</code>. For
        /// <code>GCM</code> (Firebase Cloud Messaging), <code>PlatformCredential</code>
        /// is <code>API key</code>. For <code>ADM</code>, <code>PlatformCredential</code>
        /// is <code>client secret</code>.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>PlatformPrincipal</code> – The principal received from the
        /// notification service. For <code>APNS</code> and <code>APNS_SANDBOX</code>,
        /// <code>PlatformPrincipal</code> is <code>SSL certificate</code>. For
        /// <code>GCM</code> (Firebase Cloud Messaging), there is no
        /// <code>PlatformPrincipal</code>. For <code>ADM</code>,
        /// <code>PlatformPrincipal</code> is <code>client id</code>.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>EventEndpointCreated</code> – Topic ARN to which
        /// <code>EndpointCreated</code> event notifications are sent.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>EventEndpointDeleted</code> – Topic ARN to which
        /// <code>EndpointDeleted</code> event notifications are sent.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>EventEndpointUpdated</code> – Topic ARN to which
        /// <code>EndpointUpdate</code> event notifications are sent.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>EventDeliveryFailure</code> – Topic ARN to which
        /// <code>DeliveryFailure</code> event notifications are sent upon Direct
        /// Publish delivery failure (permanent) to one of the application's
        /// endpoints.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>SuccessFeedbackRoleArn</code> – IAM role ARN used to give Amazon SNS
        /// write access to use CloudWatch Logs on your behalf.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>FailureFeedbackRoleArn</code> – IAM role ARN used to give Amazon SNS
        /// write access to use CloudWatch Logs on your behalf.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>SuccessFeedbackSampleRate</code> – Sample rate percentage (0-100)
        /// of successfully delivered messages.</p>
        /// </li>
        /// </ul>
        pub fn attributes(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self.inner.attributes(k, v);
            self
        }
        /// <p>A map of the platform application attributes. Attributes in this map include the
        /// following:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>PlatformCredential</code> – The credential received from the
        /// notification service. For <code>APNS</code> and <code>APNS_SANDBOX</code>,
        /// <code>PlatformCredential</code> is <code>private key</code>. For
        /// <code>GCM</code> (Firebase Cloud Messaging), <code>PlatformCredential</code>
        /// is <code>API key</code>. For <code>ADM</code>, <code>PlatformCredential</code>
        /// is <code>client secret</code>.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>PlatformPrincipal</code> – The principal received from the
        /// notification service. For <code>APNS</code> and <code>APNS_SANDBOX</code>,
        /// <code>PlatformPrincipal</code> is <code>SSL certificate</code>. For
        /// <code>GCM</code> (Firebase Cloud Messaging), there is no
        /// <code>PlatformPrincipal</code>. For <code>ADM</code>,
        /// <code>PlatformPrincipal</code> is <code>client id</code>.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>EventEndpointCreated</code> – Topic ARN to which
        /// <code>EndpointCreated</code> event notifications are sent.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>EventEndpointDeleted</code> – Topic ARN to which
        /// <code>EndpointDeleted</code> event notifications are sent.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>EventEndpointUpdated</code> – Topic ARN to which
        /// <code>EndpointUpdate</code> event notifications are sent.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>EventDeliveryFailure</code> – Topic ARN to which
        /// <code>DeliveryFailure</code> event notifications are sent upon Direct
        /// Publish delivery failure (permanent) to one of the application's
        /// endpoints.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>SuccessFeedbackRoleArn</code> – IAM role ARN used to give Amazon SNS
        /// write access to use CloudWatch Logs on your behalf.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>FailureFeedbackRoleArn</code> – IAM role ARN used to give Amazon SNS
        /// write access to use CloudWatch Logs on your behalf.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>SuccessFeedbackSampleRate</code> – Sample rate percentage (0-100)
        /// of successfully delivered messages.</p>
        /// </li>
        /// </ul>
        pub fn set_attributes(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, std::string::String>,
            >,
        ) -> Self {
            self.inner = self.inner.set_attributes(input);
            self
        }
    }
    /// Fluent builder constructing a request to `SetSMSAttributes`.
    ///
    /// <p>Use this request to set the default settings for sending SMS messages and receiving
    /// daily SMS usage reports.</p>
    /// <p>You can override some of these settings for a single message when you use the
    /// <code>Publish</code> action with the <code>MessageAttributes.entry.N</code>
    /// parameter. For more information, see <a href="https://docs.aws.amazon.com/sns/latest/dg/sms_publish-to-phone.html">Publishing to a mobile phone</a>
    /// in the <i>Amazon SNS Developer Guide</i>.</p>
    /// <note>
    /// <p>To use this operation, you must grant the Amazon SNS service principal
    /// (<code>sns.amazonaws.com</code>) permission to perform the
    /// <code>s3:ListBucket</code> action. </p>
    /// </note>
    #[derive(std::fmt::Debug)]
    pub struct SetSMSAttributes<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::set_sms_attributes_input::Builder,
    }
    impl<C, M, R> SetSMSAttributes<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `SetSMSAttributes`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::SetSmsAttributesOutput,
            aws_smithy_http::result::SdkError<crate::error::SetSMSAttributesError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::SetSmsAttributesInputOperationOutputAlias,
                crate::output::SetSmsAttributesOutput,
                crate::error::SetSMSAttributesError,
                crate::input::SetSmsAttributesInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// Adds a key-value pair to `attributes`.
        ///
        /// To override the contents of this collection use [`set_attributes`](Self::set_attributes).
        ///
        /// <p>The default settings for sending SMS messages from your account. You can set values
        /// for the following attribute names:</p>
        /// <p>
        /// <code>MonthlySpendLimit</code> – The maximum amount in USD that you are willing to spend
        /// each month to send SMS messages. When Amazon SNS determines that sending an SMS message would
        /// incur a cost that exceeds this limit, it stops sending SMS messages within
        /// minutes.</p>
        /// <important>
        /// <p>Amazon SNS stops sending SMS messages within minutes of the limit being crossed. During
        /// that interval, if you continue to send SMS messages, you will incur costs that
        /// exceed your limit.</p>
        /// </important>
        /// <p>By default, the spend limit is set to the maximum allowed by Amazon SNS. If you want to
        /// raise the limit, submit an <a href="https://console.aws.amazon.com/support/home#/case/create?issueType=service-limit-increase&limitType=service-code-sns">SNS Limit Increase case</a>. For <b>New limit
        /// value</b>, enter your desired monthly spend limit. In the <b>Use Case Description</b> field, explain that you are requesting
        /// an SMS monthly spend limit increase.</p>
        /// <p>
        /// <code>DeliveryStatusIAMRole</code> – The ARN of the IAM role that allows Amazon SNS to write
        /// logs about SMS deliveries in CloudWatch Logs. For each SMS message that you send, Amazon SNS
        /// writes a log that includes the message price, the success or failure status, the reason
        /// for failure (if the message failed), the message dwell time, and other
        /// information.</p>
        /// <p>
        /// <code>DeliveryStatusSuccessSamplingRate</code> – The percentage of successful SMS
        /// deliveries for which Amazon SNS will write logs in CloudWatch Logs. The value can be an
        /// integer from 0 - 100. For example, to write logs only for failed deliveries, set this
        /// value to <code>0</code>. To write logs for 10% of your successful deliveries, set it to
        /// <code>10</code>.</p>
        /// <p>
        /// <code>DefaultSenderID</code> – A string, such as your business brand, that is displayed
        /// as the sender on the receiving device. Support for sender IDs varies by country. The
        /// sender ID can be 1 - 11 alphanumeric characters, and it must contain at least one
        /// letter.</p>
        /// <p>
        /// <code>DefaultSMSType</code> – The type of SMS message that you will send by default. You
        /// can assign the following values:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>Promotional</code> – (Default) Noncritical messages, such as marketing
        /// messages. Amazon SNS optimizes the message delivery to incur the lowest cost.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>Transactional</code> – Critical messages that support customer
        /// transactions, such as one-time passcodes for multi-factor authentication. Amazon
        /// SNS optimizes the message delivery to achieve the highest reliability.</p>
        /// </li>
        /// </ul>
        /// <p>
        /// <code>UsageReportS3Bucket</code> – The name of the Amazon S3 bucket to receive daily SMS
        /// usage reports from Amazon SNS. Each day, Amazon SNS will deliver a usage report as a CSV file to
        /// the bucket. The report includes the following information for each SMS message that was
        /// successfully delivered by your account:</p>
        /// <ul>
        /// <li>
        /// <p>Time that the message was published (in UTC)</p>
        /// </li>
        /// <li>
        /// <p>Message ID</p>
        /// </li>
        /// <li>
        /// <p>Destination phone number</p>
        /// </li>
        /// <li>
        /// <p>Message type</p>
        /// </li>
        /// <li>
        /// <p>Delivery status</p>
        /// </li>
        /// <li>
        /// <p>Message price (in USD)</p>
        /// </li>
        /// <li>
        /// <p>Part number (a message is split into multiple parts if it is too long for a
        /// single message)</p>
        /// </li>
        /// <li>
        /// <p>Total number of parts</p>
        /// </li>
        /// </ul>
        /// <p>To receive the report, the bucket must have a policy that allows the Amazon SNS service
        /// principal to perform the <code>s3:PutObject</code> and <code>s3:GetBucketLocation</code>
        /// actions.</p>
        /// <p>For an example bucket policy and usage report, see <a href="https://docs.aws.amazon.com/sns/latest/dg/sms_stats.html">Monitoring SMS Activity</a> in the
        /// <i>Amazon SNS Developer Guide</i>.</p>
        pub fn attributes(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self.inner.attributes(k, v);
            self
        }
        /// <p>The default settings for sending SMS messages from your account. You can set values
        /// for the following attribute names:</p>
        /// <p>
        /// <code>MonthlySpendLimit</code> – The maximum amount in USD that you are willing to spend
        /// each month to send SMS messages. When Amazon SNS determines that sending an SMS message would
        /// incur a cost that exceeds this limit, it stops sending SMS messages within
        /// minutes.</p>
        /// <important>
        /// <p>Amazon SNS stops sending SMS messages within minutes of the limit being crossed. During
        /// that interval, if you continue to send SMS messages, you will incur costs that
        /// exceed your limit.</p>
        /// </important>
        /// <p>By default, the spend limit is set to the maximum allowed by Amazon SNS. If you want to
        /// raise the limit, submit an <a href="https://console.aws.amazon.com/support/home#/case/create?issueType=service-limit-increase&limitType=service-code-sns">SNS Limit Increase case</a>. For <b>New limit
        /// value</b>, enter your desired monthly spend limit. In the <b>Use Case Description</b> field, explain that you are requesting
        /// an SMS monthly spend limit increase.</p>
        /// <p>
        /// <code>DeliveryStatusIAMRole</code> – The ARN of the IAM role that allows Amazon SNS to write
        /// logs about SMS deliveries in CloudWatch Logs. For each SMS message that you send, Amazon SNS
        /// writes a log that includes the message price, the success or failure status, the reason
        /// for failure (if the message failed), the message dwell time, and other
        /// information.</p>
        /// <p>
        /// <code>DeliveryStatusSuccessSamplingRate</code> – The percentage of successful SMS
        /// deliveries for which Amazon SNS will write logs in CloudWatch Logs. The value can be an
        /// integer from 0 - 100. For example, to write logs only for failed deliveries, set this
        /// value to <code>0</code>. To write logs for 10% of your successful deliveries, set it to
        /// <code>10</code>.</p>
        /// <p>
        /// <code>DefaultSenderID</code> – A string, such as your business brand, that is displayed
        /// as the sender on the receiving device. Support for sender IDs varies by country. The
        /// sender ID can be 1 - 11 alphanumeric characters, and it must contain at least one
        /// letter.</p>
        /// <p>
        /// <code>DefaultSMSType</code> – The type of SMS message that you will send by default. You
        /// can assign the following values:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>Promotional</code> – (Default) Noncritical messages, such as marketing
        /// messages. Amazon SNS optimizes the message delivery to incur the lowest cost.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>Transactional</code> – Critical messages that support customer
        /// transactions, such as one-time passcodes for multi-factor authentication. Amazon
        /// SNS optimizes the message delivery to achieve the highest reliability.</p>
        /// </li>
        /// </ul>
        /// <p>
        /// <code>UsageReportS3Bucket</code> – The name of the Amazon S3 bucket to receive daily SMS
        /// usage reports from Amazon SNS. Each day, Amazon SNS will deliver a usage report as a CSV file to
        /// the bucket. The report includes the following information for each SMS message that was
        /// successfully delivered by your account:</p>
        /// <ul>
        /// <li>
        /// <p>Time that the message was published (in UTC)</p>
        /// </li>
        /// <li>
        /// <p>Message ID</p>
        /// </li>
        /// <li>
        /// <p>Destination phone number</p>
        /// </li>
        /// <li>
        /// <p>Message type</p>
        /// </li>
        /// <li>
        /// <p>Delivery status</p>
        /// </li>
        /// <li>
        /// <p>Message price (in USD)</p>
        /// </li>
        /// <li>
        /// <p>Part number (a message is split into multiple parts if it is too long for a
        /// single message)</p>
        /// </li>
        /// <li>
        /// <p>Total number of parts</p>
        /// </li>
        /// </ul>
        /// <p>To receive the report, the bucket must have a policy that allows the Amazon SNS service
        /// principal to perform the <code>s3:PutObject</code> and <code>s3:GetBucketLocation</code>
        /// actions.</p>
        /// <p>For an example bucket policy and usage report, see <a href="https://docs.aws.amazon.com/sns/latest/dg/sms_stats.html">Monitoring SMS Activity</a> in the
        /// <i>Amazon SNS Developer Guide</i>.</p>
        pub fn set_attributes(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, std::string::String>,
            >,
        ) -> Self {
            self.inner = self.inner.set_attributes(input);
            self
        }
    }
    /// Fluent builder constructing a request to `SetSubscriptionAttributes`.
    ///
    /// <p>Allows a subscription owner to set an attribute of the subscription to a new
    /// value.</p>
    #[derive(std::fmt::Debug)]
    pub struct SetSubscriptionAttributes<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::set_subscription_attributes_input::Builder,
    }
    impl<C, M, R> SetSubscriptionAttributes<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `SetSubscriptionAttributes`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::SetSubscriptionAttributesOutput,
            aws_smithy_http::result::SdkError<crate::error::SetSubscriptionAttributesError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::SetSubscriptionAttributesInputOperationOutputAlias,
                crate::output::SetSubscriptionAttributesOutput,
                crate::error::SetSubscriptionAttributesError,
                crate::input::SetSubscriptionAttributesInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The ARN of the subscription to modify.</p>
        pub fn subscription_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.subscription_arn(inp);
            self
        }
        /// <p>The ARN of the subscription to modify.</p>
        pub fn set_subscription_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_subscription_arn(input);
            self
        }
        /// <p>A map of attributes with their corresponding values.</p>
        /// <p>The following lists the names, descriptions, and values of the special request
        /// parameters that this action uses:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>DeliveryPolicy</code> – The policy that defines how Amazon SNS retries
        /// failed deliveries to HTTP/S endpoints.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>FilterPolicy</code> – The simple JSON object that lets your
        /// subscriber receive only a subset of messages, rather than receiving every
        /// message published to the topic.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>RawMessageDelivery</code> – When set to <code>true</code>,
        /// enables raw message delivery to Amazon SQS or HTTP/S endpoints. This eliminates the
        /// need for the endpoints to process JSON formatting, which is otherwise created
        /// for Amazon SNS metadata.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>RedrivePolicy</code> – When specified, sends undeliverable messages to the specified Amazon SQS dead-letter queue.
        /// Messages that can't be delivered due to client errors (for example, when the subscribed endpoint is unreachable)
        /// or server errors (for example, when the service that powers the subscribed endpoint becomes unavailable) are held
        /// in the dead-letter queue for further analysis or reprocessing.</p>
        /// </li>
        /// </ul>
        ///
        ///
        /// <p>The following attribute applies only to Amazon Kinesis Data Firehose delivery stream subscriptions:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>SubscriptionRoleArn</code> – The ARN of the IAM role that has the following:</p>
        /// <ul>
        /// <li>
        /// <p>Permission to write to the Kinesis Data Firehose delivery stream</p>
        /// </li>
        /// <li>
        /// <p>Amazon SNS listed as a trusted entity</p>
        /// </li>
        /// </ul>
        /// <p>Specifying a valid ARN for this attribute is required for Kinesis Data Firehose delivery stream subscriptions.
        /// For more information, see <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-firehose-as-subscriber.html">Fanout
        /// to Kinesis Data Firehose delivery streams</a> in the <i>Amazon SNS Developer Guide</i>.</p>
        /// </li>
        /// </ul>
        pub fn attribute_name(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.attribute_name(inp);
            self
        }
        /// <p>A map of attributes with their corresponding values.</p>
        /// <p>The following lists the names, descriptions, and values of the special request
        /// parameters that this action uses:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>DeliveryPolicy</code> – The policy that defines how Amazon SNS retries
        /// failed deliveries to HTTP/S endpoints.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>FilterPolicy</code> – The simple JSON object that lets your
        /// subscriber receive only a subset of messages, rather than receiving every
        /// message published to the topic.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>RawMessageDelivery</code> – When set to <code>true</code>,
        /// enables raw message delivery to Amazon SQS or HTTP/S endpoints. This eliminates the
        /// need for the endpoints to process JSON formatting, which is otherwise created
        /// for Amazon SNS metadata.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>RedrivePolicy</code> – When specified, sends undeliverable messages to the specified Amazon SQS dead-letter queue.
        /// Messages that can't be delivered due to client errors (for example, when the subscribed endpoint is unreachable)
        /// or server errors (for example, when the service that powers the subscribed endpoint becomes unavailable) are held
        /// in the dead-letter queue for further analysis or reprocessing.</p>
        /// </li>
        /// </ul>
        ///
        ///
        /// <p>The following attribute applies only to Amazon Kinesis Data Firehose delivery stream subscriptions:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>SubscriptionRoleArn</code> – The ARN of the IAM role that has the following:</p>
        /// <ul>
        /// <li>
        /// <p>Permission to write to the Kinesis Data Firehose delivery stream</p>
        /// </li>
        /// <li>
        /// <p>Amazon SNS listed as a trusted entity</p>
        /// </li>
        /// </ul>
        /// <p>Specifying a valid ARN for this attribute is required for Kinesis Data Firehose delivery stream subscriptions.
        /// For more information, see <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-firehose-as-subscriber.html">Fanout
        /// to Kinesis Data Firehose delivery streams</a> in the <i>Amazon SNS Developer Guide</i>.</p>
        /// </li>
        /// </ul>
        pub fn set_attribute_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_attribute_name(input);
            self
        }
        /// <p>The new value for the attribute in JSON format.</p>
        pub fn attribute_value(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.attribute_value(inp);
            self
        }
        /// <p>The new value for the attribute in JSON format.</p>
        pub fn set_attribute_value(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_attribute_value(input);
            self
        }
    }
    /// Fluent builder constructing a request to `SetTopicAttributes`.
    ///
    /// <p>Allows a topic owner to set an attribute of the topic to a new value.</p>
    #[derive(std::fmt::Debug)]
    pub struct SetTopicAttributes<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::set_topic_attributes_input::Builder,
    }
    impl<C, M, R> SetTopicAttributes<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `SetTopicAttributes`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::SetTopicAttributesOutput,
            aws_smithy_http::result::SdkError<crate::error::SetTopicAttributesError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::SetTopicAttributesInputOperationOutputAlias,
                crate::output::SetTopicAttributesOutput,
                crate::error::SetTopicAttributesError,
                crate::input::SetTopicAttributesInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The ARN of the topic to modify.</p>
        pub fn topic_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.topic_arn(inp);
            self
        }
        /// <p>The ARN of the topic to modify.</p>
        pub fn set_topic_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_topic_arn(input);
            self
        }
        /// <p>A map of attributes with their corresponding values.</p>
        /// <p>The following lists the names, descriptions, and values of the special request
        /// parameters that the <code>SetTopicAttributes</code> action uses:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>DeliveryPolicy</code> – The policy that defines how Amazon SNS retries
        /// failed deliveries to HTTP/S endpoints.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>DisplayName</code> – The display name to use for a topic with SMS
        /// subscriptions.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>Policy</code> – The policy that defines who can access your
        /// topic. By default, only the topic owner can publish or subscribe to the
        /// topic.</p>
        /// </li>
        /// </ul>
        ///
        /// <p>The following attribute applies only to <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-server-side-encryption.html">server-side-encryption</a>:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>KmsMasterKeyId</code> – The ID of an Amazon Web Services managed customer master
        /// key (CMK) for Amazon SNS or a custom CMK. For more information, see <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-server-side-encryption.html#sse-key-terms">Key
        /// Terms</a>. For more examples, see <a href="https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html#API_DescribeKey_RequestParameters">KeyId</a> in the <i>Key Management Service API
        /// Reference</i>. </p>
        /// </li>
        /// </ul>
        ///
        ///
        /// <p>The following attribute applies only to <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-fifo-topics.html">FIFO topics</a>:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>ContentBasedDeduplication</code> – Enables content-based deduplication for
        /// FIFO topics.</p>
        ///
        /// <ul>
        /// <li>
        /// <p>By default, <code>ContentBasedDeduplication</code> is set to <code>false</code>.
        /// If you create a FIFO topic and this attribute is <code>false</code>, you must
        /// specify a value for the <code>MessageDeduplicationId</code> parameter for the
        /// <a href="https://docs.aws.amazon.com/sns/latest/api/API_Publish.html">Publish</a> action. </p>
        /// </li>
        /// <li>
        /// <p>When you set <code>ContentBasedDeduplication</code> to <code>true</code>,
        /// Amazon SNS uses a SHA-256 hash to generate the <code>MessageDeduplicationId</code> using
        /// the body of the message (but not the attributes of the message).</p>
        /// <p>(Optional) To override the generated value, you can specify a value
        /// for the <code>MessageDeduplicationId</code> parameter for the <code>Publish</code>
        /// action.</p>
        /// </li>
        /// </ul>
        /// </li>
        /// </ul>
        pub fn attribute_name(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.attribute_name(inp);
            self
        }
        /// <p>A map of attributes with their corresponding values.</p>
        /// <p>The following lists the names, descriptions, and values of the special request
        /// parameters that the <code>SetTopicAttributes</code> action uses:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>DeliveryPolicy</code> – The policy that defines how Amazon SNS retries
        /// failed deliveries to HTTP/S endpoints.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>DisplayName</code> – The display name to use for a topic with SMS
        /// subscriptions.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>Policy</code> – The policy that defines who can access your
        /// topic. By default, only the topic owner can publish or subscribe to the
        /// topic.</p>
        /// </li>
        /// </ul>
        ///
        /// <p>The following attribute applies only to <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-server-side-encryption.html">server-side-encryption</a>:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>KmsMasterKeyId</code> – The ID of an Amazon Web Services managed customer master
        /// key (CMK) for Amazon SNS or a custom CMK. For more information, see <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-server-side-encryption.html#sse-key-terms">Key
        /// Terms</a>. For more examples, see <a href="https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html#API_DescribeKey_RequestParameters">KeyId</a> in the <i>Key Management Service API
        /// Reference</i>. </p>
        /// </li>
        /// </ul>
        ///
        ///
        /// <p>The following attribute applies only to <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-fifo-topics.html">FIFO topics</a>:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>ContentBasedDeduplication</code> – Enables content-based deduplication for
        /// FIFO topics.</p>
        ///
        /// <ul>
        /// <li>
        /// <p>By default, <code>ContentBasedDeduplication</code> is set to <code>false</code>.
        /// If you create a FIFO topic and this attribute is <code>false</code>, you must
        /// specify a value for the <code>MessageDeduplicationId</code> parameter for the
        /// <a href="https://docs.aws.amazon.com/sns/latest/api/API_Publish.html">Publish</a> action. </p>
        /// </li>
        /// <li>
        /// <p>When you set <code>ContentBasedDeduplication</code> to <code>true</code>,
        /// Amazon SNS uses a SHA-256 hash to generate the <code>MessageDeduplicationId</code> using
        /// the body of the message (but not the attributes of the message).</p>
        /// <p>(Optional) To override the generated value, you can specify a value
        /// for the <code>MessageDeduplicationId</code> parameter for the <code>Publish</code>
        /// action.</p>
        /// </li>
        /// </ul>
        /// </li>
        /// </ul>
        pub fn set_attribute_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_attribute_name(input);
            self
        }
        /// <p>The new value for the attribute.</p>
        pub fn attribute_value(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.attribute_value(inp);
            self
        }
        /// <p>The new value for the attribute.</p>
        pub fn set_attribute_value(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_attribute_value(input);
            self
        }
    }
    /// Fluent builder constructing a request to `Subscribe`.
    ///
    /// <p>Subscribes an endpoint to an Amazon SNS topic. If the endpoint type is HTTP/S or email, or
    /// if the endpoint and the topic are not in the same account, the endpoint owner must
    /// run the <code>ConfirmSubscription</code> action to confirm the subscription.</p>
    /// <p>You call the <code>ConfirmSubscription</code> action with the token from the
    /// subscription response. Confirmation tokens are valid for three days.</p>
    /// <p>This action is throttled at 100 transactions per second (TPS).</p>
    #[derive(std::fmt::Debug)]
    pub struct Subscribe<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::subscribe_input::Builder,
    }
    impl<C, M, R> Subscribe<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `Subscribe`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::SubscribeOutput,
            aws_smithy_http::result::SdkError<crate::error::SubscribeError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::SubscribeInputOperationOutputAlias,
                crate::output::SubscribeOutput,
                crate::error::SubscribeError,
                crate::input::SubscribeInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The ARN of the topic you want to subscribe to.</p>
        pub fn topic_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.topic_arn(inp);
            self
        }
        /// <p>The ARN of the topic you want to subscribe to.</p>
        pub fn set_topic_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_topic_arn(input);
            self
        }
        /// <p>The protocol that you want to use. Supported protocols include:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>http</code> – delivery of JSON-encoded message via HTTP
        /// POST</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>https</code> – delivery of JSON-encoded message via HTTPS
        /// POST</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>email</code> – delivery of message via SMTP</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>email-json</code> – delivery of JSON-encoded message via
        /// SMTP</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>sms</code> – delivery of message via SMS</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>sqs</code> – delivery of JSON-encoded message to an Amazon SQS
        /// queue</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>application</code> – delivery of JSON-encoded message to an
        /// EndpointArn for a mobile app and device</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>lambda</code> – delivery of JSON-encoded message to an Lambda
        /// function</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>firehose</code> – delivery of JSON-encoded message to an Amazon
        /// Kinesis Data Firehose delivery stream.</p>
        /// </li>
        /// </ul>
        pub fn protocol(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.protocol(inp);
            self
        }
        /// <p>The protocol that you want to use. Supported protocols include:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>http</code> – delivery of JSON-encoded message via HTTP
        /// POST</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>https</code> – delivery of JSON-encoded message via HTTPS
        /// POST</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>email</code> – delivery of message via SMTP</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>email-json</code> – delivery of JSON-encoded message via
        /// SMTP</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>sms</code> – delivery of message via SMS</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>sqs</code> – delivery of JSON-encoded message to an Amazon SQS
        /// queue</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>application</code> – delivery of JSON-encoded message to an
        /// EndpointArn for a mobile app and device</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>lambda</code> – delivery of JSON-encoded message to an Lambda
        /// function</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>firehose</code> – delivery of JSON-encoded message to an Amazon
        /// Kinesis Data Firehose delivery stream.</p>
        /// </li>
        /// </ul>
        pub fn set_protocol(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_protocol(input);
            self
        }
        /// <p>The endpoint that you want to receive notifications. Endpoints vary by
        /// protocol:</p>
        /// <ul>
        /// <li>
        /// <p>For the <code>http</code> protocol, the (public) endpoint is a URL beginning
        /// with <code>http://</code>.</p>
        /// </li>
        /// <li>
        /// <p>For the <code>https</code> protocol, the (public) endpoint is a URL beginning
        /// with <code>https://</code>.</p>
        /// </li>
        /// <li>
        /// <p>For the <code>email</code> protocol, the endpoint is an email address.</p>
        /// </li>
        /// <li>
        /// <p>For the <code>email-json</code> protocol, the endpoint is an email
        /// address.</p>
        /// </li>
        /// <li>
        /// <p>For the <code>sms</code> protocol, the endpoint is a phone number of an
        /// SMS-enabled device.</p>
        /// </li>
        /// <li>
        /// <p>For the <code>sqs</code> protocol, the endpoint is the ARN of an Amazon SQS
        /// queue.</p>
        /// </li>
        /// <li>
        /// <p>For the <code>application</code> protocol, the endpoint is the EndpointArn of
        /// a mobile app and device.</p>
        /// </li>
        /// <li>
        /// <p>For the <code>lambda</code> protocol, the endpoint is the ARN of an Lambda
        /// function.</p>
        /// </li>
        /// <li>
        /// <p>For the <code>firehose</code> protocol, the endpoint is the ARN of an Amazon
        /// Kinesis Data Firehose delivery stream.</p>
        /// </li>
        /// </ul>
        pub fn endpoint(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.endpoint(inp);
            self
        }
        /// <p>The endpoint that you want to receive notifications. Endpoints vary by
        /// protocol:</p>
        /// <ul>
        /// <li>
        /// <p>For the <code>http</code> protocol, the (public) endpoint is a URL beginning
        /// with <code>http://</code>.</p>
        /// </li>
        /// <li>
        /// <p>For the <code>https</code> protocol, the (public) endpoint is a URL beginning
        /// with <code>https://</code>.</p>
        /// </li>
        /// <li>
        /// <p>For the <code>email</code> protocol, the endpoint is an email address.</p>
        /// </li>
        /// <li>
        /// <p>For the <code>email-json</code> protocol, the endpoint is an email
        /// address.</p>
        /// </li>
        /// <li>
        /// <p>For the <code>sms</code> protocol, the endpoint is a phone number of an
        /// SMS-enabled device.</p>
        /// </li>
        /// <li>
        /// <p>For the <code>sqs</code> protocol, the endpoint is the ARN of an Amazon SQS
        /// queue.</p>
        /// </li>
        /// <li>
        /// <p>For the <code>application</code> protocol, the endpoint is the EndpointArn of
        /// a mobile app and device.</p>
        /// </li>
        /// <li>
        /// <p>For the <code>lambda</code> protocol, the endpoint is the ARN of an Lambda
        /// function.</p>
        /// </li>
        /// <li>
        /// <p>For the <code>firehose</code> protocol, the endpoint is the ARN of an Amazon
        /// Kinesis Data Firehose delivery stream.</p>
        /// </li>
        /// </ul>
        pub fn set_endpoint(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_endpoint(input);
            self
        }
        /// Adds a key-value pair to `Attributes`.
        ///
        /// To override the contents of this collection use [`set_attributes`](Self::set_attributes).
        ///
        /// <p>A map of attributes with their corresponding values.</p>
        /// <p>The following lists the names, descriptions, and values of the special request
        /// parameters that the <code>Subscribe</code> action uses:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>DeliveryPolicy</code> – The policy that defines how Amazon SNS retries
        /// failed deliveries to HTTP/S endpoints.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>FilterPolicy</code> – The simple JSON object that lets your
        /// subscriber receive only a subset of messages, rather than receiving every
        /// message published to the topic.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>RawMessageDelivery</code> – When set to <code>true</code>,
        /// enables raw message delivery to Amazon SQS or HTTP/S endpoints. This eliminates the
        /// need for the endpoints to process JSON formatting, which is otherwise created
        /// for Amazon SNS metadata.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>RedrivePolicy</code> – When specified, sends undeliverable messages to the specified Amazon SQS dead-letter queue.
        /// Messages that can't be delivered due to client errors (for example, when the subscribed endpoint is unreachable)
        /// or server errors (for example, when the service that powers the subscribed endpoint becomes unavailable) are held
        /// in the dead-letter queue for further analysis or reprocessing.</p>
        /// </li>
        /// </ul>
        ///
        ///
        /// <p>The following attribute applies only to Amazon Kinesis Data Firehose delivery stream subscriptions:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>SubscriptionRoleArn</code> – The ARN of the IAM role that has the following:</p>
        /// <ul>
        /// <li>
        /// <p>Permission to write to the Kinesis Data Firehose delivery stream</p>
        /// </li>
        /// <li>
        /// <p>Amazon SNS listed as a trusted entity</p>
        /// </li>
        /// </ul>
        /// <p>Specifying a valid ARN for this attribute is required for Kinesis Data Firehose delivery stream subscriptions.
        /// For more information, see <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-firehose-as-subscriber.html">Fanout
        /// to Kinesis Data Firehose delivery streams</a> in the <i>Amazon SNS Developer Guide</i>.</p>
        /// </li>
        /// </ul>
        pub fn attributes(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<std::string::String>,
        ) -> Self {
            self.inner = self.inner.attributes(k, v);
            self
        }
        /// <p>A map of attributes with their corresponding values.</p>
        /// <p>The following lists the names, descriptions, and values of the special request
        /// parameters that the <code>Subscribe</code> action uses:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>DeliveryPolicy</code> – The policy that defines how Amazon SNS retries
        /// failed deliveries to HTTP/S endpoints.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>FilterPolicy</code> – The simple JSON object that lets your
        /// subscriber receive only a subset of messages, rather than receiving every
        /// message published to the topic.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>RawMessageDelivery</code> – When set to <code>true</code>,
        /// enables raw message delivery to Amazon SQS or HTTP/S endpoints. This eliminates the
        /// need for the endpoints to process JSON formatting, which is otherwise created
        /// for Amazon SNS metadata.</p>
        /// </li>
        /// <li>
        /// <p>
        /// <code>RedrivePolicy</code> – When specified, sends undeliverable messages to the specified Amazon SQS dead-letter queue.
        /// Messages that can't be delivered due to client errors (for example, when the subscribed endpoint is unreachable)
        /// or server errors (for example, when the service that powers the subscribed endpoint becomes unavailable) are held
        /// in the dead-letter queue for further analysis or reprocessing.</p>
        /// </li>
        /// </ul>
        ///
        ///
        /// <p>The following attribute applies only to Amazon Kinesis Data Firehose delivery stream subscriptions:</p>
        /// <ul>
        /// <li>
        /// <p>
        /// <code>SubscriptionRoleArn</code> – The ARN of the IAM role that has the following:</p>
        /// <ul>
        /// <li>
        /// <p>Permission to write to the Kinesis Data Firehose delivery stream</p>
        /// </li>
        /// <li>
        /// <p>Amazon SNS listed as a trusted entity</p>
        /// </li>
        /// </ul>
        /// <p>Specifying a valid ARN for this attribute is required for Kinesis Data Firehose delivery stream subscriptions.
        /// For more information, see <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-firehose-as-subscriber.html">Fanout
        /// to Kinesis Data Firehose delivery streams</a> in the <i>Amazon SNS Developer Guide</i>.</p>
        /// </li>
        /// </ul>
        pub fn set_attributes(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, std::string::String>,
            >,
        ) -> Self {
            self.inner = self.inner.set_attributes(input);
            self
        }
        /// <p>Sets whether the response from the <code>Subscribe</code> request includes the
        /// subscription ARN, even if the subscription is not yet confirmed.</p>
        /// <p>If you set this parameter to <code>true</code>, the response includes the ARN in all
        /// cases, even if the subscription is not yet confirmed. In addition to the ARN for
        /// confirmed subscriptions, the response also includes the <code>pending
        /// subscription</code> ARN value for subscriptions that aren't yet confirmed. A
        /// subscription becomes confirmed when the subscriber calls the
        /// <code>ConfirmSubscription</code> action with a confirmation token.</p>
        /// <p></p>
        /// <p>The default value is <code>false</code>.</p>
        pub fn return_subscription_arn(mut self, inp: bool) -> Self {
            self.inner = self.inner.return_subscription_arn(inp);
            self
        }
        /// <p>Sets whether the response from the <code>Subscribe</code> request includes the
        /// subscription ARN, even if the subscription is not yet confirmed.</p>
        /// <p>If you set this parameter to <code>true</code>, the response includes the ARN in all
        /// cases, even if the subscription is not yet confirmed. In addition to the ARN for
        /// confirmed subscriptions, the response also includes the <code>pending
        /// subscription</code> ARN value for subscriptions that aren't yet confirmed. A
        /// subscription becomes confirmed when the subscriber calls the
        /// <code>ConfirmSubscription</code> action with a confirmation token.</p>
        /// <p></p>
        /// <p>The default value is <code>false</code>.</p>
        pub fn set_return_subscription_arn(mut self, input: std::option::Option<bool>) -> Self {
            self.inner = self.inner.set_return_subscription_arn(input);
            self
        }
    }
    /// Fluent builder constructing a request to `TagResource`.
    ///
    /// <p>Add tags to the specified Amazon SNS topic. For an overview, see <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-tags.html">Amazon SNS Tags</a> in the
    /// <i>Amazon SNS Developer Guide</i>.</p>
    /// <p>When you use topic tags, keep the following guidelines in mind:</p>
    /// <ul>
    /// <li>
    /// <p>Adding more than 50 tags to a topic isn't recommended.</p>
    /// </li>
    /// <li>
    /// <p>Tags don't have any semantic meaning. Amazon SNS interprets tags as character
    /// strings.</p>
    /// </li>
    /// <li>
    /// <p>Tags are case-sensitive.</p>
    /// </li>
    /// <li>
    /// <p>A new tag with a key identical to that of an existing tag overwrites the
    /// existing tag.</p>
    /// </li>
    /// <li>
    /// <p>Tagging actions are limited to 10 TPS per account, per Region. If your
    /// application requires a higher throughput, file a <a href="https://console.aws.amazon.com/support/home#/case/create?issueType=technical">technical support request</a>.</p>
    /// </li>
    /// </ul>
    #[derive(std::fmt::Debug)]
    pub struct TagResource<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::tag_resource_input::Builder,
    }
    impl<C, M, R> TagResource<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `TagResource`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::TagResourceOutput,
            aws_smithy_http::result::SdkError<crate::error::TagResourceError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::TagResourceInputOperationOutputAlias,
                crate::output::TagResourceOutput,
                crate::error::TagResourceError,
                crate::input::TagResourceInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The ARN of the topic to which to add tags.</p>
        pub fn resource_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.resource_arn(inp);
            self
        }
        /// <p>The ARN of the topic to which to add tags.</p>
        pub fn set_resource_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_resource_arn(input);
            self
        }
        /// Appends an item to `Tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// <p>The tags to be added to the specified topic. A tag consists of a required key and an
        /// optional value.</p>
        pub fn tags(mut self, inp: impl Into<crate::model::Tag>) -> Self {
            self.inner = self.inner.tags(inp);
            self
        }
        /// <p>The tags to be added to the specified topic. A tag consists of a required key and an
        /// optional value.</p>
        pub fn set_tags(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
        ) -> Self {
            self.inner = self.inner.set_tags(input);
            self
        }
    }
    /// Fluent builder constructing a request to `Unsubscribe`.
    ///
    /// <p>Deletes a subscription. If the subscription requires authentication for deletion, only
    /// the owner of the subscription or the topic's owner can unsubscribe, and an Amazon Web Services signature
    /// is required. If the <code>Unsubscribe</code> call does not require authentication and
    /// the requester is not the subscription owner, a final cancellation message is delivered
    /// to the endpoint, so that the endpoint owner can easily resubscribe to the topic if the
    /// <code>Unsubscribe</code> request was unintended.</p>
    /// <p>This action is throttled at 100 transactions per second (TPS).</p>
    #[derive(std::fmt::Debug)]
    pub struct Unsubscribe<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::unsubscribe_input::Builder,
    }
    impl<C, M, R> Unsubscribe<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `Unsubscribe`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::UnsubscribeOutput,
            aws_smithy_http::result::SdkError<crate::error::UnsubscribeError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::UnsubscribeInputOperationOutputAlias,
                crate::output::UnsubscribeOutput,
                crate::error::UnsubscribeError,
                crate::input::UnsubscribeInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The ARN of the subscription to be deleted.</p>
        pub fn subscription_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.subscription_arn(inp);
            self
        }
        /// <p>The ARN of the subscription to be deleted.</p>
        pub fn set_subscription_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_subscription_arn(input);
            self
        }
    }
    /// Fluent builder constructing a request to `UntagResource`.
    ///
    /// <p>Remove tags from the specified Amazon SNS topic. For an overview, see <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-tags.html">Amazon SNS Tags</a> in the
    /// <i>Amazon SNS Developer Guide</i>.</p>
    #[derive(std::fmt::Debug)]
    pub struct UntagResource<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::untag_resource_input::Builder,
    }
    impl<C, M, R> UntagResource<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `UntagResource`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::UntagResourceOutput,
            aws_smithy_http::result::SdkError<crate::error::UntagResourceError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::UntagResourceInputOperationOutputAlias,
                crate::output::UntagResourceOutput,
                crate::error::UntagResourceError,
                crate::input::UntagResourceInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The ARN of the topic from which to remove tags.</p>
        pub fn resource_arn(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.resource_arn(inp);
            self
        }
        /// <p>The ARN of the topic from which to remove tags.</p>
        pub fn set_resource_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_resource_arn(input);
            self
        }
        /// Appends an item to `TagKeys`.
        ///
        /// To override the contents of this collection use [`set_tag_keys`](Self::set_tag_keys).
        ///
        /// <p>The list of tag keys to remove from the specified topic.</p>
        pub fn tag_keys(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.tag_keys(inp);
            self
        }
        /// <p>The list of tag keys to remove from the specified topic.</p>
        pub fn set_tag_keys(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.inner = self.inner.set_tag_keys(input);
            self
        }
    }
    /// Fluent builder constructing a request to `VerifySMSSandboxPhoneNumber`.
    ///
    /// <p>Verifies a destination phone number with a one-time password (OTP) for the calling account.</p>
    /// <p>When you start using Amazon SNS to send SMS messages, your account is in the
    /// <i>SMS sandbox</i>. The SMS sandbox provides a safe environment for
    /// you to try Amazon SNS features without risking your reputation as an SMS sender. While your
    /// account is in the SMS sandbox, you can use all of the features of Amazon SNS. However, you can send
    /// SMS messages only to verified destination phone numbers. For more information, including how to
    /// move out of the sandbox to send messages without restrictions,
    /// see <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-sms-sandbox.html">SMS sandbox</a> in
    /// the <i>Amazon SNS Developer Guide</i>.</p>
    #[derive(std::fmt::Debug)]
    pub struct VerifySMSSandboxPhoneNumber<
        C = aws_smithy_client::erase::DynConnector,
        M = aws_hyper::AwsMiddleware,
        R = aws_smithy_client::retry::Standard,
    > {
        handle: std::sync::Arc<super::Handle<C, M, R>>,
        inner: crate::input::verify_sms_sandbox_phone_number_input::Builder,
    }
    impl<C, M, R> VerifySMSSandboxPhoneNumber<C, M, R>
    where
        C: aws_smithy_client::bounds::SmithyConnector,
        M: aws_smithy_client::bounds::SmithyMiddleware<C>,
        R: aws_smithy_client::retry::NewRequestPolicy,
    {
        /// Creates a new `VerifySMSSandboxPhoneNumber`.
        pub(crate) fn new(handle: std::sync::Arc<super::Handle<C, M, R>>) -> Self {
            Self {
                handle,
                inner: Default::default(),
            }
        }

        /// 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::VerifySmsSandboxPhoneNumberOutput,
            aws_smithy_http::result::SdkError<crate::error::VerifySMSSandboxPhoneNumberError>,
        >
        where
            R::Policy: aws_smithy_client::bounds::SmithyRetryPolicy<
                crate::input::VerifySmsSandboxPhoneNumberInputOperationOutputAlias,
                crate::output::VerifySmsSandboxPhoneNumberOutput,
                crate::error::VerifySMSSandboxPhoneNumberError,
                crate::input::VerifySmsSandboxPhoneNumberInputOperationRetryAlias,
            >,
        {
            let input = self.inner.build().map_err(|err| {
                aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
            })?;
            let op = input
                .make_operation(&self.handle.conf)
                .await
                .map_err(|err| {
                    aws_smithy_http::result::SdkError::ConstructionFailure(err.into())
                })?;
            self.handle.client.call(op).await
        }
        /// <p>The destination phone number to verify.</p>
        pub fn phone_number(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.phone_number(inp);
            self
        }
        /// <p>The destination phone number to verify.</p>
        pub fn set_phone_number(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.inner = self.inner.set_phone_number(input);
            self
        }
        /// <p>The OTP sent to the destination number from the
        /// <code>CreateSMSSandBoxPhoneNumber</code> call.</p>
        pub fn one_time_password(mut self, inp: impl Into<std::string::String>) -> Self {
            self.inner = self.inner.one_time_password(inp);
            self
        }
        /// <p>The OTP sent to the destination number from the
        /// <code>CreateSMSSandBoxPhoneNumber</code> call.</p>
        pub fn set_one_time_password(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.inner = self.inner.set_one_time_password(input);
            self
        }
    }
}
impl<C> Client<C, aws_hyper::AwsMiddleware, aws_smithy_client::retry::Standard> {
    /// Creates a client with the given service config and connector override.
    pub fn from_conf_conn(conf: crate::Config, conn: C) -> Self {
        let retry_config = conf.retry_config.as_ref().cloned().unwrap_or_default();
        let client = aws_hyper::Client::new(conn).with_retry_config(retry_config.into());
        Self {
            handle: std::sync::Arc::new(Handle { client, conf }),
        }
    }
}
impl
    Client<
        aws_smithy_client::erase::DynConnector,
        aws_hyper::AwsMiddleware,
        aws_smithy_client::retry::Standard,
    >
{
    /// Creates a new client from a shared config.
    #[cfg(any(feature = "rustls", feature = "native-tls"))]
    pub fn new(config: &aws_types::config::Config) -> Self {
        Self::from_conf(config.into())
    }

    /// Creates a new client from the service [`Config`](crate::Config).
    #[cfg(any(feature = "rustls", feature = "native-tls"))]
    pub fn from_conf(conf: crate::Config) -> Self {
        let retry_config = conf.retry_config.as_ref().cloned().unwrap_or_default();
        let client = aws_hyper::Client::https().with_retry_config(retry_config.into());
        Self {
            handle: std::sync::Arc::new(Handle { client, conf }),
        }
    }
}
