SNSClient.h

 
#pragma once
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/sns/SNSPaginationBase.h>
#include <aws/sns/SNSServiceClientModel.h>
#include <aws/sns/SNSWaiter.h>
#include <aws/sns/SNS_EXPORTS.h>
 
namespace Aws {
namespace SNS {
class AWS_SNS_API SNSClient : public Aws::Client::AWSXMLClient,
                              public Aws::Client::ClientWithAsyncTemplateMethods<SNSClient>,
                              public SNSPaginationBase<SNSClient>,
                              public SNSWaiter<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<SNSEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<SNSClient>;
  void init(const SNSClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, SNSError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  SNSClientConfiguration m_clientConfiguration;
  std::shared_ptr<SNSEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace SNS
}  // namespace Aws