SNSClient.h

 
#pragma once
#include <aws/sns/SNS_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/sns/SNSServiceClientModel.h>
 
namespace Aws
{
namespace SNS
{
  class AWS_SNS_API SNSClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods<SNSClient>
  {
    public:
      typedef Aws::Client::AWSXMLClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef SNSClientConfiguration ClientConfigurationType;
      typedef SNSEndpointProvider EndpointProviderType;
 
        SNSClient(const Aws::SNS::SNSClientConfiguration& clientConfiguration = Aws::SNS::SNSClientConfiguration(),
                  std::shared_ptr<SNSEndpointProviderBase> endpointProvider = nullptr);
 
        SNSClient(const Aws::Auth::AWSCredentials& credentials,
                  std::shared_ptr<SNSEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::SNS::SNSClientConfiguration& clientConfiguration = Aws::SNS::SNSClientConfiguration());
 
        SNSClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<SNSEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::SNS::SNSClientConfiguration& clientConfiguration = Aws::SNS::SNSClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        SNSClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SNSClient(const Aws::Auth::AWSCredentials& credentials,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SNSClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~SNSClient();
 
 
        Aws::String ConvertRequestToPresignedUrl(const Aws::AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const;
 
 
        virtual Model::AddPermissionOutcome AddPermission(const Model::AddPermissionRequest& request) const;
 
        template<typename AddPermissionRequestT = Model::AddPermissionRequest>
        Model::AddPermissionOutcomeCallable AddPermissionCallable(const AddPermissionRequestT& request) const
        {
            return SubmitCallable(&SNSClient::AddPermission, request);
        }
 
        template<typename AddPermissionRequestT = Model::AddPermissionRequest>
        void AddPermissionAsync(const AddPermissionRequestT& request, const AddPermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::AddPermission, request, handler, context);
        }
 
        virtual Model::CheckIfPhoneNumberIsOptedOutOutcome CheckIfPhoneNumberIsOptedOut(const Model::CheckIfPhoneNumberIsOptedOutRequest& request) const;
 
        template<typename CheckIfPhoneNumberIsOptedOutRequestT = Model::CheckIfPhoneNumberIsOptedOutRequest>
        Model::CheckIfPhoneNumberIsOptedOutOutcomeCallable CheckIfPhoneNumberIsOptedOutCallable(const CheckIfPhoneNumberIsOptedOutRequestT& request) const
        {
            return SubmitCallable(&SNSClient::CheckIfPhoneNumberIsOptedOut, request);
        }
 
        template<typename CheckIfPhoneNumberIsOptedOutRequestT = Model::CheckIfPhoneNumberIsOptedOutRequest>
        void CheckIfPhoneNumberIsOptedOutAsync(const CheckIfPhoneNumberIsOptedOutRequestT& request, const CheckIfPhoneNumberIsOptedOutResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::CheckIfPhoneNumberIsOptedOut, request, handler, context);
        }
 
        virtual Model::ConfirmSubscriptionOutcome ConfirmSubscription(const Model::ConfirmSubscriptionRequest& request) const;
 
        template<typename ConfirmSubscriptionRequestT = Model::ConfirmSubscriptionRequest>
        Model::ConfirmSubscriptionOutcomeCallable ConfirmSubscriptionCallable(const ConfirmSubscriptionRequestT& request) const
        {
            return SubmitCallable(&SNSClient::ConfirmSubscription, request);
        }
 
        template<typename ConfirmSubscriptionRequestT = Model::ConfirmSubscriptionRequest>
        void ConfirmSubscriptionAsync(const ConfirmSubscriptionRequestT& request, const ConfirmSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::ConfirmSubscription, request, handler, context);
        }
 
        virtual Model::CreatePlatformApplicationOutcome CreatePlatformApplication(const Model::CreatePlatformApplicationRequest& request) const;
 
        template<typename CreatePlatformApplicationRequestT = Model::CreatePlatformApplicationRequest>
        Model::CreatePlatformApplicationOutcomeCallable CreatePlatformApplicationCallable(const CreatePlatformApplicationRequestT& request) const
        {
            return SubmitCallable(&SNSClient::CreatePlatformApplication, request);
        }
 
        template<typename CreatePlatformApplicationRequestT = Model::CreatePlatformApplicationRequest>
        void CreatePlatformApplicationAsync(const CreatePlatformApplicationRequestT& request, const CreatePlatformApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::CreatePlatformApplication, request, handler, context);
        }
 
        virtual Model::CreatePlatformEndpointOutcome CreatePlatformEndpoint(const Model::CreatePlatformEndpointRequest& request) const;
 
        template<typename CreatePlatformEndpointRequestT = Model::CreatePlatformEndpointRequest>
        Model::CreatePlatformEndpointOutcomeCallable CreatePlatformEndpointCallable(const CreatePlatformEndpointRequestT& request) const
        {
            return SubmitCallable(&SNSClient::CreatePlatformEndpoint, request);
        }
 
        template<typename CreatePlatformEndpointRequestT = Model::CreatePlatformEndpointRequest>
        void CreatePlatformEndpointAsync(const CreatePlatformEndpointRequestT& request, const CreatePlatformEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::CreatePlatformEndpoint, request, handler, context);
        }
 
        virtual Model::CreateSMSSandboxPhoneNumberOutcome CreateSMSSandboxPhoneNumber(const Model::CreateSMSSandboxPhoneNumberRequest& request) const;
 
        template<typename CreateSMSSandboxPhoneNumberRequestT = Model::CreateSMSSandboxPhoneNumberRequest>
        Model::CreateSMSSandboxPhoneNumberOutcomeCallable CreateSMSSandboxPhoneNumberCallable(const CreateSMSSandboxPhoneNumberRequestT& request) const
        {
            return SubmitCallable(&SNSClient::CreateSMSSandboxPhoneNumber, request);
        }
 
        template<typename CreateSMSSandboxPhoneNumberRequestT = Model::CreateSMSSandboxPhoneNumberRequest>
        void CreateSMSSandboxPhoneNumberAsync(const CreateSMSSandboxPhoneNumberRequestT& request, const CreateSMSSandboxPhoneNumberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::CreateSMSSandboxPhoneNumber, request, handler, context);
        }
 
        virtual Model::CreateTopicOutcome CreateTopic(const Model::CreateTopicRequest& request) const;
 
        template<typename CreateTopicRequestT = Model::CreateTopicRequest>
        Model::CreateTopicOutcomeCallable CreateTopicCallable(const CreateTopicRequestT& request) const
        {
            return SubmitCallable(&SNSClient::CreateTopic, request);
        }
 
        template<typename CreateTopicRequestT = Model::CreateTopicRequest>
        void CreateTopicAsync(const CreateTopicRequestT& request, const CreateTopicResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::CreateTopic, request, handler, context);
        }
 
        virtual Model::DeleteEndpointOutcome DeleteEndpoint(const Model::DeleteEndpointRequest& request) const;
 
        template<typename DeleteEndpointRequestT = Model::DeleteEndpointRequest>
        Model::DeleteEndpointOutcomeCallable DeleteEndpointCallable(const DeleteEndpointRequestT& request) const
        {
            return SubmitCallable(&SNSClient::DeleteEndpoint, request);
        }
 
        template<typename DeleteEndpointRequestT = Model::DeleteEndpointRequest>
        void DeleteEndpointAsync(const DeleteEndpointRequestT& request, const DeleteEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::DeleteEndpoint, request, handler, context);
        }
 
        virtual Model::DeletePlatformApplicationOutcome DeletePlatformApplication(const Model::DeletePlatformApplicationRequest& request) const;
 
        template<typename DeletePlatformApplicationRequestT = Model::DeletePlatformApplicationRequest>
        Model::DeletePlatformApplicationOutcomeCallable DeletePlatformApplicationCallable(const DeletePlatformApplicationRequestT& request) const
        {
            return SubmitCallable(&SNSClient::DeletePlatformApplication, request);
        }
 
        template<typename DeletePlatformApplicationRequestT = Model::DeletePlatformApplicationRequest>
        void DeletePlatformApplicationAsync(const DeletePlatformApplicationRequestT& request, const DeletePlatformApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::DeletePlatformApplication, request, handler, context);
        }
 
        virtual Model::DeleteSMSSandboxPhoneNumberOutcome DeleteSMSSandboxPhoneNumber(const Model::DeleteSMSSandboxPhoneNumberRequest& request) const;
 
        template<typename DeleteSMSSandboxPhoneNumberRequestT = Model::DeleteSMSSandboxPhoneNumberRequest>
        Model::DeleteSMSSandboxPhoneNumberOutcomeCallable DeleteSMSSandboxPhoneNumberCallable(const DeleteSMSSandboxPhoneNumberRequestT& request) const
        {
            return SubmitCallable(&SNSClient::DeleteSMSSandboxPhoneNumber, request);
        }
 
        template<typename DeleteSMSSandboxPhoneNumberRequestT = Model::DeleteSMSSandboxPhoneNumberRequest>
        void DeleteSMSSandboxPhoneNumberAsync(const DeleteSMSSandboxPhoneNumberRequestT& request, const DeleteSMSSandboxPhoneNumberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::DeleteSMSSandboxPhoneNumber, request, handler, context);
        }
 
        virtual Model::DeleteTopicOutcome DeleteTopic(const Model::DeleteTopicRequest& request) const;
 
        template<typename DeleteTopicRequestT = Model::DeleteTopicRequest>
        Model::DeleteTopicOutcomeCallable DeleteTopicCallable(const DeleteTopicRequestT& request) const
        {
            return SubmitCallable(&SNSClient::DeleteTopic, request);
        }
 
        template<typename DeleteTopicRequestT = Model::DeleteTopicRequest>
        void DeleteTopicAsync(const DeleteTopicRequestT& request, const DeleteTopicResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::DeleteTopic, request, handler, context);
        }
 
        virtual Model::GetDataProtectionPolicyOutcome GetDataProtectionPolicy(const Model::GetDataProtectionPolicyRequest& request) const;
 
        template<typename GetDataProtectionPolicyRequestT = Model::GetDataProtectionPolicyRequest>
        Model::GetDataProtectionPolicyOutcomeCallable GetDataProtectionPolicyCallable(const GetDataProtectionPolicyRequestT& request) const
        {
            return SubmitCallable(&SNSClient::GetDataProtectionPolicy, request);
        }
 
        template<typename GetDataProtectionPolicyRequestT = Model::GetDataProtectionPolicyRequest>
        void GetDataProtectionPolicyAsync(const GetDataProtectionPolicyRequestT& request, const GetDataProtectionPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::GetDataProtectionPolicy, request, handler, context);
        }
 
        virtual Model::GetEndpointAttributesOutcome GetEndpointAttributes(const Model::GetEndpointAttributesRequest& request) const;
 
        template<typename GetEndpointAttributesRequestT = Model::GetEndpointAttributesRequest>
        Model::GetEndpointAttributesOutcomeCallable GetEndpointAttributesCallable(const GetEndpointAttributesRequestT& request) const
        {
            return SubmitCallable(&SNSClient::GetEndpointAttributes, request);
        }
 
        template<typename GetEndpointAttributesRequestT = Model::GetEndpointAttributesRequest>
        void GetEndpointAttributesAsync(const GetEndpointAttributesRequestT& request, const GetEndpointAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::GetEndpointAttributes, request, handler, context);
        }
 
        virtual Model::GetPlatformApplicationAttributesOutcome GetPlatformApplicationAttributes(const Model::GetPlatformApplicationAttributesRequest& request) const;
 
        template<typename GetPlatformApplicationAttributesRequestT = Model::GetPlatformApplicationAttributesRequest>
        Model::GetPlatformApplicationAttributesOutcomeCallable GetPlatformApplicationAttributesCallable(const GetPlatformApplicationAttributesRequestT& request) const
        {
            return SubmitCallable(&SNSClient::GetPlatformApplicationAttributes, request);
        }
 
        template<typename GetPlatformApplicationAttributesRequestT = Model::GetPlatformApplicationAttributesRequest>
        void GetPlatformApplicationAttributesAsync(const GetPlatformApplicationAttributesRequestT& request, const GetPlatformApplicationAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::GetPlatformApplicationAttributes, request, handler, context);
        }
 
        virtual Model::GetSMSAttributesOutcome GetSMSAttributes(const Model::GetSMSAttributesRequest& request = {}) const;
 
        template<typename GetSMSAttributesRequestT = Model::GetSMSAttributesRequest>
        Model::GetSMSAttributesOutcomeCallable GetSMSAttributesCallable(const GetSMSAttributesRequestT& request = {}) const
        {
            return SubmitCallable(&SNSClient::GetSMSAttributes, request);
        }
 
        template<typename GetSMSAttributesRequestT = Model::GetSMSAttributesRequest>
        void GetSMSAttributesAsync(const GetSMSAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetSMSAttributesRequestT& request = {}) const
        {
            return SubmitAsync(&SNSClient::GetSMSAttributes, request, handler, context);
        }
 
        virtual Model::GetSMSSandboxAccountStatusOutcome GetSMSSandboxAccountStatus(const Model::GetSMSSandboxAccountStatusRequest& request = {}) const;
 
        template<typename GetSMSSandboxAccountStatusRequestT = Model::GetSMSSandboxAccountStatusRequest>
        Model::GetSMSSandboxAccountStatusOutcomeCallable GetSMSSandboxAccountStatusCallable(const GetSMSSandboxAccountStatusRequestT& request = {}) const
        {
            return SubmitCallable(&SNSClient::GetSMSSandboxAccountStatus, request);
        }
 
        template<typename GetSMSSandboxAccountStatusRequestT = Model::GetSMSSandboxAccountStatusRequest>
        void GetSMSSandboxAccountStatusAsync(const GetSMSSandboxAccountStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetSMSSandboxAccountStatusRequestT& request = {}) const
        {
            return SubmitAsync(&SNSClient::GetSMSSandboxAccountStatus, request, handler, context);
        }
 
        virtual Model::GetSubscriptionAttributesOutcome GetSubscriptionAttributes(const Model::GetSubscriptionAttributesRequest& request) const;
 
        template<typename GetSubscriptionAttributesRequestT = Model::GetSubscriptionAttributesRequest>
        Model::GetSubscriptionAttributesOutcomeCallable GetSubscriptionAttributesCallable(const GetSubscriptionAttributesRequestT& request) const
        {
            return SubmitCallable(&SNSClient::GetSubscriptionAttributes, request);
        }
 
        template<typename GetSubscriptionAttributesRequestT = Model::GetSubscriptionAttributesRequest>
        void GetSubscriptionAttributesAsync(const GetSubscriptionAttributesRequestT& request, const GetSubscriptionAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::GetSubscriptionAttributes, request, handler, context);
        }
 
        virtual Model::GetTopicAttributesOutcome GetTopicAttributes(const Model::GetTopicAttributesRequest& request) const;
 
        template<typename GetTopicAttributesRequestT = Model::GetTopicAttributesRequest>
        Model::GetTopicAttributesOutcomeCallable GetTopicAttributesCallable(const GetTopicAttributesRequestT& request) const
        {
            return SubmitCallable(&SNSClient::GetTopicAttributes, request);
        }
 
        template<typename GetTopicAttributesRequestT = Model::GetTopicAttributesRequest>
        void GetTopicAttributesAsync(const GetTopicAttributesRequestT& request, const GetTopicAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::GetTopicAttributes, request, handler, context);
        }
 
        virtual Model::ListEndpointsByPlatformApplicationOutcome ListEndpointsByPlatformApplication(const Model::ListEndpointsByPlatformApplicationRequest& request) const;
 
        template<typename ListEndpointsByPlatformApplicationRequestT = Model::ListEndpointsByPlatformApplicationRequest>
        Model::ListEndpointsByPlatformApplicationOutcomeCallable ListEndpointsByPlatformApplicationCallable(const ListEndpointsByPlatformApplicationRequestT& request) const
        {
            return SubmitCallable(&SNSClient::ListEndpointsByPlatformApplication, request);
        }
 
        template<typename ListEndpointsByPlatformApplicationRequestT = Model::ListEndpointsByPlatformApplicationRequest>
        void ListEndpointsByPlatformApplicationAsync(const ListEndpointsByPlatformApplicationRequestT& request, const ListEndpointsByPlatformApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::ListEndpointsByPlatformApplication, request, handler, context);
        }
 
        virtual Model::ListOriginationNumbersOutcome ListOriginationNumbers(const Model::ListOriginationNumbersRequest& request = {}) const;
 
        template<typename ListOriginationNumbersRequestT = Model::ListOriginationNumbersRequest>
        Model::ListOriginationNumbersOutcomeCallable ListOriginationNumbersCallable(const ListOriginationNumbersRequestT& request = {}) const
        {
            return SubmitCallable(&SNSClient::ListOriginationNumbers, request);
        }
 
        template<typename ListOriginationNumbersRequestT = Model::ListOriginationNumbersRequest>
        void ListOriginationNumbersAsync(const ListOriginationNumbersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListOriginationNumbersRequestT& request = {}) const
        {
            return SubmitAsync(&SNSClient::ListOriginationNumbers, request, handler, context);
        }
 
        virtual Model::ListPhoneNumbersOptedOutOutcome ListPhoneNumbersOptedOut(const Model::ListPhoneNumbersOptedOutRequest& request = {}) const;
 
        template<typename ListPhoneNumbersOptedOutRequestT = Model::ListPhoneNumbersOptedOutRequest>
        Model::ListPhoneNumbersOptedOutOutcomeCallable ListPhoneNumbersOptedOutCallable(const ListPhoneNumbersOptedOutRequestT& request = {}) const
        {
            return SubmitCallable(&SNSClient::ListPhoneNumbersOptedOut, request);
        }
 
        template<typename ListPhoneNumbersOptedOutRequestT = Model::ListPhoneNumbersOptedOutRequest>
        void ListPhoneNumbersOptedOutAsync(const ListPhoneNumbersOptedOutResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPhoneNumbersOptedOutRequestT& request = {}) const
        {
            return SubmitAsync(&SNSClient::ListPhoneNumbersOptedOut, request, handler, context);
        }
 
        virtual Model::ListPlatformApplicationsOutcome ListPlatformApplications(const Model::ListPlatformApplicationsRequest& request = {}) const;
 
        template<typename ListPlatformApplicationsRequestT = Model::ListPlatformApplicationsRequest>
        Model::ListPlatformApplicationsOutcomeCallable ListPlatformApplicationsCallable(const ListPlatformApplicationsRequestT& request = {}) const
        {
            return SubmitCallable(&SNSClient::ListPlatformApplications, request);
        }
 
        template<typename ListPlatformApplicationsRequestT = Model::ListPlatformApplicationsRequest>
        void ListPlatformApplicationsAsync(const ListPlatformApplicationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPlatformApplicationsRequestT& request = {}) const
        {
            return SubmitAsync(&SNSClient::ListPlatformApplications, request, handler, context);
        }
 
        virtual Model::ListSMSSandboxPhoneNumbersOutcome ListSMSSandboxPhoneNumbers(const Model::ListSMSSandboxPhoneNumbersRequest& request = {}) const;
 
        template<typename ListSMSSandboxPhoneNumbersRequestT = Model::ListSMSSandboxPhoneNumbersRequest>
        Model::ListSMSSandboxPhoneNumbersOutcomeCallable ListSMSSandboxPhoneNumbersCallable(const ListSMSSandboxPhoneNumbersRequestT& request = {}) const
        {
            return SubmitCallable(&SNSClient::ListSMSSandboxPhoneNumbers, request);
        }
 
        template<typename ListSMSSandboxPhoneNumbersRequestT = Model::ListSMSSandboxPhoneNumbersRequest>
        void ListSMSSandboxPhoneNumbersAsync(const ListSMSSandboxPhoneNumbersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSMSSandboxPhoneNumbersRequestT& request = {}) const
        {
            return SubmitAsync(&SNSClient::ListSMSSandboxPhoneNumbers, request, handler, context);
        }
 
        virtual Model::ListSubscriptionsOutcome ListSubscriptions(const Model::ListSubscriptionsRequest& request = {}) const;
 
        template<typename ListSubscriptionsRequestT = Model::ListSubscriptionsRequest>
        Model::ListSubscriptionsOutcomeCallable ListSubscriptionsCallable(const ListSubscriptionsRequestT& request = {}) const
        {
            return SubmitCallable(&SNSClient::ListSubscriptions, request);
        }
 
        template<typename ListSubscriptionsRequestT = Model::ListSubscriptionsRequest>
        void ListSubscriptionsAsync(const ListSubscriptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSubscriptionsRequestT& request = {}) const
        {
            return SubmitAsync(&SNSClient::ListSubscriptions, request, handler, context);
        }
 
        virtual Model::ListSubscriptionsByTopicOutcome ListSubscriptionsByTopic(const Model::ListSubscriptionsByTopicRequest& request) const;
 
        template<typename ListSubscriptionsByTopicRequestT = Model::ListSubscriptionsByTopicRequest>
        Model::ListSubscriptionsByTopicOutcomeCallable ListSubscriptionsByTopicCallable(const ListSubscriptionsByTopicRequestT& request) const
        {
            return SubmitCallable(&SNSClient::ListSubscriptionsByTopic, request);
        }
 
        template<typename ListSubscriptionsByTopicRequestT = Model::ListSubscriptionsByTopicRequest>
        void ListSubscriptionsByTopicAsync(const ListSubscriptionsByTopicRequestT& request, const ListSubscriptionsByTopicResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::ListSubscriptionsByTopic, request, handler, context);
        }
 
        virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const
        {
            return SubmitCallable(&SNSClient::ListTagsForResource, request);
        }
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListTopicsOutcome ListTopics(const Model::ListTopicsRequest& request = {}) const;
 
        template<typename ListTopicsRequestT = Model::ListTopicsRequest>
        Model::ListTopicsOutcomeCallable ListTopicsCallable(const ListTopicsRequestT& request = {}) const
        {
            return SubmitCallable(&SNSClient::ListTopics, request);
        }
 
        template<typename ListTopicsRequestT = Model::ListTopicsRequest>
        void ListTopicsAsync(const ListTopicsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTopicsRequestT& request = {}) const
        {
            return SubmitAsync(&SNSClient::ListTopics, request, handler, context);
        }
 
        virtual Model::OptInPhoneNumberOutcome OptInPhoneNumber(const Model::OptInPhoneNumberRequest& request) const;
 
        template<typename OptInPhoneNumberRequestT = Model::OptInPhoneNumberRequest>
        Model::OptInPhoneNumberOutcomeCallable OptInPhoneNumberCallable(const OptInPhoneNumberRequestT& request) const
        {
            return SubmitCallable(&SNSClient::OptInPhoneNumber, request);
        }
 
        template<typename OptInPhoneNumberRequestT = Model::OptInPhoneNumberRequest>
        void OptInPhoneNumberAsync(const OptInPhoneNumberRequestT& request, const OptInPhoneNumberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::OptInPhoneNumber, request, handler, context);
        }
 
        virtual Model::PublishOutcome Publish(const Model::PublishRequest& request) const;
 
        template<typename PublishRequestT = Model::PublishRequest>
        Model::PublishOutcomeCallable PublishCallable(const PublishRequestT& request) const
        {
            return SubmitCallable(&SNSClient::Publish, request);
        }
 
        template<typename PublishRequestT = Model::PublishRequest>
        void PublishAsync(const PublishRequestT& request, const PublishResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::Publish, request, handler, context);
        }
 
        virtual Model::PublishBatchOutcome PublishBatch(const Model::PublishBatchRequest& request) const;
 
        template<typename PublishBatchRequestT = Model::PublishBatchRequest>
        Model::PublishBatchOutcomeCallable PublishBatchCallable(const PublishBatchRequestT& request) const
        {
            return SubmitCallable(&SNSClient::PublishBatch, request);
        }
 
        template<typename PublishBatchRequestT = Model::PublishBatchRequest>
        void PublishBatchAsync(const PublishBatchRequestT& request, const PublishBatchResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::PublishBatch, request, handler, context);
        }
 
        virtual Model::PutDataProtectionPolicyOutcome PutDataProtectionPolicy(const Model::PutDataProtectionPolicyRequest& request) const;
 
        template<typename PutDataProtectionPolicyRequestT = Model::PutDataProtectionPolicyRequest>
        Model::PutDataProtectionPolicyOutcomeCallable PutDataProtectionPolicyCallable(const PutDataProtectionPolicyRequestT& request) const
        {
            return SubmitCallable(&SNSClient::PutDataProtectionPolicy, request);
        }
 
        template<typename PutDataProtectionPolicyRequestT = Model::PutDataProtectionPolicyRequest>
        void PutDataProtectionPolicyAsync(const PutDataProtectionPolicyRequestT& request, const PutDataProtectionPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::PutDataProtectionPolicy, request, handler, context);
        }
 
        virtual Model::RemovePermissionOutcome RemovePermission(const Model::RemovePermissionRequest& request) const;
 
        template<typename RemovePermissionRequestT = Model::RemovePermissionRequest>
        Model::RemovePermissionOutcomeCallable RemovePermissionCallable(const RemovePermissionRequestT& request) const
        {
            return SubmitCallable(&SNSClient::RemovePermission, request);
        }
 
        template<typename RemovePermissionRequestT = Model::RemovePermissionRequest>
        void RemovePermissionAsync(const RemovePermissionRequestT& request, const RemovePermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::RemovePermission, request, handler, context);
        }
 
        virtual Model::SetEndpointAttributesOutcome SetEndpointAttributes(const Model::SetEndpointAttributesRequest& request) const;
 
        template<typename SetEndpointAttributesRequestT = Model::SetEndpointAttributesRequest>
        Model::SetEndpointAttributesOutcomeCallable SetEndpointAttributesCallable(const SetEndpointAttributesRequestT& request) const
        {
            return SubmitCallable(&SNSClient::SetEndpointAttributes, request);
        }
 
        template<typename SetEndpointAttributesRequestT = Model::SetEndpointAttributesRequest>
        void SetEndpointAttributesAsync(const SetEndpointAttributesRequestT& request, const SetEndpointAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::SetEndpointAttributes, request, handler, context);
        }
 
        virtual Model::SetPlatformApplicationAttributesOutcome SetPlatformApplicationAttributes(const Model::SetPlatformApplicationAttributesRequest& request) const;
 
        template<typename SetPlatformApplicationAttributesRequestT = Model::SetPlatformApplicationAttributesRequest>
        Model::SetPlatformApplicationAttributesOutcomeCallable SetPlatformApplicationAttributesCallable(const SetPlatformApplicationAttributesRequestT& request) const
        {
            return SubmitCallable(&SNSClient::SetPlatformApplicationAttributes, request);
        }
 
        template<typename SetPlatformApplicationAttributesRequestT = Model::SetPlatformApplicationAttributesRequest>
        void SetPlatformApplicationAttributesAsync(const SetPlatformApplicationAttributesRequestT& request, const SetPlatformApplicationAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::SetPlatformApplicationAttributes, request, handler, context);
        }
 
        virtual Model::SetSMSAttributesOutcome SetSMSAttributes(const Model::SetSMSAttributesRequest& request) const;
 
        template<typename SetSMSAttributesRequestT = Model::SetSMSAttributesRequest>
        Model::SetSMSAttributesOutcomeCallable SetSMSAttributesCallable(const SetSMSAttributesRequestT& request) const
        {
            return SubmitCallable(&SNSClient::SetSMSAttributes, request);
        }
 
        template<typename SetSMSAttributesRequestT = Model::SetSMSAttributesRequest>
        void SetSMSAttributesAsync(const SetSMSAttributesRequestT& request, const SetSMSAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::SetSMSAttributes, request, handler, context);
        }
 
        virtual Model::SetSubscriptionAttributesOutcome SetSubscriptionAttributes(const Model::SetSubscriptionAttributesRequest& request) const;
 
        template<typename SetSubscriptionAttributesRequestT = Model::SetSubscriptionAttributesRequest>
        Model::SetSubscriptionAttributesOutcomeCallable SetSubscriptionAttributesCallable(const SetSubscriptionAttributesRequestT& request) const
        {
            return SubmitCallable(&SNSClient::SetSubscriptionAttributes, request);
        }
 
        template<typename SetSubscriptionAttributesRequestT = Model::SetSubscriptionAttributesRequest>
        void SetSubscriptionAttributesAsync(const SetSubscriptionAttributesRequestT& request, const SetSubscriptionAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::SetSubscriptionAttributes, request, handler, context);
        }
 
        virtual Model::SetTopicAttributesOutcome SetTopicAttributes(const Model::SetTopicAttributesRequest& request) const;
 
        template<typename SetTopicAttributesRequestT = Model::SetTopicAttributesRequest>
        Model::SetTopicAttributesOutcomeCallable SetTopicAttributesCallable(const SetTopicAttributesRequestT& request) const
        {
            return SubmitCallable(&SNSClient::SetTopicAttributes, request);
        }
 
        template<typename SetTopicAttributesRequestT = Model::SetTopicAttributesRequest>
        void SetTopicAttributesAsync(const SetTopicAttributesRequestT& request, const SetTopicAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::SetTopicAttributes, request, handler, context);
        }
 
        virtual Model::SubscribeOutcome Subscribe(const Model::SubscribeRequest& request) const;
 
        template<typename SubscribeRequestT = Model::SubscribeRequest>
        Model::SubscribeOutcomeCallable SubscribeCallable(const SubscribeRequestT& request) const
        {
            return SubmitCallable(&SNSClient::Subscribe, request);
        }
 
        template<typename SubscribeRequestT = Model::SubscribeRequest>
        void SubscribeAsync(const SubscribeRequestT& request, const SubscribeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::Subscribe, request, handler, context);
        }
 
        virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
        template<typename TagResourceRequestT = Model::TagResourceRequest>
        Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const
        {
            return SubmitCallable(&SNSClient::TagResource, request);
        }
 
        template<typename TagResourceRequestT = Model::TagResourceRequest>
        void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::TagResource, request, handler, context);
        }
 
        virtual Model::UnsubscribeOutcome Unsubscribe(const Model::UnsubscribeRequest& request) const;
 
        template<typename UnsubscribeRequestT = Model::UnsubscribeRequest>
        Model::UnsubscribeOutcomeCallable UnsubscribeCallable(const UnsubscribeRequestT& request) const
        {
            return SubmitCallable(&SNSClient::Unsubscribe, request);
        }
 
        template<typename UnsubscribeRequestT = Model::UnsubscribeRequest>
        void UnsubscribeAsync(const UnsubscribeRequestT& request, const UnsubscribeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::Unsubscribe, request, handler, context);
        }
 
        virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const
        {
            return SubmitCallable(&SNSClient::UntagResource, request);
        }
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::UntagResource, request, handler, context);
        }
 
        virtual Model::VerifySMSSandboxPhoneNumberOutcome VerifySMSSandboxPhoneNumber(const Model::VerifySMSSandboxPhoneNumberRequest& request) const;
 
        template<typename VerifySMSSandboxPhoneNumberRequestT = Model::VerifySMSSandboxPhoneNumberRequest>
        Model::VerifySMSSandboxPhoneNumberOutcomeCallable VerifySMSSandboxPhoneNumberCallable(const VerifySMSSandboxPhoneNumberRequestT& request) const
        {
            return SubmitCallable(&SNSClient::VerifySMSSandboxPhoneNumber, request);
        }
 
        template<typename VerifySMSSandboxPhoneNumberRequestT = Model::VerifySMSSandboxPhoneNumberRequest>
        void VerifySMSSandboxPhoneNumberAsync(const VerifySMSSandboxPhoneNumberRequestT& request, const VerifySMSSandboxPhoneNumberResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SNSClient::VerifySMSSandboxPhoneNumber, request, handler, context);
        }
 
 
        void OverrideEndpoint(const Aws::String& endpoint);
        std::shared_ptr<SNSEndpointProviderBase>& accessEndpointProvider();
  private:
        friend class Aws::Client::ClientWithAsyncTemplateMethods<SNSClient>;
        void init(const SNSClientConfiguration& clientConfiguration);
 
        SNSClientConfiguration m_clientConfiguration;
        std::shared_ptr<SNSEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace SNS
} // namespace Aws