// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
/// <p>Adds a statement to a topic's access control policy, granting access for the specified
/// accounts to the specified actions.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct AddPermission {
    _private: (),
}
impl AddPermission {
    /// Creates a new builder-style object to manufacture [`AddPermissionInput`](crate::input::AddPermissionInput)
    pub fn builder() -> crate::input::add_permission_input::Builder {
        crate::input::add_permission_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for AddPermission {
    type Output =
        std::result::Result<crate::output::AddPermissionOutput, crate::error::AddPermissionError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_add_permission_error(response)
        } else {
            crate::operation_deser::parse_add_permission_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct CheckIfPhoneNumberIsOptedOut {
    _private: (),
}
impl CheckIfPhoneNumberIsOptedOut {
    /// Creates a new builder-style object to manufacture [`CheckIfPhoneNumberIsOptedOutInput`](crate::input::CheckIfPhoneNumberIsOptedOutInput)
    pub fn builder() -> crate::input::check_if_phone_number_is_opted_out_input::Builder {
        crate::input::check_if_phone_number_is_opted_out_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for CheckIfPhoneNumberIsOptedOut {
    type Output = std::result::Result<
        crate::output::CheckIfPhoneNumberIsOptedOutOutput,
        crate::error::CheckIfPhoneNumberIsOptedOutError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_check_if_phone_number_is_opted_out_error(response)
        } else {
            crate::operation_deser::parse_check_if_phone_number_is_opted_out_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ConfirmSubscription {
    _private: (),
}
impl ConfirmSubscription {
    /// Creates a new builder-style object to manufacture [`ConfirmSubscriptionInput`](crate::input::ConfirmSubscriptionInput)
    pub fn builder() -> crate::input::confirm_subscription_input::Builder {
        crate::input::confirm_subscription_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for ConfirmSubscription {
    type Output = std::result::Result<
        crate::output::ConfirmSubscriptionOutput,
        crate::error::ConfirmSubscriptionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_confirm_subscription_error(response)
        } else {
            crate::operation_deser::parse_confirm_subscription_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct CreatePlatformApplication {
    _private: (),
}
impl CreatePlatformApplication {
    /// Creates a new builder-style object to manufacture [`CreatePlatformApplicationInput`](crate::input::CreatePlatformApplicationInput)
    pub fn builder() -> crate::input::create_platform_application_input::Builder {
        crate::input::create_platform_application_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for CreatePlatformApplication {
    type Output = std::result::Result<
        crate::output::CreatePlatformApplicationOutput,
        crate::error::CreatePlatformApplicationError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_platform_application_error(response)
        } else {
            crate::operation_deser::parse_create_platform_application_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct CreatePlatformEndpoint {
    _private: (),
}
impl CreatePlatformEndpoint {
    /// Creates a new builder-style object to manufacture [`CreatePlatformEndpointInput`](crate::input::CreatePlatformEndpointInput)
    pub fn builder() -> crate::input::create_platform_endpoint_input::Builder {
        crate::input::create_platform_endpoint_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for CreatePlatformEndpoint {
    type Output = std::result::Result<
        crate::output::CreatePlatformEndpointOutput,
        crate::error::CreatePlatformEndpointError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_platform_endpoint_error(response)
        } else {
            crate::operation_deser::parse_create_platform_endpoint_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct CreateSMSSandboxPhoneNumber {
    _private: (),
}
impl CreateSMSSandboxPhoneNumber {
    /// Creates a new builder-style object to manufacture [`CreateSmsSandboxPhoneNumberInput`](crate::input::CreateSmsSandboxPhoneNumberInput)
    pub fn builder() -> crate::input::create_sms_sandbox_phone_number_input::Builder {
        crate::input::create_sms_sandbox_phone_number_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for CreateSMSSandboxPhoneNumber {
    type Output = std::result::Result<
        crate::output::CreateSmsSandboxPhoneNumberOutput,
        crate::error::CreateSMSSandboxPhoneNumberError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_sms_sandbox_phone_number_error(response)
        } else {
            crate::operation_deser::parse_create_sms_sandbox_phone_number_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct CreateTopic {
    _private: (),
}
impl CreateTopic {
    /// Creates a new builder-style object to manufacture [`CreateTopicInput`](crate::input::CreateTopicInput)
    pub fn builder() -> crate::input::create_topic_input::Builder {
        crate::input::create_topic_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for CreateTopic {
    type Output =
        std::result::Result<crate::output::CreateTopicOutput, crate::error::CreateTopicError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_topic_error(response)
        } else {
            crate::operation_deser::parse_create_topic_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteEndpoint {
    _private: (),
}
impl DeleteEndpoint {
    /// Creates a new builder-style object to manufacture [`DeleteEndpointInput`](crate::input::DeleteEndpointInput)
    pub fn builder() -> crate::input::delete_endpoint_input::Builder {
        crate::input::delete_endpoint_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for DeleteEndpoint {
    type Output =
        std::result::Result<crate::output::DeleteEndpointOutput, crate::error::DeleteEndpointError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_endpoint_error(response)
        } else {
            crate::operation_deser::parse_delete_endpoint_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeletePlatformApplication {
    _private: (),
}
impl DeletePlatformApplication {
    /// Creates a new builder-style object to manufacture [`DeletePlatformApplicationInput`](crate::input::DeletePlatformApplicationInput)
    pub fn builder() -> crate::input::delete_platform_application_input::Builder {
        crate::input::delete_platform_application_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for DeletePlatformApplication {
    type Output = std::result::Result<
        crate::output::DeletePlatformApplicationOutput,
        crate::error::DeletePlatformApplicationError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_platform_application_error(response)
        } else {
            crate::operation_deser::parse_delete_platform_application_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteSMSSandboxPhoneNumber {
    _private: (),
}
impl DeleteSMSSandboxPhoneNumber {
    /// Creates a new builder-style object to manufacture [`DeleteSmsSandboxPhoneNumberInput`](crate::input::DeleteSmsSandboxPhoneNumberInput)
    pub fn builder() -> crate::input::delete_sms_sandbox_phone_number_input::Builder {
        crate::input::delete_sms_sandbox_phone_number_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for DeleteSMSSandboxPhoneNumber {
    type Output = std::result::Result<
        crate::output::DeleteSmsSandboxPhoneNumberOutput,
        crate::error::DeleteSMSSandboxPhoneNumberError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_sms_sandbox_phone_number_error(response)
        } else {
            crate::operation_deser::parse_delete_sms_sandbox_phone_number_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteTopic {
    _private: (),
}
impl DeleteTopic {
    /// Creates a new builder-style object to manufacture [`DeleteTopicInput`](crate::input::DeleteTopicInput)
    pub fn builder() -> crate::input::delete_topic_input::Builder {
        crate::input::delete_topic_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for DeleteTopic {
    type Output =
        std::result::Result<crate::output::DeleteTopicOutput, crate::error::DeleteTopicError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_topic_error(response)
        } else {
            crate::operation_deser::parse_delete_topic_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetEndpointAttributes {
    _private: (),
}
impl GetEndpointAttributes {
    /// Creates a new builder-style object to manufacture [`GetEndpointAttributesInput`](crate::input::GetEndpointAttributesInput)
    pub fn builder() -> crate::input::get_endpoint_attributes_input::Builder {
        crate::input::get_endpoint_attributes_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for GetEndpointAttributes {
    type Output = std::result::Result<
        crate::output::GetEndpointAttributesOutput,
        crate::error::GetEndpointAttributesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_endpoint_attributes_error(response)
        } else {
            crate::operation_deser::parse_get_endpoint_attributes_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetPlatformApplicationAttributes {
    _private: (),
}
impl GetPlatformApplicationAttributes {
    /// Creates a new builder-style object to manufacture [`GetPlatformApplicationAttributesInput`](crate::input::GetPlatformApplicationAttributesInput)
    pub fn builder() -> crate::input::get_platform_application_attributes_input::Builder {
        crate::input::get_platform_application_attributes_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for GetPlatformApplicationAttributes {
    type Output = std::result::Result<
        crate::output::GetPlatformApplicationAttributesOutput,
        crate::error::GetPlatformApplicationAttributesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_platform_application_attributes_error(response)
        } else {
            crate::operation_deser::parse_get_platform_application_attributes_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetSMSAttributes {
    _private: (),
}
impl GetSMSAttributes {
    /// Creates a new builder-style object to manufacture [`GetSmsAttributesInput`](crate::input::GetSmsAttributesInput)
    pub fn builder() -> crate::input::get_sms_attributes_input::Builder {
        crate::input::get_sms_attributes_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for GetSMSAttributes {
    type Output = std::result::Result<
        crate::output::GetSmsAttributesOutput,
        crate::error::GetSMSAttributesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_sms_attributes_error(response)
        } else {
            crate::operation_deser::parse_get_sms_attributes_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetSMSSandboxAccountStatus {
    _private: (),
}
impl GetSMSSandboxAccountStatus {
    /// Creates a new builder-style object to manufacture [`GetSmsSandboxAccountStatusInput`](crate::input::GetSmsSandboxAccountStatusInput)
    pub fn builder() -> crate::input::get_sms_sandbox_account_status_input::Builder {
        crate::input::get_sms_sandbox_account_status_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for GetSMSSandboxAccountStatus {
    type Output = std::result::Result<
        crate::output::GetSmsSandboxAccountStatusOutput,
        crate::error::GetSMSSandboxAccountStatusError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_sms_sandbox_account_status_error(response)
        } else {
            crate::operation_deser::parse_get_sms_sandbox_account_status_response(response)
        }
    }
}

/// <p>Returns all of the properties of a subscription.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetSubscriptionAttributes {
    _private: (),
}
impl GetSubscriptionAttributes {
    /// Creates a new builder-style object to manufacture [`GetSubscriptionAttributesInput`](crate::input::GetSubscriptionAttributesInput)
    pub fn builder() -> crate::input::get_subscription_attributes_input::Builder {
        crate::input::get_subscription_attributes_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for GetSubscriptionAttributes {
    type Output = std::result::Result<
        crate::output::GetSubscriptionAttributesOutput,
        crate::error::GetSubscriptionAttributesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_subscription_attributes_error(response)
        } else {
            crate::operation_deser::parse_get_subscription_attributes_response(response)
        }
    }
}

/// <p>Returns all of the properties of a topic. Topic properties returned might differ based
/// on the authorization of the user.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetTopicAttributes {
    _private: (),
}
impl GetTopicAttributes {
    /// Creates a new builder-style object to manufacture [`GetTopicAttributesInput`](crate::input::GetTopicAttributesInput)
    pub fn builder() -> crate::input::get_topic_attributes_input::Builder {
        crate::input::get_topic_attributes_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for GetTopicAttributes {
    type Output = std::result::Result<
        crate::output::GetTopicAttributesOutput,
        crate::error::GetTopicAttributesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_topic_attributes_error(response)
        } else {
            crate::operation_deser::parse_get_topic_attributes_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListEndpointsByPlatformApplication {
    _private: (),
}
impl ListEndpointsByPlatformApplication {
    /// Creates a new builder-style object to manufacture [`ListEndpointsByPlatformApplicationInput`](crate::input::ListEndpointsByPlatformApplicationInput)
    pub fn builder() -> crate::input::list_endpoints_by_platform_application_input::Builder {
        crate::input::list_endpoints_by_platform_application_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for ListEndpointsByPlatformApplication {
    type Output = std::result::Result<
        crate::output::ListEndpointsByPlatformApplicationOutput,
        crate::error::ListEndpointsByPlatformApplicationError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_endpoints_by_platform_application_error(response)
        } else {
            crate::operation_deser::parse_list_endpoints_by_platform_application_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListOriginationNumbers {
    _private: (),
}
impl ListOriginationNumbers {
    /// Creates a new builder-style object to manufacture [`ListOriginationNumbersInput`](crate::input::ListOriginationNumbersInput)
    pub fn builder() -> crate::input::list_origination_numbers_input::Builder {
        crate::input::list_origination_numbers_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for ListOriginationNumbers {
    type Output = std::result::Result<
        crate::output::ListOriginationNumbersOutput,
        crate::error::ListOriginationNumbersError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_origination_numbers_error(response)
        } else {
            crate::operation_deser::parse_list_origination_numbers_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListPhoneNumbersOptedOut {
    _private: (),
}
impl ListPhoneNumbersOptedOut {
    /// Creates a new builder-style object to manufacture [`ListPhoneNumbersOptedOutInput`](crate::input::ListPhoneNumbersOptedOutInput)
    pub fn builder() -> crate::input::list_phone_numbers_opted_out_input::Builder {
        crate::input::list_phone_numbers_opted_out_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for ListPhoneNumbersOptedOut {
    type Output = std::result::Result<
        crate::output::ListPhoneNumbersOptedOutOutput,
        crate::error::ListPhoneNumbersOptedOutError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_phone_numbers_opted_out_error(response)
        } else {
            crate::operation_deser::parse_list_phone_numbers_opted_out_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListPlatformApplications {
    _private: (),
}
impl ListPlatformApplications {
    /// Creates a new builder-style object to manufacture [`ListPlatformApplicationsInput`](crate::input::ListPlatformApplicationsInput)
    pub fn builder() -> crate::input::list_platform_applications_input::Builder {
        crate::input::list_platform_applications_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for ListPlatformApplications {
    type Output = std::result::Result<
        crate::output::ListPlatformApplicationsOutput,
        crate::error::ListPlatformApplicationsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_platform_applications_error(response)
        } else {
            crate::operation_deser::parse_list_platform_applications_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListSMSSandboxPhoneNumbers {
    _private: (),
}
impl ListSMSSandboxPhoneNumbers {
    /// Creates a new builder-style object to manufacture [`ListSmsSandboxPhoneNumbersInput`](crate::input::ListSmsSandboxPhoneNumbersInput)
    pub fn builder() -> crate::input::list_sms_sandbox_phone_numbers_input::Builder {
        crate::input::list_sms_sandbox_phone_numbers_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for ListSMSSandboxPhoneNumbers {
    type Output = std::result::Result<
        crate::output::ListSmsSandboxPhoneNumbersOutput,
        crate::error::ListSMSSandboxPhoneNumbersError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_sms_sandbox_phone_numbers_error(response)
        } else {
            crate::operation_deser::parse_list_sms_sandbox_phone_numbers_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListSubscriptions {
    _private: (),
}
impl ListSubscriptions {
    /// Creates a new builder-style object to manufacture [`ListSubscriptionsInput`](crate::input::ListSubscriptionsInput)
    pub fn builder() -> crate::input::list_subscriptions_input::Builder {
        crate::input::list_subscriptions_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for ListSubscriptions {
    type Output = std::result::Result<
        crate::output::ListSubscriptionsOutput,
        crate::error::ListSubscriptionsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_subscriptions_error(response)
        } else {
            crate::operation_deser::parse_list_subscriptions_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListSubscriptionsByTopic {
    _private: (),
}
impl ListSubscriptionsByTopic {
    /// Creates a new builder-style object to manufacture [`ListSubscriptionsByTopicInput`](crate::input::ListSubscriptionsByTopicInput)
    pub fn builder() -> crate::input::list_subscriptions_by_topic_input::Builder {
        crate::input::list_subscriptions_by_topic_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for ListSubscriptionsByTopic {
    type Output = std::result::Result<
        crate::output::ListSubscriptionsByTopicOutput,
        crate::error::ListSubscriptionsByTopicError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_subscriptions_by_topic_error(response)
        } else {
            crate::operation_deser::parse_list_subscriptions_by_topic_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListTagsForResource {
    _private: (),
}
impl ListTagsForResource {
    /// Creates a new builder-style object to manufacture [`ListTagsForResourceInput`](crate::input::ListTagsForResourceInput)
    pub fn builder() -> crate::input::list_tags_for_resource_input::Builder {
        crate::input::list_tags_for_resource_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for ListTagsForResource {
    type Output = std::result::Result<
        crate::output::ListTagsForResourceOutput,
        crate::error::ListTagsForResourceError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_tags_for_resource_error(response)
        } else {
            crate::operation_deser::parse_list_tags_for_resource_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListTopics {
    _private: (),
}
impl ListTopics {
    /// Creates a new builder-style object to manufacture [`ListTopicsInput`](crate::input::ListTopicsInput)
    pub fn builder() -> crate::input::list_topics_input::Builder {
        crate::input::list_topics_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for ListTopics {
    type Output =
        std::result::Result<crate::output::ListTopicsOutput, crate::error::ListTopicsError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_topics_error(response)
        } else {
            crate::operation_deser::parse_list_topics_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct OptInPhoneNumber {
    _private: (),
}
impl OptInPhoneNumber {
    /// Creates a new builder-style object to manufacture [`OptInPhoneNumberInput`](crate::input::OptInPhoneNumberInput)
    pub fn builder() -> crate::input::opt_in_phone_number_input::Builder {
        crate::input::opt_in_phone_number_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for OptInPhoneNumber {
    type Output = std::result::Result<
        crate::output::OptInPhoneNumberOutput,
        crate::error::OptInPhoneNumberError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_opt_in_phone_number_error(response)
        } else {
            crate::operation_deser::parse_opt_in_phone_number_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct Publish {
    _private: (),
}
impl Publish {
    /// Creates a new builder-style object to manufacture [`PublishInput`](crate::input::PublishInput)
    pub fn builder() -> crate::input::publish_input::Builder {
        crate::input::publish_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for Publish {
    type Output = std::result::Result<crate::output::PublishOutput, crate::error::PublishError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_publish_error(response)
        } else {
            crate::operation_deser::parse_publish_response(response)
        }
    }
}

/// <p>Removes a statement from a topic's access control policy.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct RemovePermission {
    _private: (),
}
impl RemovePermission {
    /// Creates a new builder-style object to manufacture [`RemovePermissionInput`](crate::input::RemovePermissionInput)
    pub fn builder() -> crate::input::remove_permission_input::Builder {
        crate::input::remove_permission_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for RemovePermission {
    type Output = std::result::Result<
        crate::output::RemovePermissionOutput,
        crate::error::RemovePermissionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_remove_permission_error(response)
        } else {
            crate::operation_deser::parse_remove_permission_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct SetEndpointAttributes {
    _private: (),
}
impl SetEndpointAttributes {
    /// Creates a new builder-style object to manufacture [`SetEndpointAttributesInput`](crate::input::SetEndpointAttributesInput)
    pub fn builder() -> crate::input::set_endpoint_attributes_input::Builder {
        crate::input::set_endpoint_attributes_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for SetEndpointAttributes {
    type Output = std::result::Result<
        crate::output::SetEndpointAttributesOutput,
        crate::error::SetEndpointAttributesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_set_endpoint_attributes_error(response)
        } else {
            crate::operation_deser::parse_set_endpoint_attributes_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct SetPlatformApplicationAttributes {
    _private: (),
}
impl SetPlatformApplicationAttributes {
    /// Creates a new builder-style object to manufacture [`SetPlatformApplicationAttributesInput`](crate::input::SetPlatformApplicationAttributesInput)
    pub fn builder() -> crate::input::set_platform_application_attributes_input::Builder {
        crate::input::set_platform_application_attributes_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for SetPlatformApplicationAttributes {
    type Output = std::result::Result<
        crate::output::SetPlatformApplicationAttributesOutput,
        crate::error::SetPlatformApplicationAttributesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_set_platform_application_attributes_error(response)
        } else {
            crate::operation_deser::parse_set_platform_application_attributes_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct SetSMSAttributes {
    _private: (),
}
impl SetSMSAttributes {
    /// Creates a new builder-style object to manufacture [`SetSmsAttributesInput`](crate::input::SetSmsAttributesInput)
    pub fn builder() -> crate::input::set_sms_attributes_input::Builder {
        crate::input::set_sms_attributes_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for SetSMSAttributes {
    type Output = std::result::Result<
        crate::output::SetSmsAttributesOutput,
        crate::error::SetSMSAttributesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_set_sms_attributes_error(response)
        } else {
            crate::operation_deser::parse_set_sms_attributes_response(response)
        }
    }
}

/// <p>Allows a subscription owner to set an attribute of the subscription to a new
/// value.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct SetSubscriptionAttributes {
    _private: (),
}
impl SetSubscriptionAttributes {
    /// Creates a new builder-style object to manufacture [`SetSubscriptionAttributesInput`](crate::input::SetSubscriptionAttributesInput)
    pub fn builder() -> crate::input::set_subscription_attributes_input::Builder {
        crate::input::set_subscription_attributes_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for SetSubscriptionAttributes {
    type Output = std::result::Result<
        crate::output::SetSubscriptionAttributesOutput,
        crate::error::SetSubscriptionAttributesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_set_subscription_attributes_error(response)
        } else {
            crate::operation_deser::parse_set_subscription_attributes_response(response)
        }
    }
}

/// <p>Allows a topic owner to set an attribute of the topic to a new value.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct SetTopicAttributes {
    _private: (),
}
impl SetTopicAttributes {
    /// Creates a new builder-style object to manufacture [`SetTopicAttributesInput`](crate::input::SetTopicAttributesInput)
    pub fn builder() -> crate::input::set_topic_attributes_input::Builder {
        crate::input::set_topic_attributes_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for SetTopicAttributes {
    type Output = std::result::Result<
        crate::output::SetTopicAttributesOutput,
        crate::error::SetTopicAttributesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_set_topic_attributes_error(response)
        } else {
            crate::operation_deser::parse_set_topic_attributes_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct Subscribe {
    _private: (),
}
impl Subscribe {
    /// Creates a new builder-style object to manufacture [`SubscribeInput`](crate::input::SubscribeInput)
    pub fn builder() -> crate::input::subscribe_input::Builder {
        crate::input::subscribe_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for Subscribe {
    type Output = std::result::Result<crate::output::SubscribeOutput, crate::error::SubscribeError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_subscribe_error(response)
        } else {
            crate::operation_deser::parse_subscribe_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct TagResource {
    _private: (),
}
impl TagResource {
    /// Creates a new builder-style object to manufacture [`TagResourceInput`](crate::input::TagResourceInput)
    pub fn builder() -> crate::input::tag_resource_input::Builder {
        crate::input::tag_resource_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for TagResource {
    type Output =
        std::result::Result<crate::output::TagResourceOutput, crate::error::TagResourceError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_tag_resource_error(response)
        } else {
            crate::operation_deser::parse_tag_resource_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct Unsubscribe {
    _private: (),
}
impl Unsubscribe {
    /// Creates a new builder-style object to manufacture [`UnsubscribeInput`](crate::input::UnsubscribeInput)
    pub fn builder() -> crate::input::unsubscribe_input::Builder {
        crate::input::unsubscribe_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for Unsubscribe {
    type Output =
        std::result::Result<crate::output::UnsubscribeOutput, crate::error::UnsubscribeError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_unsubscribe_error(response)
        } else {
            crate::operation_deser::parse_unsubscribe_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UntagResource {
    _private: (),
}
impl UntagResource {
    /// Creates a new builder-style object to manufacture [`UntagResourceInput`](crate::input::UntagResourceInput)
    pub fn builder() -> crate::input::untag_resource_input::Builder {
        crate::input::untag_resource_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for UntagResource {
    type Output =
        std::result::Result<crate::output::UntagResourceOutput, crate::error::UntagResourceError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_untag_resource_error(response)
        } else {
            crate::operation_deser::parse_untag_resource_response(response)
        }
    }
}

/// <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::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct VerifySMSSandboxPhoneNumber {
    _private: (),
}
impl VerifySMSSandboxPhoneNumber {
    /// Creates a new builder-style object to manufacture [`VerifySmsSandboxPhoneNumberInput`](crate::input::VerifySmsSandboxPhoneNumberInput)
    pub fn builder() -> crate::input::verify_sms_sandbox_phone_number_input::Builder {
        crate::input::verify_sms_sandbox_phone_number_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for VerifySMSSandboxPhoneNumber {
    type Output = std::result::Result<
        crate::output::VerifySmsSandboxPhoneNumberOutput,
        crate::error::VerifySMSSandboxPhoneNumberError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_verify_sms_sandbox_phone_number_error(response)
        } else {
            crate::operation_deser::parse_verify_sms_sandbox_phone_number_response(response)
        }
    }
}
