EndUserMessagingClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/endusermessaging/EndUserMessagingPaginationBase.h>
#include <aws/endusermessaging/EndUserMessagingServiceClientModel.h>
#include <aws/endusermessaging/EndUserMessagingWaiter.h>
#include <aws/endusermessaging/EndUserMessaging_EXPORTS.h>
 
namespace Aws {
namespace EndUserMessaging {
class AWS_ENDUSERMESSAGING_API EndUserMessagingClient : public Aws::Client::AWSJsonClient,
                                                        public Aws::Client::ClientWithAsyncTemplateMethods<EndUserMessagingClient>,
                                                        public EndUserMessagingPaginationBase<EndUserMessagingClient>,
                                                        public EndUserMessagingWaiter<EndUserMessagingClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef EndUserMessagingClientConfiguration ClientConfigurationType;
  typedef EndUserMessagingEndpointProvider EndpointProviderType;
 
  EndUserMessagingClient(const Aws::EndUserMessaging::EndUserMessagingClientConfiguration& clientConfiguration =
                             Aws::EndUserMessaging::EndUserMessagingClientConfiguration(),
                         std::shared_ptr<EndUserMessagingEndpointProviderBase> endpointProvider = nullptr);
 
  EndUserMessagingClient(const Aws::Auth::AWSCredentials& credentials,
                         std::shared_ptr<EndUserMessagingEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::EndUserMessaging::EndUserMessagingClientConfiguration& clientConfiguration =
                             Aws::EndUserMessaging::EndUserMessagingClientConfiguration());
 
  EndUserMessagingClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         std::shared_ptr<EndUserMessagingEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::EndUserMessaging::EndUserMessagingClientConfiguration& clientConfiguration =
                             Aws::EndUserMessaging::EndUserMessagingClientConfiguration());
 
  /* Legacy constructors due deprecation */
  EndUserMessagingClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  EndUserMessagingClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  EndUserMessagingClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~EndUserMessagingClient();
 
  virtual Model::CreateBrandProfileOutcome CreateBrandProfile(const Model::CreateBrandProfileRequest& request) const;
 
  template <typename CreateBrandProfileRequestT = Model::CreateBrandProfileRequest>
  Model::CreateBrandProfileOutcomeCallable CreateBrandProfileCallable(const CreateBrandProfileRequestT& request) const {
    return SubmitCallable(&EndUserMessagingClient::CreateBrandProfile, request);
  }
 
  template <typename CreateBrandProfileRequestT = Model::CreateBrandProfileRequest>
  void CreateBrandProfileAsync(const CreateBrandProfileRequestT& request, const CreateBrandProfileResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EndUserMessagingClient::CreateBrandProfile, request, handler, context);
  }
 
  virtual Model::CreateBrandProfileAttributesOutcome CreateBrandProfileAttributes(
      const Model::CreateBrandProfileAttributesRequest& request) const;
 
  template <typename CreateBrandProfileAttributesRequestT = Model::CreateBrandProfileAttributesRequest>
  Model::CreateBrandProfileAttributesOutcomeCallable CreateBrandProfileAttributesCallable(
      const CreateBrandProfileAttributesRequestT& request) const {
    return SubmitCallable(&EndUserMessagingClient::CreateBrandProfileAttributes, request);
  }
 
  template <typename CreateBrandProfileAttributesRequestT = Model::CreateBrandProfileAttributesRequest>
  void CreateBrandProfileAttributesAsync(const CreateBrandProfileAttributesRequestT& request,
                                         const CreateBrandProfileAttributesResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EndUserMessagingClient::CreateBrandProfileAttributes, request, handler, context);
  }
 
  virtual Model::CreateBrandProfileFromRegistrationOutcome CreateBrandProfileFromRegistration(
      const Model::CreateBrandProfileFromRegistrationRequest& request) const;
 
  template <typename CreateBrandProfileFromRegistrationRequestT = Model::CreateBrandProfileFromRegistrationRequest>
  Model::CreateBrandProfileFromRegistrationOutcomeCallable CreateBrandProfileFromRegistrationCallable(
      const CreateBrandProfileFromRegistrationRequestT& request) const {
    return SubmitCallable(&EndUserMessagingClient::CreateBrandProfileFromRegistration, request);
  }
 
  template <typename CreateBrandProfileFromRegistrationRequestT = Model::CreateBrandProfileFromRegistrationRequest>
  void CreateBrandProfileFromRegistrationAsync(const CreateBrandProfileFromRegistrationRequestT& request,
                                               const CreateBrandProfileFromRegistrationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EndUserMessagingClient::CreateBrandProfileFromRegistration, request, handler, context);
  }
 
  virtual Model::CreateNotifyCodeConfigurationOutcome CreateNotifyCodeConfiguration(
      const Model::CreateNotifyCodeConfigurationRequest& request) const;
 
  template <typename CreateNotifyCodeConfigurationRequestT = Model::CreateNotifyCodeConfigurationRequest>
  Model::CreateNotifyCodeConfigurationOutcomeCallable CreateNotifyCodeConfigurationCallable(
      const CreateNotifyCodeConfigurationRequestT& request) const {
    return SubmitCallable(&EndUserMessagingClient::CreateNotifyCodeConfiguration, request);
  }
 
  template <typename CreateNotifyCodeConfigurationRequestT = Model::CreateNotifyCodeConfigurationRequest>
  void CreateNotifyCodeConfigurationAsync(const CreateNotifyCodeConfigurationRequestT& request,
                                          const CreateNotifyCodeConfigurationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EndUserMessagingClient::CreateNotifyCodeConfiguration, request, handler, context);
  }
 
  virtual Model::CreateRegistrationsFromBrandProfileOutcome CreateRegistrationsFromBrandProfile(
      const Model::CreateRegistrationsFromBrandProfileRequest& request) const;
 
  template <typename CreateRegistrationsFromBrandProfileRequestT = Model::CreateRegistrationsFromBrandProfileRequest>
  Model::CreateRegistrationsFromBrandProfileOutcomeCallable CreateRegistrationsFromBrandProfileCallable(
      const CreateRegistrationsFromBrandProfileRequestT& request) const {
    return SubmitCallable(&EndUserMessagingClient::CreateRegistrationsFromBrandProfile, request);
  }
 
  template <typename CreateRegistrationsFromBrandProfileRequestT = Model::CreateRegistrationsFromBrandProfileRequest>
  void CreateRegistrationsFromBrandProfileAsync(const CreateRegistrationsFromBrandProfileRequestT& request,
                                                const CreateRegistrationsFromBrandProfileResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EndUserMessagingClient::CreateRegistrationsFromBrandProfile, request, handler, context);
  }
 
  virtual Model::DeleteBrandProfileOutcome DeleteBrandProfile(const Model::DeleteBrandProfileRequest& request) const;
 
  template <typename DeleteBrandProfileRequestT = Model::DeleteBrandProfileRequest>
  Model::DeleteBrandProfileOutcomeCallable DeleteBrandProfileCallable(const DeleteBrandProfileRequestT& request) const {
    return SubmitCallable(&EndUserMessagingClient::DeleteBrandProfile, request);
  }
 
  template <typename DeleteBrandProfileRequestT = Model::DeleteBrandProfileRequest>
  void DeleteBrandProfileAsync(const DeleteBrandProfileRequestT& request, const DeleteBrandProfileResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EndUserMessagingClient::DeleteBrandProfile, request, handler, context);
  }
 
  virtual Model::DeleteBrandProfileAttributeOutcome DeleteBrandProfileAttribute(
      const Model::DeleteBrandProfileAttributeRequest& request) const;
 
  template <typename DeleteBrandProfileAttributeRequestT = Model::DeleteBrandProfileAttributeRequest>
  Model::DeleteBrandProfileAttributeOutcomeCallable DeleteBrandProfileAttributeCallable(
      const DeleteBrandProfileAttributeRequestT& request) const {
    return SubmitCallable(&EndUserMessagingClient::DeleteBrandProfileAttribute, request);
  }
 
  template <typename DeleteBrandProfileAttributeRequestT = Model::DeleteBrandProfileAttributeRequest>
  void DeleteBrandProfileAttributeAsync(const DeleteBrandProfileAttributeRequestT& request,
                                        const DeleteBrandProfileAttributeResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EndUserMessagingClient::DeleteBrandProfileAttribute, request, handler, context);
  }
 
  virtual Model::DeleteNotifyCodeConfigurationOutcome DeleteNotifyCodeConfiguration(
      const Model::DeleteNotifyCodeConfigurationRequest& request) const;
 
  template <typename DeleteNotifyCodeConfigurationRequestT = Model::DeleteNotifyCodeConfigurationRequest>
  Model::DeleteNotifyCodeConfigurationOutcomeCallable DeleteNotifyCodeConfigurationCallable(
      const DeleteNotifyCodeConfigurationRequestT& request) const {
    return SubmitCallable(&EndUserMessagingClient::DeleteNotifyCodeConfiguration, request);
  }
 
  template <typename DeleteNotifyCodeConfigurationRequestT = Model::DeleteNotifyCodeConfigurationRequest>
  void DeleteNotifyCodeConfigurationAsync(const DeleteNotifyCodeConfigurationRequestT& request,
                                          const DeleteNotifyCodeConfigurationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EndUserMessagingClient::DeleteNotifyCodeConfiguration, request, handler, context);
  }
 
  virtual Model::GetBrandProfileOutcome GetBrandProfile(const Model::GetBrandProfileRequest& request) const;
 
  template <typename GetBrandProfileRequestT = Model::GetBrandProfileRequest>
  Model::GetBrandProfileOutcomeCallable GetBrandProfileCallable(const GetBrandProfileRequestT& request) const {
    return SubmitCallable(&EndUserMessagingClient::GetBrandProfile, request);
  }
 
  template <typename GetBrandProfileRequestT = Model::GetBrandProfileRequest>
  void GetBrandProfileAsync(const GetBrandProfileRequestT& request, const GetBrandProfileResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EndUserMessagingClient::GetBrandProfile, request, handler, context);
  }
 
  virtual Model::GetBrandProfileAttributeOutcome GetBrandProfileAttribute(const Model::GetBrandProfileAttributeRequest& request) const;
 
  template <typename GetBrandProfileAttributeRequestT = Model::GetBrandProfileAttributeRequest>
  Model::GetBrandProfileAttributeOutcomeCallable GetBrandProfileAttributeCallable(const GetBrandProfileAttributeRequestT& request) const {
    return SubmitCallable(&EndUserMessagingClient::GetBrandProfileAttribute, request);
  }
 
  template <typename GetBrandProfileAttributeRequestT = Model::GetBrandProfileAttributeRequest>
  void GetBrandProfileAttributeAsync(const GetBrandProfileAttributeRequestT& request,
                                     const GetBrandProfileAttributeResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EndUserMessagingClient::GetBrandProfileAttribute, request, handler, context);
  }
 
  virtual Model::GetJobOutcome GetJob(const Model::GetJobRequest& request) const;
 
  template <typename GetJobRequestT = Model::GetJobRequest>
  Model::GetJobOutcomeCallable GetJobCallable(const GetJobRequestT& request) const {
    return SubmitCallable(&EndUserMessagingClient::GetJob, request);
  }
 
  template <typename GetJobRequestT = Model::GetJobRequest>
  void GetJobAsync(const GetJobRequestT& request, const GetJobResponseReceivedHandler& handler,
                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EndUserMessagingClient::GetJob, request, handler, context);
  }
 
  virtual Model::GetNotifyCodeConfigurationOutcome GetNotifyCodeConfiguration(
      const Model::GetNotifyCodeConfigurationRequest& request) const;
 
  template <typename GetNotifyCodeConfigurationRequestT = Model::GetNotifyCodeConfigurationRequest>
  Model::GetNotifyCodeConfigurationOutcomeCallable GetNotifyCodeConfigurationCallable(
      const GetNotifyCodeConfigurationRequestT& request) const {
    return SubmitCallable(&EndUserMessagingClient::GetNotifyCodeConfiguration, request);
  }
 
  template <typename GetNotifyCodeConfigurationRequestT = Model::GetNotifyCodeConfigurationRequest>
  void GetNotifyCodeConfigurationAsync(const GetNotifyCodeConfigurationRequestT& request,
                                       const GetNotifyCodeConfigurationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EndUserMessagingClient::GetNotifyCodeConfiguration, request, handler, context);
  }
 
  virtual Model::ListBrandProfileAttributesOutcome ListBrandProfileAttributes(
      const Model::ListBrandProfileAttributesRequest& request) const;
 
  template <typename ListBrandProfileAttributesRequestT = Model::ListBrandProfileAttributesRequest>
  Model::ListBrandProfileAttributesOutcomeCallable ListBrandProfileAttributesCallable(
      const ListBrandProfileAttributesRequestT& request) const {
    return SubmitCallable(&EndUserMessagingClient::ListBrandProfileAttributes, request);
  }
 
  template <typename ListBrandProfileAttributesRequestT = Model::ListBrandProfileAttributesRequest>
  void ListBrandProfileAttributesAsync(const ListBrandProfileAttributesRequestT& request,
                                       const ListBrandProfileAttributesResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EndUserMessagingClient::ListBrandProfileAttributes, request, handler, context);
  }
 
  virtual Model::ListBrandProfilesOutcome ListBrandProfiles(const Model::ListBrandProfilesRequest& request = {}) const;
 
  template <typename ListBrandProfilesRequestT = Model::ListBrandProfilesRequest>
  Model::ListBrandProfilesOutcomeCallable ListBrandProfilesCallable(const ListBrandProfilesRequestT& request = {}) const {
    return SubmitCallable(&EndUserMessagingClient::ListBrandProfiles, request);
  }
 
  template <typename ListBrandProfilesRequestT = Model::ListBrandProfilesRequest>
  void ListBrandProfilesAsync(const ListBrandProfilesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListBrandProfilesRequestT& request = {}) const {
    return SubmitAsync(&EndUserMessagingClient::ListBrandProfiles, request, handler, context);
  }
 
  virtual Model::ListJobsOutcome ListJobs(const Model::ListJobsRequest& request = {}) const;
 
  template <typename ListJobsRequestT = Model::ListJobsRequest>
  Model::ListJobsOutcomeCallable ListJobsCallable(const ListJobsRequestT& request = {}) const {
    return SubmitCallable(&EndUserMessagingClient::ListJobs, request);
  }
 
  template <typename ListJobsRequestT = Model::ListJobsRequest>
  void ListJobsAsync(const ListJobsResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                     const ListJobsRequestT& request = {}) const {
    return SubmitAsync(&EndUserMessagingClient::ListJobs, request, handler, context);
  }
 
  virtual Model::ListNotifyCodeConfigurationsOutcome ListNotifyCodeConfigurations(
      const Model::ListNotifyCodeConfigurationsRequest& request = {}) const;
 
  template <typename ListNotifyCodeConfigurationsRequestT = Model::ListNotifyCodeConfigurationsRequest>
  Model::ListNotifyCodeConfigurationsOutcomeCallable ListNotifyCodeConfigurationsCallable(
      const ListNotifyCodeConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&EndUserMessagingClient::ListNotifyCodeConfigurations, request);
  }
 
  template <typename ListNotifyCodeConfigurationsRequestT = Model::ListNotifyCodeConfigurationsRequest>
  void ListNotifyCodeConfigurationsAsync(const ListNotifyCodeConfigurationsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const ListNotifyCodeConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&EndUserMessagingClient::ListNotifyCodeConfigurations, request, handler, context);
  }
 
  virtual Model::ListRegistrationsFromBrandProfileOutcome ListRegistrationsFromBrandProfile(
      const Model::ListRegistrationsFromBrandProfileRequest& request) const;
 
  template <typename ListRegistrationsFromBrandProfileRequestT = Model::ListRegistrationsFromBrandProfileRequest>
  Model::ListRegistrationsFromBrandProfileOutcomeCallable ListRegistrationsFromBrandProfileCallable(
      const ListRegistrationsFromBrandProfileRequestT& request) const {
    return SubmitCallable(&EndUserMessagingClient::ListRegistrationsFromBrandProfile, request);
  }
 
  template <typename ListRegistrationsFromBrandProfileRequestT = Model::ListRegistrationsFromBrandProfileRequest>
  void ListRegistrationsFromBrandProfileAsync(const ListRegistrationsFromBrandProfileRequestT& request,
                                              const ListRegistrationsFromBrandProfileResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EndUserMessagingClient::ListRegistrationsFromBrandProfile, 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(&EndUserMessagingClient::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(&EndUserMessagingClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::SendNotifyCodeVerificationOutcome SendNotifyCodeVerification(
      const Model::SendNotifyCodeVerificationRequest& request) const;
 
  template <typename SendNotifyCodeVerificationRequestT = Model::SendNotifyCodeVerificationRequest>
  Model::SendNotifyCodeVerificationOutcomeCallable SendNotifyCodeVerificationCallable(
      const SendNotifyCodeVerificationRequestT& request) const {
    return SubmitCallable(&EndUserMessagingClient::SendNotifyCodeVerification, request);
  }
 
  template <typename SendNotifyCodeVerificationRequestT = Model::SendNotifyCodeVerificationRequest>
  void SendNotifyCodeVerificationAsync(const SendNotifyCodeVerificationRequestT& request,
                                       const SendNotifyCodeVerificationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EndUserMessagingClient::SendNotifyCodeVerification, 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(&EndUserMessagingClient::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(&EndUserMessagingClient::TagResource, 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(&EndUserMessagingClient::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(&EndUserMessagingClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateBrandProfileOutcome UpdateBrandProfile(const Model::UpdateBrandProfileRequest& request) const;
 
  template <typename UpdateBrandProfileRequestT = Model::UpdateBrandProfileRequest>
  Model::UpdateBrandProfileOutcomeCallable UpdateBrandProfileCallable(const UpdateBrandProfileRequestT& request) const {
    return SubmitCallable(&EndUserMessagingClient::UpdateBrandProfile, request);
  }
 
  template <typename UpdateBrandProfileRequestT = Model::UpdateBrandProfileRequest>
  void UpdateBrandProfileAsync(const UpdateBrandProfileRequestT& request, const UpdateBrandProfileResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EndUserMessagingClient::UpdateBrandProfile, request, handler, context);
  }
 
  virtual Model::UpdateBrandProfileAttributeOutcome UpdateBrandProfileAttribute(
      const Model::UpdateBrandProfileAttributeRequest& request) const;
 
  template <typename UpdateBrandProfileAttributeRequestT = Model::UpdateBrandProfileAttributeRequest>
  Model::UpdateBrandProfileAttributeOutcomeCallable UpdateBrandProfileAttributeCallable(
      const UpdateBrandProfileAttributeRequestT& request) const {
    return SubmitCallable(&EndUserMessagingClient::UpdateBrandProfileAttribute, request);
  }
 
  template <typename UpdateBrandProfileAttributeRequestT = Model::UpdateBrandProfileAttributeRequest>
  void UpdateBrandProfileAttributeAsync(const UpdateBrandProfileAttributeRequestT& request,
                                        const UpdateBrandProfileAttributeResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EndUserMessagingClient::UpdateBrandProfileAttribute, request, handler, context);
  }
 
  virtual Model::UpdateBrandProfileFromRegistrationOutcome UpdateBrandProfileFromRegistration(
      const Model::UpdateBrandProfileFromRegistrationRequest& request) const;
 
  template <typename UpdateBrandProfileFromRegistrationRequestT = Model::UpdateBrandProfileFromRegistrationRequest>
  Model::UpdateBrandProfileFromRegistrationOutcomeCallable UpdateBrandProfileFromRegistrationCallable(
      const UpdateBrandProfileFromRegistrationRequestT& request) const {
    return SubmitCallable(&EndUserMessagingClient::UpdateBrandProfileFromRegistration, request);
  }
 
  template <typename UpdateBrandProfileFromRegistrationRequestT = Model::UpdateBrandProfileFromRegistrationRequest>
  void UpdateBrandProfileFromRegistrationAsync(const UpdateBrandProfileFromRegistrationRequestT& request,
                                               const UpdateBrandProfileFromRegistrationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EndUserMessagingClient::UpdateBrandProfileFromRegistration, request, handler, context);
  }
 
  virtual Model::UpdateNotifyCodeConfigurationOutcome UpdateNotifyCodeConfiguration(
      const Model::UpdateNotifyCodeConfigurationRequest& request) const;
 
  template <typename UpdateNotifyCodeConfigurationRequestT = Model::UpdateNotifyCodeConfigurationRequest>
  Model::UpdateNotifyCodeConfigurationOutcomeCallable UpdateNotifyCodeConfigurationCallable(
      const UpdateNotifyCodeConfigurationRequestT& request) const {
    return SubmitCallable(&EndUserMessagingClient::UpdateNotifyCodeConfiguration, request);
  }
 
  template <typename UpdateNotifyCodeConfigurationRequestT = Model::UpdateNotifyCodeConfigurationRequest>
  void UpdateNotifyCodeConfigurationAsync(const UpdateNotifyCodeConfigurationRequestT& request,
                                          const UpdateNotifyCodeConfigurationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EndUserMessagingClient::UpdateNotifyCodeConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateRegistrationsFromBrandProfileOutcome UpdateRegistrationsFromBrandProfile(
      const Model::UpdateRegistrationsFromBrandProfileRequest& request) const;
 
  template <typename UpdateRegistrationsFromBrandProfileRequestT = Model::UpdateRegistrationsFromBrandProfileRequest>
  Model::UpdateRegistrationsFromBrandProfileOutcomeCallable UpdateRegistrationsFromBrandProfileCallable(
      const UpdateRegistrationsFromBrandProfileRequestT& request) const {
    return SubmitCallable(&EndUserMessagingClient::UpdateRegistrationsFromBrandProfile, request);
  }
 
  template <typename UpdateRegistrationsFromBrandProfileRequestT = Model::UpdateRegistrationsFromBrandProfileRequest>
  void UpdateRegistrationsFromBrandProfileAsync(const UpdateRegistrationsFromBrandProfileRequestT& request,
                                                const UpdateRegistrationsFromBrandProfileResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EndUserMessagingClient::UpdateRegistrationsFromBrandProfile, request, handler, context);
  }
 
  virtual Model::ValidateNotifyCodeVerificationOutcome ValidateNotifyCodeVerification(
      const Model::ValidateNotifyCodeVerificationRequest& request) const;
 
  template <typename ValidateNotifyCodeVerificationRequestT = Model::ValidateNotifyCodeVerificationRequest>
  Model::ValidateNotifyCodeVerificationOutcomeCallable ValidateNotifyCodeVerificationCallable(
      const ValidateNotifyCodeVerificationRequestT& request) const {
    return SubmitCallable(&EndUserMessagingClient::ValidateNotifyCodeVerification, request);
  }
 
  template <typename ValidateNotifyCodeVerificationRequestT = Model::ValidateNotifyCodeVerificationRequest>
  void ValidateNotifyCodeVerificationAsync(const ValidateNotifyCodeVerificationRequestT& request,
                                           const ValidateNotifyCodeVerificationResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&EndUserMessagingClient::ValidateNotifyCodeVerification, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<EndUserMessagingEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<EndUserMessagingClient>;
  void init(const EndUserMessagingClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, EndUserMessagingError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  EndUserMessagingClientConfiguration m_clientConfiguration;
  std::shared_ptr<EndUserMessagingEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace EndUserMessaging
}  // namespace Aws