PinpointClient.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/pinpoint/PinpointPaginationBase.h>
#include <aws/pinpoint/PinpointServiceClientModel.h>
#include <aws/pinpoint/Pinpoint_EXPORTS.h>
 
namespace Aws {
namespace Pinpoint {
class AWS_PINPOINT_API PinpointClient : public Aws::Client::AWSJsonClient,
                                        public Aws::Client::ClientWithAsyncTemplateMethods<PinpointClient>,
                                        public PinpointPaginationBase<PinpointClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef PinpointClientConfiguration ClientConfigurationType;
  typedef PinpointEndpointProvider EndpointProviderType;
 
  PinpointClient(const Aws::Pinpoint::PinpointClientConfiguration& clientConfiguration = Aws::Pinpoint::PinpointClientConfiguration(),
                 std::shared_ptr<PinpointEndpointProviderBase> endpointProvider = nullptr);
 
  PinpointClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<PinpointEndpointProviderBase> endpointProvider = nullptr,
                 const Aws::Pinpoint::PinpointClientConfiguration& clientConfiguration = Aws::Pinpoint::PinpointClientConfiguration());
 
  PinpointClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                 std::shared_ptr<PinpointEndpointProviderBase> endpointProvider = nullptr,
                 const Aws::Pinpoint::PinpointClientConfiguration& clientConfiguration = Aws::Pinpoint::PinpointClientConfiguration());
 
  /* Legacy constructors due deprecation */
  PinpointClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  PinpointClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  PinpointClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                 const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~PinpointClient();
 
  virtual Model::CreateAppOutcome CreateApp(const Model::CreateAppRequest& request) const;
 
  template <typename CreateAppRequestT = Model::CreateAppRequest>
  Model::CreateAppOutcomeCallable CreateAppCallable(const CreateAppRequestT& request) const {
    return SubmitCallable(&PinpointClient::CreateApp, request);
  }
 
  template <typename CreateAppRequestT = Model::CreateAppRequest>
  void CreateAppAsync(const CreateAppRequestT& request, const CreateAppResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::CreateApp, request, handler, context);
  }
 
  virtual Model::CreateCampaignOutcome CreateCampaign(const Model::CreateCampaignRequest& request) const;
 
  template <typename CreateCampaignRequestT = Model::CreateCampaignRequest>
  Model::CreateCampaignOutcomeCallable CreateCampaignCallable(const CreateCampaignRequestT& request) const {
    return SubmitCallable(&PinpointClient::CreateCampaign, request);
  }
 
  template <typename CreateCampaignRequestT = Model::CreateCampaignRequest>
  void CreateCampaignAsync(const CreateCampaignRequestT& request, const CreateCampaignResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::CreateCampaign, request, handler, context);
  }
 
  virtual Model::CreateEmailTemplateOutcome CreateEmailTemplate(const Model::CreateEmailTemplateRequest& request) const;
 
  template <typename CreateEmailTemplateRequestT = Model::CreateEmailTemplateRequest>
  Model::CreateEmailTemplateOutcomeCallable CreateEmailTemplateCallable(const CreateEmailTemplateRequestT& request) const {
    return SubmitCallable(&PinpointClient::CreateEmailTemplate, request);
  }
 
  template <typename CreateEmailTemplateRequestT = Model::CreateEmailTemplateRequest>
  void CreateEmailTemplateAsync(const CreateEmailTemplateRequestT& request, const CreateEmailTemplateResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::CreateEmailTemplate, request, handler, context);
  }
 
  virtual Model::CreateExportJobOutcome CreateExportJob(const Model::CreateExportJobRequest& request) const;
 
  template <typename CreateExportJobRequestT = Model::CreateExportJobRequest>
  Model::CreateExportJobOutcomeCallable CreateExportJobCallable(const CreateExportJobRequestT& request) const {
    return SubmitCallable(&PinpointClient::CreateExportJob, request);
  }
 
  template <typename CreateExportJobRequestT = Model::CreateExportJobRequest>
  void CreateExportJobAsync(const CreateExportJobRequestT& request, const CreateExportJobResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::CreateExportJob, request, handler, context);
  }
 
  virtual Model::CreateImportJobOutcome CreateImportJob(const Model::CreateImportJobRequest& request) const;
 
  template <typename CreateImportJobRequestT = Model::CreateImportJobRequest>
  Model::CreateImportJobOutcomeCallable CreateImportJobCallable(const CreateImportJobRequestT& request) const {
    return SubmitCallable(&PinpointClient::CreateImportJob, request);
  }
 
  template <typename CreateImportJobRequestT = Model::CreateImportJobRequest>
  void CreateImportJobAsync(const CreateImportJobRequestT& request, const CreateImportJobResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::CreateImportJob, request, handler, context);
  }
 
  virtual Model::CreateInAppTemplateOutcome CreateInAppTemplate(const Model::CreateInAppTemplateRequest& request) const;
 
  template <typename CreateInAppTemplateRequestT = Model::CreateInAppTemplateRequest>
  Model::CreateInAppTemplateOutcomeCallable CreateInAppTemplateCallable(const CreateInAppTemplateRequestT& request) const {
    return SubmitCallable(&PinpointClient::CreateInAppTemplate, request);
  }
 
  template <typename CreateInAppTemplateRequestT = Model::CreateInAppTemplateRequest>
  void CreateInAppTemplateAsync(const CreateInAppTemplateRequestT& request, const CreateInAppTemplateResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::CreateInAppTemplate, request, handler, context);
  }
 
  virtual Model::CreateJourneyOutcome CreateJourney(const Model::CreateJourneyRequest& request) const;
 
  template <typename CreateJourneyRequestT = Model::CreateJourneyRequest>
  Model::CreateJourneyOutcomeCallable CreateJourneyCallable(const CreateJourneyRequestT& request) const {
    return SubmitCallable(&PinpointClient::CreateJourney, request);
  }
 
  template <typename CreateJourneyRequestT = Model::CreateJourneyRequest>
  void CreateJourneyAsync(const CreateJourneyRequestT& request, const CreateJourneyResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::CreateJourney, request, handler, context);
  }
 
  virtual Model::CreatePushTemplateOutcome CreatePushTemplate(const Model::CreatePushTemplateRequest& request) const;
 
  template <typename CreatePushTemplateRequestT = Model::CreatePushTemplateRequest>
  Model::CreatePushTemplateOutcomeCallable CreatePushTemplateCallable(const CreatePushTemplateRequestT& request) const {
    return SubmitCallable(&PinpointClient::CreatePushTemplate, request);
  }
 
  template <typename CreatePushTemplateRequestT = Model::CreatePushTemplateRequest>
  void CreatePushTemplateAsync(const CreatePushTemplateRequestT& request, const CreatePushTemplateResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::CreatePushTemplate, request, handler, context);
  }
 
  virtual Model::CreateRecommenderConfigurationOutcome CreateRecommenderConfiguration(
      const Model::CreateRecommenderConfigurationRequest& request) const;
 
  template <typename CreateRecommenderConfigurationRequestT = Model::CreateRecommenderConfigurationRequest>
  Model::CreateRecommenderConfigurationOutcomeCallable CreateRecommenderConfigurationCallable(
      const CreateRecommenderConfigurationRequestT& request) const {
    return SubmitCallable(&PinpointClient::CreateRecommenderConfiguration, request);
  }
 
  template <typename CreateRecommenderConfigurationRequestT = Model::CreateRecommenderConfigurationRequest>
  void CreateRecommenderConfigurationAsync(const CreateRecommenderConfigurationRequestT& request,
                                           const CreateRecommenderConfigurationResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::CreateRecommenderConfiguration, request, handler, context);
  }
 
  virtual Model::CreateSegmentOutcome CreateSegment(const Model::CreateSegmentRequest& request) const;
 
  template <typename CreateSegmentRequestT = Model::CreateSegmentRequest>
  Model::CreateSegmentOutcomeCallable CreateSegmentCallable(const CreateSegmentRequestT& request) const {
    return SubmitCallable(&PinpointClient::CreateSegment, request);
  }
 
  template <typename CreateSegmentRequestT = Model::CreateSegmentRequest>
  void CreateSegmentAsync(const CreateSegmentRequestT& request, const CreateSegmentResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::CreateSegment, request, handler, context);
  }
 
  virtual Model::CreateSmsTemplateOutcome CreateSmsTemplate(const Model::CreateSmsTemplateRequest& request) const;
 
  template <typename CreateSmsTemplateRequestT = Model::CreateSmsTemplateRequest>
  Model::CreateSmsTemplateOutcomeCallable CreateSmsTemplateCallable(const CreateSmsTemplateRequestT& request) const {
    return SubmitCallable(&PinpointClient::CreateSmsTemplate, request);
  }
 
  template <typename CreateSmsTemplateRequestT = Model::CreateSmsTemplateRequest>
  void CreateSmsTemplateAsync(const CreateSmsTemplateRequestT& request, const CreateSmsTemplateResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::CreateSmsTemplate, request, handler, context);
  }
 
  virtual Model::CreateVoiceTemplateOutcome CreateVoiceTemplate(const Model::CreateVoiceTemplateRequest& request) const;
 
  template <typename CreateVoiceTemplateRequestT = Model::CreateVoiceTemplateRequest>
  Model::CreateVoiceTemplateOutcomeCallable CreateVoiceTemplateCallable(const CreateVoiceTemplateRequestT& request) const {
    return SubmitCallable(&PinpointClient::CreateVoiceTemplate, request);
  }
 
  template <typename CreateVoiceTemplateRequestT = Model::CreateVoiceTemplateRequest>
  void CreateVoiceTemplateAsync(const CreateVoiceTemplateRequestT& request, const CreateVoiceTemplateResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::CreateVoiceTemplate, request, handler, context);
  }
 
  virtual Model::DeleteAdmChannelOutcome DeleteAdmChannel(const Model::DeleteAdmChannelRequest& request) const;
 
  template <typename DeleteAdmChannelRequestT = Model::DeleteAdmChannelRequest>
  Model::DeleteAdmChannelOutcomeCallable DeleteAdmChannelCallable(const DeleteAdmChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::DeleteAdmChannel, request);
  }
 
  template <typename DeleteAdmChannelRequestT = Model::DeleteAdmChannelRequest>
  void DeleteAdmChannelAsync(const DeleteAdmChannelRequestT& request, const DeleteAdmChannelResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::DeleteAdmChannel, request, handler, context);
  }
 
  virtual Model::DeleteApnsChannelOutcome DeleteApnsChannel(const Model::DeleteApnsChannelRequest& request) const;
 
  template <typename DeleteApnsChannelRequestT = Model::DeleteApnsChannelRequest>
  Model::DeleteApnsChannelOutcomeCallable DeleteApnsChannelCallable(const DeleteApnsChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::DeleteApnsChannel, request);
  }
 
  template <typename DeleteApnsChannelRequestT = Model::DeleteApnsChannelRequest>
  void DeleteApnsChannelAsync(const DeleteApnsChannelRequestT& request, const DeleteApnsChannelResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::DeleteApnsChannel, request, handler, context);
  }
 
  virtual Model::DeleteApnsSandboxChannelOutcome DeleteApnsSandboxChannel(const Model::DeleteApnsSandboxChannelRequest& request) const;
 
  template <typename DeleteApnsSandboxChannelRequestT = Model::DeleteApnsSandboxChannelRequest>
  Model::DeleteApnsSandboxChannelOutcomeCallable DeleteApnsSandboxChannelCallable(const DeleteApnsSandboxChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::DeleteApnsSandboxChannel, request);
  }
 
  template <typename DeleteApnsSandboxChannelRequestT = Model::DeleteApnsSandboxChannelRequest>
  void DeleteApnsSandboxChannelAsync(const DeleteApnsSandboxChannelRequestT& request,
                                     const DeleteApnsSandboxChannelResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::DeleteApnsSandboxChannel, request, handler, context);
  }
 
  virtual Model::DeleteApnsVoipChannelOutcome DeleteApnsVoipChannel(const Model::DeleteApnsVoipChannelRequest& request) const;
 
  template <typename DeleteApnsVoipChannelRequestT = Model::DeleteApnsVoipChannelRequest>
  Model::DeleteApnsVoipChannelOutcomeCallable DeleteApnsVoipChannelCallable(const DeleteApnsVoipChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::DeleteApnsVoipChannel, request);
  }
 
  template <typename DeleteApnsVoipChannelRequestT = Model::DeleteApnsVoipChannelRequest>
  void DeleteApnsVoipChannelAsync(const DeleteApnsVoipChannelRequestT& request, const DeleteApnsVoipChannelResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::DeleteApnsVoipChannel, request, handler, context);
  }
 
  virtual Model::DeleteApnsVoipSandboxChannelOutcome DeleteApnsVoipSandboxChannel(
      const Model::DeleteApnsVoipSandboxChannelRequest& request) const;
 
  template <typename DeleteApnsVoipSandboxChannelRequestT = Model::DeleteApnsVoipSandboxChannelRequest>
  Model::DeleteApnsVoipSandboxChannelOutcomeCallable DeleteApnsVoipSandboxChannelCallable(
      const DeleteApnsVoipSandboxChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::DeleteApnsVoipSandboxChannel, request);
  }
 
  template <typename DeleteApnsVoipSandboxChannelRequestT = Model::DeleteApnsVoipSandboxChannelRequest>
  void DeleteApnsVoipSandboxChannelAsync(const DeleteApnsVoipSandboxChannelRequestT& request,
                                         const DeleteApnsVoipSandboxChannelResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::DeleteApnsVoipSandboxChannel, request, handler, context);
  }
 
  virtual Model::DeleteAppOutcome DeleteApp(const Model::DeleteAppRequest& request) const;
 
  template <typename DeleteAppRequestT = Model::DeleteAppRequest>
  Model::DeleteAppOutcomeCallable DeleteAppCallable(const DeleteAppRequestT& request) const {
    return SubmitCallable(&PinpointClient::DeleteApp, request);
  }
 
  template <typename DeleteAppRequestT = Model::DeleteAppRequest>
  void DeleteAppAsync(const DeleteAppRequestT& request, const DeleteAppResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::DeleteApp, request, handler, context);
  }
 
  virtual Model::DeleteBaiduChannelOutcome DeleteBaiduChannel(const Model::DeleteBaiduChannelRequest& request) const;
 
  template <typename DeleteBaiduChannelRequestT = Model::DeleteBaiduChannelRequest>
  Model::DeleteBaiduChannelOutcomeCallable DeleteBaiduChannelCallable(const DeleteBaiduChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::DeleteBaiduChannel, request);
  }
 
  template <typename DeleteBaiduChannelRequestT = Model::DeleteBaiduChannelRequest>
  void DeleteBaiduChannelAsync(const DeleteBaiduChannelRequestT& request, const DeleteBaiduChannelResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::DeleteBaiduChannel, request, handler, context);
  }
 
  virtual Model::DeleteCampaignOutcome DeleteCampaign(const Model::DeleteCampaignRequest& request) const;
 
  template <typename DeleteCampaignRequestT = Model::DeleteCampaignRequest>
  Model::DeleteCampaignOutcomeCallable DeleteCampaignCallable(const DeleteCampaignRequestT& request) const {
    return SubmitCallable(&PinpointClient::DeleteCampaign, request);
  }
 
  template <typename DeleteCampaignRequestT = Model::DeleteCampaignRequest>
  void DeleteCampaignAsync(const DeleteCampaignRequestT& request, const DeleteCampaignResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::DeleteCampaign, request, handler, context);
  }
 
  virtual Model::DeleteEmailChannelOutcome DeleteEmailChannel(const Model::DeleteEmailChannelRequest& request) const;
 
  template <typename DeleteEmailChannelRequestT = Model::DeleteEmailChannelRequest>
  Model::DeleteEmailChannelOutcomeCallable DeleteEmailChannelCallable(const DeleteEmailChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::DeleteEmailChannel, request);
  }
 
  template <typename DeleteEmailChannelRequestT = Model::DeleteEmailChannelRequest>
  void DeleteEmailChannelAsync(const DeleteEmailChannelRequestT& request, const DeleteEmailChannelResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::DeleteEmailChannel, request, handler, context);
  }
 
  virtual Model::DeleteEmailTemplateOutcome DeleteEmailTemplate(const Model::DeleteEmailTemplateRequest& request) const;
 
  template <typename DeleteEmailTemplateRequestT = Model::DeleteEmailTemplateRequest>
  Model::DeleteEmailTemplateOutcomeCallable DeleteEmailTemplateCallable(const DeleteEmailTemplateRequestT& request) const {
    return SubmitCallable(&PinpointClient::DeleteEmailTemplate, request);
  }
 
  template <typename DeleteEmailTemplateRequestT = Model::DeleteEmailTemplateRequest>
  void DeleteEmailTemplateAsync(const DeleteEmailTemplateRequestT& request, const DeleteEmailTemplateResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::DeleteEmailTemplate, 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(&PinpointClient::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(&PinpointClient::DeleteEndpoint, request, handler, context);
  }
 
  virtual Model::DeleteEventStreamOutcome DeleteEventStream(const Model::DeleteEventStreamRequest& request) const;
 
  template <typename DeleteEventStreamRequestT = Model::DeleteEventStreamRequest>
  Model::DeleteEventStreamOutcomeCallable DeleteEventStreamCallable(const DeleteEventStreamRequestT& request) const {
    return SubmitCallable(&PinpointClient::DeleteEventStream, request);
  }
 
  template <typename DeleteEventStreamRequestT = Model::DeleteEventStreamRequest>
  void DeleteEventStreamAsync(const DeleteEventStreamRequestT& request, const DeleteEventStreamResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::DeleteEventStream, request, handler, context);
  }
 
  virtual Model::DeleteGcmChannelOutcome DeleteGcmChannel(const Model::DeleteGcmChannelRequest& request) const;
 
  template <typename DeleteGcmChannelRequestT = Model::DeleteGcmChannelRequest>
  Model::DeleteGcmChannelOutcomeCallable DeleteGcmChannelCallable(const DeleteGcmChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::DeleteGcmChannel, request);
  }
 
  template <typename DeleteGcmChannelRequestT = Model::DeleteGcmChannelRequest>
  void DeleteGcmChannelAsync(const DeleteGcmChannelRequestT& request, const DeleteGcmChannelResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::DeleteGcmChannel, request, handler, context);
  }
 
  virtual Model::DeleteInAppTemplateOutcome DeleteInAppTemplate(const Model::DeleteInAppTemplateRequest& request) const;
 
  template <typename DeleteInAppTemplateRequestT = Model::DeleteInAppTemplateRequest>
  Model::DeleteInAppTemplateOutcomeCallable DeleteInAppTemplateCallable(const DeleteInAppTemplateRequestT& request) const {
    return SubmitCallable(&PinpointClient::DeleteInAppTemplate, request);
  }
 
  template <typename DeleteInAppTemplateRequestT = Model::DeleteInAppTemplateRequest>
  void DeleteInAppTemplateAsync(const DeleteInAppTemplateRequestT& request, const DeleteInAppTemplateResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::DeleteInAppTemplate, request, handler, context);
  }
 
  virtual Model::DeleteJourneyOutcome DeleteJourney(const Model::DeleteJourneyRequest& request) const;
 
  template <typename DeleteJourneyRequestT = Model::DeleteJourneyRequest>
  Model::DeleteJourneyOutcomeCallable DeleteJourneyCallable(const DeleteJourneyRequestT& request) const {
    return SubmitCallable(&PinpointClient::DeleteJourney, request);
  }
 
  template <typename DeleteJourneyRequestT = Model::DeleteJourneyRequest>
  void DeleteJourneyAsync(const DeleteJourneyRequestT& request, const DeleteJourneyResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::DeleteJourney, request, handler, context);
  }
 
  virtual Model::DeletePushTemplateOutcome DeletePushTemplate(const Model::DeletePushTemplateRequest& request) const;
 
  template <typename DeletePushTemplateRequestT = Model::DeletePushTemplateRequest>
  Model::DeletePushTemplateOutcomeCallable DeletePushTemplateCallable(const DeletePushTemplateRequestT& request) const {
    return SubmitCallable(&PinpointClient::DeletePushTemplate, request);
  }
 
  template <typename DeletePushTemplateRequestT = Model::DeletePushTemplateRequest>
  void DeletePushTemplateAsync(const DeletePushTemplateRequestT& request, const DeletePushTemplateResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::DeletePushTemplate, request, handler, context);
  }
 
  virtual Model::DeleteRecommenderConfigurationOutcome DeleteRecommenderConfiguration(
      const Model::DeleteRecommenderConfigurationRequest& request) const;
 
  template <typename DeleteRecommenderConfigurationRequestT = Model::DeleteRecommenderConfigurationRequest>
  Model::DeleteRecommenderConfigurationOutcomeCallable DeleteRecommenderConfigurationCallable(
      const DeleteRecommenderConfigurationRequestT& request) const {
    return SubmitCallable(&PinpointClient::DeleteRecommenderConfiguration, request);
  }
 
  template <typename DeleteRecommenderConfigurationRequestT = Model::DeleteRecommenderConfigurationRequest>
  void DeleteRecommenderConfigurationAsync(const DeleteRecommenderConfigurationRequestT& request,
                                           const DeleteRecommenderConfigurationResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::DeleteRecommenderConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteSegmentOutcome DeleteSegment(const Model::DeleteSegmentRequest& request) const;
 
  template <typename DeleteSegmentRequestT = Model::DeleteSegmentRequest>
  Model::DeleteSegmentOutcomeCallable DeleteSegmentCallable(const DeleteSegmentRequestT& request) const {
    return SubmitCallable(&PinpointClient::DeleteSegment, request);
  }
 
  template <typename DeleteSegmentRequestT = Model::DeleteSegmentRequest>
  void DeleteSegmentAsync(const DeleteSegmentRequestT& request, const DeleteSegmentResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::DeleteSegment, request, handler, context);
  }
 
  virtual Model::DeleteSmsChannelOutcome DeleteSmsChannel(const Model::DeleteSmsChannelRequest& request) const;
 
  template <typename DeleteSmsChannelRequestT = Model::DeleteSmsChannelRequest>
  Model::DeleteSmsChannelOutcomeCallable DeleteSmsChannelCallable(const DeleteSmsChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::DeleteSmsChannel, request);
  }
 
  template <typename DeleteSmsChannelRequestT = Model::DeleteSmsChannelRequest>
  void DeleteSmsChannelAsync(const DeleteSmsChannelRequestT& request, const DeleteSmsChannelResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::DeleteSmsChannel, request, handler, context);
  }
 
  virtual Model::DeleteSmsTemplateOutcome DeleteSmsTemplate(const Model::DeleteSmsTemplateRequest& request) const;
 
  template <typename DeleteSmsTemplateRequestT = Model::DeleteSmsTemplateRequest>
  Model::DeleteSmsTemplateOutcomeCallable DeleteSmsTemplateCallable(const DeleteSmsTemplateRequestT& request) const {
    return SubmitCallable(&PinpointClient::DeleteSmsTemplate, request);
  }
 
  template <typename DeleteSmsTemplateRequestT = Model::DeleteSmsTemplateRequest>
  void DeleteSmsTemplateAsync(const DeleteSmsTemplateRequestT& request, const DeleteSmsTemplateResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::DeleteSmsTemplate, request, handler, context);
  }
 
  virtual Model::DeleteUserEndpointsOutcome DeleteUserEndpoints(const Model::DeleteUserEndpointsRequest& request) const;
 
  template <typename DeleteUserEndpointsRequestT = Model::DeleteUserEndpointsRequest>
  Model::DeleteUserEndpointsOutcomeCallable DeleteUserEndpointsCallable(const DeleteUserEndpointsRequestT& request) const {
    return SubmitCallable(&PinpointClient::DeleteUserEndpoints, request);
  }
 
  template <typename DeleteUserEndpointsRequestT = Model::DeleteUserEndpointsRequest>
  void DeleteUserEndpointsAsync(const DeleteUserEndpointsRequestT& request, const DeleteUserEndpointsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::DeleteUserEndpoints, request, handler, context);
  }
 
  virtual Model::DeleteVoiceChannelOutcome DeleteVoiceChannel(const Model::DeleteVoiceChannelRequest& request) const;
 
  template <typename DeleteVoiceChannelRequestT = Model::DeleteVoiceChannelRequest>
  Model::DeleteVoiceChannelOutcomeCallable DeleteVoiceChannelCallable(const DeleteVoiceChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::DeleteVoiceChannel, request);
  }
 
  template <typename DeleteVoiceChannelRequestT = Model::DeleteVoiceChannelRequest>
  void DeleteVoiceChannelAsync(const DeleteVoiceChannelRequestT& request, const DeleteVoiceChannelResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::DeleteVoiceChannel, request, handler, context);
  }
 
  virtual Model::DeleteVoiceTemplateOutcome DeleteVoiceTemplate(const Model::DeleteVoiceTemplateRequest& request) const;
 
  template <typename DeleteVoiceTemplateRequestT = Model::DeleteVoiceTemplateRequest>
  Model::DeleteVoiceTemplateOutcomeCallable DeleteVoiceTemplateCallable(const DeleteVoiceTemplateRequestT& request) const {
    return SubmitCallable(&PinpointClient::DeleteVoiceTemplate, request);
  }
 
  template <typename DeleteVoiceTemplateRequestT = Model::DeleteVoiceTemplateRequest>
  void DeleteVoiceTemplateAsync(const DeleteVoiceTemplateRequestT& request, const DeleteVoiceTemplateResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::DeleteVoiceTemplate, request, handler, context);
  }
 
  virtual Model::GetAdmChannelOutcome GetAdmChannel(const Model::GetAdmChannelRequest& request) const;
 
  template <typename GetAdmChannelRequestT = Model::GetAdmChannelRequest>
  Model::GetAdmChannelOutcomeCallable GetAdmChannelCallable(const GetAdmChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetAdmChannel, request);
  }
 
  template <typename GetAdmChannelRequestT = Model::GetAdmChannelRequest>
  void GetAdmChannelAsync(const GetAdmChannelRequestT& request, const GetAdmChannelResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetAdmChannel, request, handler, context);
  }
 
  virtual Model::GetApnsChannelOutcome GetApnsChannel(const Model::GetApnsChannelRequest& request) const;
 
  template <typename GetApnsChannelRequestT = Model::GetApnsChannelRequest>
  Model::GetApnsChannelOutcomeCallable GetApnsChannelCallable(const GetApnsChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetApnsChannel, request);
  }
 
  template <typename GetApnsChannelRequestT = Model::GetApnsChannelRequest>
  void GetApnsChannelAsync(const GetApnsChannelRequestT& request, const GetApnsChannelResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetApnsChannel, request, handler, context);
  }
 
  virtual Model::GetApnsSandboxChannelOutcome GetApnsSandboxChannel(const Model::GetApnsSandboxChannelRequest& request) const;
 
  template <typename GetApnsSandboxChannelRequestT = Model::GetApnsSandboxChannelRequest>
  Model::GetApnsSandboxChannelOutcomeCallable GetApnsSandboxChannelCallable(const GetApnsSandboxChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetApnsSandboxChannel, request);
  }
 
  template <typename GetApnsSandboxChannelRequestT = Model::GetApnsSandboxChannelRequest>
  void GetApnsSandboxChannelAsync(const GetApnsSandboxChannelRequestT& request, const GetApnsSandboxChannelResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetApnsSandboxChannel, request, handler, context);
  }
 
  virtual Model::GetApnsVoipChannelOutcome GetApnsVoipChannel(const Model::GetApnsVoipChannelRequest& request) const;
 
  template <typename GetApnsVoipChannelRequestT = Model::GetApnsVoipChannelRequest>
  Model::GetApnsVoipChannelOutcomeCallable GetApnsVoipChannelCallable(const GetApnsVoipChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetApnsVoipChannel, request);
  }
 
  template <typename GetApnsVoipChannelRequestT = Model::GetApnsVoipChannelRequest>
  void GetApnsVoipChannelAsync(const GetApnsVoipChannelRequestT& request, const GetApnsVoipChannelResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetApnsVoipChannel, request, handler, context);
  }
 
  virtual Model::GetApnsVoipSandboxChannelOutcome GetApnsVoipSandboxChannel(const Model::GetApnsVoipSandboxChannelRequest& request) const;
 
  template <typename GetApnsVoipSandboxChannelRequestT = Model::GetApnsVoipSandboxChannelRequest>
  Model::GetApnsVoipSandboxChannelOutcomeCallable GetApnsVoipSandboxChannelCallable(
      const GetApnsVoipSandboxChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetApnsVoipSandboxChannel, request);
  }
 
  template <typename GetApnsVoipSandboxChannelRequestT = Model::GetApnsVoipSandboxChannelRequest>
  void GetApnsVoipSandboxChannelAsync(const GetApnsVoipSandboxChannelRequestT& request,
                                      const GetApnsVoipSandboxChannelResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetApnsVoipSandboxChannel, request, handler, context);
  }
 
  virtual Model::GetAppOutcome GetApp(const Model::GetAppRequest& request) const;
 
  template <typename GetAppRequestT = Model::GetAppRequest>
  Model::GetAppOutcomeCallable GetAppCallable(const GetAppRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetApp, request);
  }
 
  template <typename GetAppRequestT = Model::GetAppRequest>
  void GetAppAsync(const GetAppRequestT& request, const GetAppResponseReceivedHandler& handler,
                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetApp, request, handler, context);
  }
 
  virtual Model::GetApplicationDateRangeKpiOutcome GetApplicationDateRangeKpi(
      const Model::GetApplicationDateRangeKpiRequest& request) const;
 
  template <typename GetApplicationDateRangeKpiRequestT = Model::GetApplicationDateRangeKpiRequest>
  Model::GetApplicationDateRangeKpiOutcomeCallable GetApplicationDateRangeKpiCallable(
      const GetApplicationDateRangeKpiRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetApplicationDateRangeKpi, request);
  }
 
  template <typename GetApplicationDateRangeKpiRequestT = Model::GetApplicationDateRangeKpiRequest>
  void GetApplicationDateRangeKpiAsync(const GetApplicationDateRangeKpiRequestT& request,
                                       const GetApplicationDateRangeKpiResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetApplicationDateRangeKpi, request, handler, context);
  }
 
  virtual Model::GetApplicationSettingsOutcome GetApplicationSettings(const Model::GetApplicationSettingsRequest& request) const;
 
  template <typename GetApplicationSettingsRequestT = Model::GetApplicationSettingsRequest>
  Model::GetApplicationSettingsOutcomeCallable GetApplicationSettingsCallable(const GetApplicationSettingsRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetApplicationSettings, request);
  }
 
  template <typename GetApplicationSettingsRequestT = Model::GetApplicationSettingsRequest>
  void GetApplicationSettingsAsync(const GetApplicationSettingsRequestT& request,
                                   const GetApplicationSettingsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetApplicationSettings, request, handler, context);
  }
 
  virtual Model::GetAppsOutcome GetApps(const Model::GetAppsRequest& request = {}) const;
 
  template <typename GetAppsRequestT = Model::GetAppsRequest>
  Model::GetAppsOutcomeCallable GetAppsCallable(const GetAppsRequestT& request = {}) const {
    return SubmitCallable(&PinpointClient::GetApps, request);
  }
 
  template <typename GetAppsRequestT = Model::GetAppsRequest>
  void GetAppsAsync(const GetAppsResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                    const GetAppsRequestT& request = {}) const {
    return SubmitAsync(&PinpointClient::GetApps, request, handler, context);
  }
 
  virtual Model::GetBaiduChannelOutcome GetBaiduChannel(const Model::GetBaiduChannelRequest& request) const;
 
  template <typename GetBaiduChannelRequestT = Model::GetBaiduChannelRequest>
  Model::GetBaiduChannelOutcomeCallable GetBaiduChannelCallable(const GetBaiduChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetBaiduChannel, request);
  }
 
  template <typename GetBaiduChannelRequestT = Model::GetBaiduChannelRequest>
  void GetBaiduChannelAsync(const GetBaiduChannelRequestT& request, const GetBaiduChannelResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetBaiduChannel, request, handler, context);
  }
 
  virtual Model::GetCampaignOutcome GetCampaign(const Model::GetCampaignRequest& request) const;
 
  template <typename GetCampaignRequestT = Model::GetCampaignRequest>
  Model::GetCampaignOutcomeCallable GetCampaignCallable(const GetCampaignRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetCampaign, request);
  }
 
  template <typename GetCampaignRequestT = Model::GetCampaignRequest>
  void GetCampaignAsync(const GetCampaignRequestT& request, const GetCampaignResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetCampaign, request, handler, context);
  }
 
  virtual Model::GetCampaignActivitiesOutcome GetCampaignActivities(const Model::GetCampaignActivitiesRequest& request) const;
 
  template <typename GetCampaignActivitiesRequestT = Model::GetCampaignActivitiesRequest>
  Model::GetCampaignActivitiesOutcomeCallable GetCampaignActivitiesCallable(const GetCampaignActivitiesRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetCampaignActivities, request);
  }
 
  template <typename GetCampaignActivitiesRequestT = Model::GetCampaignActivitiesRequest>
  void GetCampaignActivitiesAsync(const GetCampaignActivitiesRequestT& request, const GetCampaignActivitiesResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetCampaignActivities, request, handler, context);
  }
 
  virtual Model::GetCampaignDateRangeKpiOutcome GetCampaignDateRangeKpi(const Model::GetCampaignDateRangeKpiRequest& request) const;
 
  template <typename GetCampaignDateRangeKpiRequestT = Model::GetCampaignDateRangeKpiRequest>
  Model::GetCampaignDateRangeKpiOutcomeCallable GetCampaignDateRangeKpiCallable(const GetCampaignDateRangeKpiRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetCampaignDateRangeKpi, request);
  }
 
  template <typename GetCampaignDateRangeKpiRequestT = Model::GetCampaignDateRangeKpiRequest>
  void GetCampaignDateRangeKpiAsync(const GetCampaignDateRangeKpiRequestT& request,
                                    const GetCampaignDateRangeKpiResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetCampaignDateRangeKpi, request, handler, context);
  }
 
  virtual Model::GetCampaignVersionOutcome GetCampaignVersion(const Model::GetCampaignVersionRequest& request) const;
 
  template <typename GetCampaignVersionRequestT = Model::GetCampaignVersionRequest>
  Model::GetCampaignVersionOutcomeCallable GetCampaignVersionCallable(const GetCampaignVersionRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetCampaignVersion, request);
  }
 
  template <typename GetCampaignVersionRequestT = Model::GetCampaignVersionRequest>
  void GetCampaignVersionAsync(const GetCampaignVersionRequestT& request, const GetCampaignVersionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetCampaignVersion, request, handler, context);
  }
 
  virtual Model::GetCampaignVersionsOutcome GetCampaignVersions(const Model::GetCampaignVersionsRequest& request) const;
 
  template <typename GetCampaignVersionsRequestT = Model::GetCampaignVersionsRequest>
  Model::GetCampaignVersionsOutcomeCallable GetCampaignVersionsCallable(const GetCampaignVersionsRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetCampaignVersions, request);
  }
 
  template <typename GetCampaignVersionsRequestT = Model::GetCampaignVersionsRequest>
  void GetCampaignVersionsAsync(const GetCampaignVersionsRequestT& request, const GetCampaignVersionsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetCampaignVersions, request, handler, context);
  }
 
  virtual Model::GetCampaignsOutcome GetCampaigns(const Model::GetCampaignsRequest& request) const;
 
  template <typename GetCampaignsRequestT = Model::GetCampaignsRequest>
  Model::GetCampaignsOutcomeCallable GetCampaignsCallable(const GetCampaignsRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetCampaigns, request);
  }
 
  template <typename GetCampaignsRequestT = Model::GetCampaignsRequest>
  void GetCampaignsAsync(const GetCampaignsRequestT& request, const GetCampaignsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetCampaigns, request, handler, context);
  }
 
  virtual Model::GetChannelsOutcome GetChannels(const Model::GetChannelsRequest& request) const;
 
  template <typename GetChannelsRequestT = Model::GetChannelsRequest>
  Model::GetChannelsOutcomeCallable GetChannelsCallable(const GetChannelsRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetChannels, request);
  }
 
  template <typename GetChannelsRequestT = Model::GetChannelsRequest>
  void GetChannelsAsync(const GetChannelsRequestT& request, const GetChannelsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetChannels, request, handler, context);
  }
 
  virtual Model::GetEmailChannelOutcome GetEmailChannel(const Model::GetEmailChannelRequest& request) const;
 
  template <typename GetEmailChannelRequestT = Model::GetEmailChannelRequest>
  Model::GetEmailChannelOutcomeCallable GetEmailChannelCallable(const GetEmailChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetEmailChannel, request);
  }
 
  template <typename GetEmailChannelRequestT = Model::GetEmailChannelRequest>
  void GetEmailChannelAsync(const GetEmailChannelRequestT& request, const GetEmailChannelResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetEmailChannel, request, handler, context);
  }
 
  virtual Model::GetEmailTemplateOutcome GetEmailTemplate(const Model::GetEmailTemplateRequest& request) const;
 
  template <typename GetEmailTemplateRequestT = Model::GetEmailTemplateRequest>
  Model::GetEmailTemplateOutcomeCallable GetEmailTemplateCallable(const GetEmailTemplateRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetEmailTemplate, request);
  }
 
  template <typename GetEmailTemplateRequestT = Model::GetEmailTemplateRequest>
  void GetEmailTemplateAsync(const GetEmailTemplateRequestT& request, const GetEmailTemplateResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetEmailTemplate, request, handler, context);
  }
 
  virtual Model::GetEndpointOutcome GetEndpoint(const Model::GetEndpointRequest& request) const;
 
  template <typename GetEndpointRequestT = Model::GetEndpointRequest>
  Model::GetEndpointOutcomeCallable GetEndpointCallable(const GetEndpointRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetEndpoint, request);
  }
 
  template <typename GetEndpointRequestT = Model::GetEndpointRequest>
  void GetEndpointAsync(const GetEndpointRequestT& request, const GetEndpointResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetEndpoint, request, handler, context);
  }
 
  virtual Model::GetEventStreamOutcome GetEventStream(const Model::GetEventStreamRequest& request) const;
 
  template <typename GetEventStreamRequestT = Model::GetEventStreamRequest>
  Model::GetEventStreamOutcomeCallable GetEventStreamCallable(const GetEventStreamRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetEventStream, request);
  }
 
  template <typename GetEventStreamRequestT = Model::GetEventStreamRequest>
  void GetEventStreamAsync(const GetEventStreamRequestT& request, const GetEventStreamResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetEventStream, request, handler, context);
  }
 
  virtual Model::GetExportJobOutcome GetExportJob(const Model::GetExportJobRequest& request) const;
 
  template <typename GetExportJobRequestT = Model::GetExportJobRequest>
  Model::GetExportJobOutcomeCallable GetExportJobCallable(const GetExportJobRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetExportJob, request);
  }
 
  template <typename GetExportJobRequestT = Model::GetExportJobRequest>
  void GetExportJobAsync(const GetExportJobRequestT& request, const GetExportJobResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetExportJob, request, handler, context);
  }
 
  virtual Model::GetExportJobsOutcome GetExportJobs(const Model::GetExportJobsRequest& request) const;
 
  template <typename GetExportJobsRequestT = Model::GetExportJobsRequest>
  Model::GetExportJobsOutcomeCallable GetExportJobsCallable(const GetExportJobsRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetExportJobs, request);
  }
 
  template <typename GetExportJobsRequestT = Model::GetExportJobsRequest>
  void GetExportJobsAsync(const GetExportJobsRequestT& request, const GetExportJobsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetExportJobs, request, handler, context);
  }
 
  virtual Model::GetGcmChannelOutcome GetGcmChannel(const Model::GetGcmChannelRequest& request) const;
 
  template <typename GetGcmChannelRequestT = Model::GetGcmChannelRequest>
  Model::GetGcmChannelOutcomeCallable GetGcmChannelCallable(const GetGcmChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetGcmChannel, request);
  }
 
  template <typename GetGcmChannelRequestT = Model::GetGcmChannelRequest>
  void GetGcmChannelAsync(const GetGcmChannelRequestT& request, const GetGcmChannelResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetGcmChannel, request, handler, context);
  }
 
  virtual Model::GetImportJobOutcome GetImportJob(const Model::GetImportJobRequest& request) const;
 
  template <typename GetImportJobRequestT = Model::GetImportJobRequest>
  Model::GetImportJobOutcomeCallable GetImportJobCallable(const GetImportJobRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetImportJob, request);
  }
 
  template <typename GetImportJobRequestT = Model::GetImportJobRequest>
  void GetImportJobAsync(const GetImportJobRequestT& request, const GetImportJobResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetImportJob, request, handler, context);
  }
 
  virtual Model::GetImportJobsOutcome GetImportJobs(const Model::GetImportJobsRequest& request) const;
 
  template <typename GetImportJobsRequestT = Model::GetImportJobsRequest>
  Model::GetImportJobsOutcomeCallable GetImportJobsCallable(const GetImportJobsRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetImportJobs, request);
  }
 
  template <typename GetImportJobsRequestT = Model::GetImportJobsRequest>
  void GetImportJobsAsync(const GetImportJobsRequestT& request, const GetImportJobsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetImportJobs, request, handler, context);
  }
 
  virtual Model::GetInAppMessagesOutcome GetInAppMessages(const Model::GetInAppMessagesRequest& request) const;
 
  template <typename GetInAppMessagesRequestT = Model::GetInAppMessagesRequest>
  Model::GetInAppMessagesOutcomeCallable GetInAppMessagesCallable(const GetInAppMessagesRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetInAppMessages, request);
  }
 
  template <typename GetInAppMessagesRequestT = Model::GetInAppMessagesRequest>
  void GetInAppMessagesAsync(const GetInAppMessagesRequestT& request, const GetInAppMessagesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetInAppMessages, request, handler, context);
  }
 
  virtual Model::GetInAppTemplateOutcome GetInAppTemplate(const Model::GetInAppTemplateRequest& request) const;
 
  template <typename GetInAppTemplateRequestT = Model::GetInAppTemplateRequest>
  Model::GetInAppTemplateOutcomeCallable GetInAppTemplateCallable(const GetInAppTemplateRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetInAppTemplate, request);
  }
 
  template <typename GetInAppTemplateRequestT = Model::GetInAppTemplateRequest>
  void GetInAppTemplateAsync(const GetInAppTemplateRequestT& request, const GetInAppTemplateResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetInAppTemplate, request, handler, context);
  }
 
  virtual Model::GetJourneyOutcome GetJourney(const Model::GetJourneyRequest& request) const;
 
  template <typename GetJourneyRequestT = Model::GetJourneyRequest>
  Model::GetJourneyOutcomeCallable GetJourneyCallable(const GetJourneyRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetJourney, request);
  }
 
  template <typename GetJourneyRequestT = Model::GetJourneyRequest>
  void GetJourneyAsync(const GetJourneyRequestT& request, const GetJourneyResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetJourney, request, handler, context);
  }
 
  virtual Model::GetJourneyDateRangeKpiOutcome GetJourneyDateRangeKpi(const Model::GetJourneyDateRangeKpiRequest& request) const;
 
  template <typename GetJourneyDateRangeKpiRequestT = Model::GetJourneyDateRangeKpiRequest>
  Model::GetJourneyDateRangeKpiOutcomeCallable GetJourneyDateRangeKpiCallable(const GetJourneyDateRangeKpiRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetJourneyDateRangeKpi, request);
  }
 
  template <typename GetJourneyDateRangeKpiRequestT = Model::GetJourneyDateRangeKpiRequest>
  void GetJourneyDateRangeKpiAsync(const GetJourneyDateRangeKpiRequestT& request,
                                   const GetJourneyDateRangeKpiResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetJourneyDateRangeKpi, request, handler, context);
  }
 
  virtual Model::GetJourneyExecutionActivityMetricsOutcome GetJourneyExecutionActivityMetrics(
      const Model::GetJourneyExecutionActivityMetricsRequest& request) const;
 
  template <typename GetJourneyExecutionActivityMetricsRequestT = Model::GetJourneyExecutionActivityMetricsRequest>
  Model::GetJourneyExecutionActivityMetricsOutcomeCallable GetJourneyExecutionActivityMetricsCallable(
      const GetJourneyExecutionActivityMetricsRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetJourneyExecutionActivityMetrics, request);
  }
 
  template <typename GetJourneyExecutionActivityMetricsRequestT = Model::GetJourneyExecutionActivityMetricsRequest>
  void GetJourneyExecutionActivityMetricsAsync(const GetJourneyExecutionActivityMetricsRequestT& request,
                                               const GetJourneyExecutionActivityMetricsResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetJourneyExecutionActivityMetrics, request, handler, context);
  }
 
  virtual Model::GetJourneyExecutionMetricsOutcome GetJourneyExecutionMetrics(
      const Model::GetJourneyExecutionMetricsRequest& request) const;
 
  template <typename GetJourneyExecutionMetricsRequestT = Model::GetJourneyExecutionMetricsRequest>
  Model::GetJourneyExecutionMetricsOutcomeCallable GetJourneyExecutionMetricsCallable(
      const GetJourneyExecutionMetricsRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetJourneyExecutionMetrics, request);
  }
 
  template <typename GetJourneyExecutionMetricsRequestT = Model::GetJourneyExecutionMetricsRequest>
  void GetJourneyExecutionMetricsAsync(const GetJourneyExecutionMetricsRequestT& request,
                                       const GetJourneyExecutionMetricsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetJourneyExecutionMetrics, request, handler, context);
  }
 
  virtual Model::GetJourneyRunExecutionActivityMetricsOutcome GetJourneyRunExecutionActivityMetrics(
      const Model::GetJourneyRunExecutionActivityMetricsRequest& request) const;
 
  template <typename GetJourneyRunExecutionActivityMetricsRequestT = Model::GetJourneyRunExecutionActivityMetricsRequest>
  Model::GetJourneyRunExecutionActivityMetricsOutcomeCallable GetJourneyRunExecutionActivityMetricsCallable(
      const GetJourneyRunExecutionActivityMetricsRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetJourneyRunExecutionActivityMetrics, request);
  }
 
  template <typename GetJourneyRunExecutionActivityMetricsRequestT = Model::GetJourneyRunExecutionActivityMetricsRequest>
  void GetJourneyRunExecutionActivityMetricsAsync(const GetJourneyRunExecutionActivityMetricsRequestT& request,
                                                  const GetJourneyRunExecutionActivityMetricsResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetJourneyRunExecutionActivityMetrics, request, handler, context);
  }
 
  virtual Model::GetJourneyRunExecutionMetricsOutcome GetJourneyRunExecutionMetrics(
      const Model::GetJourneyRunExecutionMetricsRequest& request) const;
 
  template <typename GetJourneyRunExecutionMetricsRequestT = Model::GetJourneyRunExecutionMetricsRequest>
  Model::GetJourneyRunExecutionMetricsOutcomeCallable GetJourneyRunExecutionMetricsCallable(
      const GetJourneyRunExecutionMetricsRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetJourneyRunExecutionMetrics, request);
  }
 
  template <typename GetJourneyRunExecutionMetricsRequestT = Model::GetJourneyRunExecutionMetricsRequest>
  void GetJourneyRunExecutionMetricsAsync(const GetJourneyRunExecutionMetricsRequestT& request,
                                          const GetJourneyRunExecutionMetricsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetJourneyRunExecutionMetrics, request, handler, context);
  }
 
  virtual Model::GetJourneyRunsOutcome GetJourneyRuns(const Model::GetJourneyRunsRequest& request) const;
 
  template <typename GetJourneyRunsRequestT = Model::GetJourneyRunsRequest>
  Model::GetJourneyRunsOutcomeCallable GetJourneyRunsCallable(const GetJourneyRunsRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetJourneyRuns, request);
  }
 
  template <typename GetJourneyRunsRequestT = Model::GetJourneyRunsRequest>
  void GetJourneyRunsAsync(const GetJourneyRunsRequestT& request, const GetJourneyRunsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetJourneyRuns, request, handler, context);
  }
 
  virtual Model::GetPushTemplateOutcome GetPushTemplate(const Model::GetPushTemplateRequest& request) const;
 
  template <typename GetPushTemplateRequestT = Model::GetPushTemplateRequest>
  Model::GetPushTemplateOutcomeCallable GetPushTemplateCallable(const GetPushTemplateRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetPushTemplate, request);
  }
 
  template <typename GetPushTemplateRequestT = Model::GetPushTemplateRequest>
  void GetPushTemplateAsync(const GetPushTemplateRequestT& request, const GetPushTemplateResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetPushTemplate, request, handler, context);
  }
 
  virtual Model::GetRecommenderConfigurationOutcome GetRecommenderConfiguration(
      const Model::GetRecommenderConfigurationRequest& request) const;
 
  template <typename GetRecommenderConfigurationRequestT = Model::GetRecommenderConfigurationRequest>
  Model::GetRecommenderConfigurationOutcomeCallable GetRecommenderConfigurationCallable(
      const GetRecommenderConfigurationRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetRecommenderConfiguration, request);
  }
 
  template <typename GetRecommenderConfigurationRequestT = Model::GetRecommenderConfigurationRequest>
  void GetRecommenderConfigurationAsync(const GetRecommenderConfigurationRequestT& request,
                                        const GetRecommenderConfigurationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetRecommenderConfiguration, request, handler, context);
  }
 
  virtual Model::GetRecommenderConfigurationsOutcome GetRecommenderConfigurations(
      const Model::GetRecommenderConfigurationsRequest& request = {}) const;
 
  template <typename GetRecommenderConfigurationsRequestT = Model::GetRecommenderConfigurationsRequest>
  Model::GetRecommenderConfigurationsOutcomeCallable GetRecommenderConfigurationsCallable(
      const GetRecommenderConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&PinpointClient::GetRecommenderConfigurations, request);
  }
 
  template <typename GetRecommenderConfigurationsRequestT = Model::GetRecommenderConfigurationsRequest>
  void GetRecommenderConfigurationsAsync(const GetRecommenderConfigurationsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const GetRecommenderConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&PinpointClient::GetRecommenderConfigurations, request, handler, context);
  }
 
  virtual Model::GetSegmentOutcome GetSegment(const Model::GetSegmentRequest& request) const;
 
  template <typename GetSegmentRequestT = Model::GetSegmentRequest>
  Model::GetSegmentOutcomeCallable GetSegmentCallable(const GetSegmentRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetSegment, request);
  }
 
  template <typename GetSegmentRequestT = Model::GetSegmentRequest>
  void GetSegmentAsync(const GetSegmentRequestT& request, const GetSegmentResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetSegment, request, handler, context);
  }
 
  virtual Model::GetSegmentExportJobsOutcome GetSegmentExportJobs(const Model::GetSegmentExportJobsRequest& request) const;
 
  template <typename GetSegmentExportJobsRequestT = Model::GetSegmentExportJobsRequest>
  Model::GetSegmentExportJobsOutcomeCallable GetSegmentExportJobsCallable(const GetSegmentExportJobsRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetSegmentExportJobs, request);
  }
 
  template <typename GetSegmentExportJobsRequestT = Model::GetSegmentExportJobsRequest>
  void GetSegmentExportJobsAsync(const GetSegmentExportJobsRequestT& request, const GetSegmentExportJobsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetSegmentExportJobs, request, handler, context);
  }
 
  virtual Model::GetSegmentImportJobsOutcome GetSegmentImportJobs(const Model::GetSegmentImportJobsRequest& request) const;
 
  template <typename GetSegmentImportJobsRequestT = Model::GetSegmentImportJobsRequest>
  Model::GetSegmentImportJobsOutcomeCallable GetSegmentImportJobsCallable(const GetSegmentImportJobsRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetSegmentImportJobs, request);
  }
 
  template <typename GetSegmentImportJobsRequestT = Model::GetSegmentImportJobsRequest>
  void GetSegmentImportJobsAsync(const GetSegmentImportJobsRequestT& request, const GetSegmentImportJobsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetSegmentImportJobs, request, handler, context);
  }
 
  virtual Model::GetSegmentVersionOutcome GetSegmentVersion(const Model::GetSegmentVersionRequest& request) const;
 
  template <typename GetSegmentVersionRequestT = Model::GetSegmentVersionRequest>
  Model::GetSegmentVersionOutcomeCallable GetSegmentVersionCallable(const GetSegmentVersionRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetSegmentVersion, request);
  }
 
  template <typename GetSegmentVersionRequestT = Model::GetSegmentVersionRequest>
  void GetSegmentVersionAsync(const GetSegmentVersionRequestT& request, const GetSegmentVersionResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetSegmentVersion, request, handler, context);
  }
 
  virtual Model::GetSegmentVersionsOutcome GetSegmentVersions(const Model::GetSegmentVersionsRequest& request) const;
 
  template <typename GetSegmentVersionsRequestT = Model::GetSegmentVersionsRequest>
  Model::GetSegmentVersionsOutcomeCallable GetSegmentVersionsCallable(const GetSegmentVersionsRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetSegmentVersions, request);
  }
 
  template <typename GetSegmentVersionsRequestT = Model::GetSegmentVersionsRequest>
  void GetSegmentVersionsAsync(const GetSegmentVersionsRequestT& request, const GetSegmentVersionsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetSegmentVersions, request, handler, context);
  }
 
  virtual Model::GetSegmentsOutcome GetSegments(const Model::GetSegmentsRequest& request) const;
 
  template <typename GetSegmentsRequestT = Model::GetSegmentsRequest>
  Model::GetSegmentsOutcomeCallable GetSegmentsCallable(const GetSegmentsRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetSegments, request);
  }
 
  template <typename GetSegmentsRequestT = Model::GetSegmentsRequest>
  void GetSegmentsAsync(const GetSegmentsRequestT& request, const GetSegmentsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetSegments, request, handler, context);
  }
 
  virtual Model::GetSmsChannelOutcome GetSmsChannel(const Model::GetSmsChannelRequest& request) const;
 
  template <typename GetSmsChannelRequestT = Model::GetSmsChannelRequest>
  Model::GetSmsChannelOutcomeCallable GetSmsChannelCallable(const GetSmsChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetSmsChannel, request);
  }
 
  template <typename GetSmsChannelRequestT = Model::GetSmsChannelRequest>
  void GetSmsChannelAsync(const GetSmsChannelRequestT& request, const GetSmsChannelResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetSmsChannel, request, handler, context);
  }
 
  virtual Model::GetSmsTemplateOutcome GetSmsTemplate(const Model::GetSmsTemplateRequest& request) const;
 
  template <typename GetSmsTemplateRequestT = Model::GetSmsTemplateRequest>
  Model::GetSmsTemplateOutcomeCallable GetSmsTemplateCallable(const GetSmsTemplateRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetSmsTemplate, request);
  }
 
  template <typename GetSmsTemplateRequestT = Model::GetSmsTemplateRequest>
  void GetSmsTemplateAsync(const GetSmsTemplateRequestT& request, const GetSmsTemplateResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetSmsTemplate, request, handler, context);
  }
 
  virtual Model::GetUserEndpointsOutcome GetUserEndpoints(const Model::GetUserEndpointsRequest& request) const;
 
  template <typename GetUserEndpointsRequestT = Model::GetUserEndpointsRequest>
  Model::GetUserEndpointsOutcomeCallable GetUserEndpointsCallable(const GetUserEndpointsRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetUserEndpoints, request);
  }
 
  template <typename GetUserEndpointsRequestT = Model::GetUserEndpointsRequest>
  void GetUserEndpointsAsync(const GetUserEndpointsRequestT& request, const GetUserEndpointsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetUserEndpoints, request, handler, context);
  }
 
  virtual Model::GetVoiceChannelOutcome GetVoiceChannel(const Model::GetVoiceChannelRequest& request) const;
 
  template <typename GetVoiceChannelRequestT = Model::GetVoiceChannelRequest>
  Model::GetVoiceChannelOutcomeCallable GetVoiceChannelCallable(const GetVoiceChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetVoiceChannel, request);
  }
 
  template <typename GetVoiceChannelRequestT = Model::GetVoiceChannelRequest>
  void GetVoiceChannelAsync(const GetVoiceChannelRequestT& request, const GetVoiceChannelResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetVoiceChannel, request, handler, context);
  }
 
  virtual Model::GetVoiceTemplateOutcome GetVoiceTemplate(const Model::GetVoiceTemplateRequest& request) const;
 
  template <typename GetVoiceTemplateRequestT = Model::GetVoiceTemplateRequest>
  Model::GetVoiceTemplateOutcomeCallable GetVoiceTemplateCallable(const GetVoiceTemplateRequestT& request) const {
    return SubmitCallable(&PinpointClient::GetVoiceTemplate, request);
  }
 
  template <typename GetVoiceTemplateRequestT = Model::GetVoiceTemplateRequest>
  void GetVoiceTemplateAsync(const GetVoiceTemplateRequestT& request, const GetVoiceTemplateResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::GetVoiceTemplate, request, handler, context);
  }
 
  virtual Model::ListJourneysOutcome ListJourneys(const Model::ListJourneysRequest& request) const;
 
  template <typename ListJourneysRequestT = Model::ListJourneysRequest>
  Model::ListJourneysOutcomeCallable ListJourneysCallable(const ListJourneysRequestT& request) const {
    return SubmitCallable(&PinpointClient::ListJourneys, request);
  }
 
  template <typename ListJourneysRequestT = Model::ListJourneysRequest>
  void ListJourneysAsync(const ListJourneysRequestT& request, const ListJourneysResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::ListJourneys, 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(&PinpointClient::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(&PinpointClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListTemplateVersionsOutcome ListTemplateVersions(const Model::ListTemplateVersionsRequest& request) const;
 
  template <typename ListTemplateVersionsRequestT = Model::ListTemplateVersionsRequest>
  Model::ListTemplateVersionsOutcomeCallable ListTemplateVersionsCallable(const ListTemplateVersionsRequestT& request) const {
    return SubmitCallable(&PinpointClient::ListTemplateVersions, request);
  }
 
  template <typename ListTemplateVersionsRequestT = Model::ListTemplateVersionsRequest>
  void ListTemplateVersionsAsync(const ListTemplateVersionsRequestT& request, const ListTemplateVersionsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::ListTemplateVersions, request, handler, context);
  }
 
  virtual Model::ListTemplatesOutcome ListTemplates(const Model::ListTemplatesRequest& request = {}) const;
 
  template <typename ListTemplatesRequestT = Model::ListTemplatesRequest>
  Model::ListTemplatesOutcomeCallable ListTemplatesCallable(const ListTemplatesRequestT& request = {}) const {
    return SubmitCallable(&PinpointClient::ListTemplates, request);
  }
 
  template <typename ListTemplatesRequestT = Model::ListTemplatesRequest>
  void ListTemplatesAsync(const ListTemplatesResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const ListTemplatesRequestT& request = {}) const {
    return SubmitAsync(&PinpointClient::ListTemplates, request, handler, context);
  }
 
  virtual Model::PhoneNumberValidateOutcome PhoneNumberValidate(const Model::PhoneNumberValidateRequest& request) const;
 
  template <typename PhoneNumberValidateRequestT = Model::PhoneNumberValidateRequest>
  Model::PhoneNumberValidateOutcomeCallable PhoneNumberValidateCallable(const PhoneNumberValidateRequestT& request) const {
    return SubmitCallable(&PinpointClient::PhoneNumberValidate, request);
  }
 
  template <typename PhoneNumberValidateRequestT = Model::PhoneNumberValidateRequest>
  void PhoneNumberValidateAsync(const PhoneNumberValidateRequestT& request, const PhoneNumberValidateResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::PhoneNumberValidate, request, handler, context);
  }
 
  virtual Model::PutEventStreamOutcome PutEventStream(const Model::PutEventStreamRequest& request) const;
 
  template <typename PutEventStreamRequestT = Model::PutEventStreamRequest>
  Model::PutEventStreamOutcomeCallable PutEventStreamCallable(const PutEventStreamRequestT& request) const {
    return SubmitCallable(&PinpointClient::PutEventStream, request);
  }
 
  template <typename PutEventStreamRequestT = Model::PutEventStreamRequest>
  void PutEventStreamAsync(const PutEventStreamRequestT& request, const PutEventStreamResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::PutEventStream, request, handler, context);
  }
 
  virtual Model::PutEventsOutcome PutEvents(const Model::PutEventsRequest& request) const;
 
  template <typename PutEventsRequestT = Model::PutEventsRequest>
  Model::PutEventsOutcomeCallable PutEventsCallable(const PutEventsRequestT& request) const {
    return SubmitCallable(&PinpointClient::PutEvents, request);
  }
 
  template <typename PutEventsRequestT = Model::PutEventsRequest>
  void PutEventsAsync(const PutEventsRequestT& request, const PutEventsResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::PutEvents, request, handler, context);
  }
 
  virtual Model::RemoveAttributesOutcome RemoveAttributes(const Model::RemoveAttributesRequest& request) const;
 
  template <typename RemoveAttributesRequestT = Model::RemoveAttributesRequest>
  Model::RemoveAttributesOutcomeCallable RemoveAttributesCallable(const RemoveAttributesRequestT& request) const {
    return SubmitCallable(&PinpointClient::RemoveAttributes, request);
  }
 
  template <typename RemoveAttributesRequestT = Model::RemoveAttributesRequest>
  void RemoveAttributesAsync(const RemoveAttributesRequestT& request, const RemoveAttributesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::RemoveAttributes, request, handler, context);
  }
 
  virtual Model::SendMessagesOutcome SendMessages(const Model::SendMessagesRequest& request) const;
 
  template <typename SendMessagesRequestT = Model::SendMessagesRequest>
  Model::SendMessagesOutcomeCallable SendMessagesCallable(const SendMessagesRequestT& request) const {
    return SubmitCallable(&PinpointClient::SendMessages, request);
  }
 
  template <typename SendMessagesRequestT = Model::SendMessagesRequest>
  void SendMessagesAsync(const SendMessagesRequestT& request, const SendMessagesResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::SendMessages, request, handler, context);
  }
 
  virtual Model::SendOTPMessageOutcome SendOTPMessage(const Model::SendOTPMessageRequest& request) const;
 
  template <typename SendOTPMessageRequestT = Model::SendOTPMessageRequest>
  Model::SendOTPMessageOutcomeCallable SendOTPMessageCallable(const SendOTPMessageRequestT& request) const {
    return SubmitCallable(&PinpointClient::SendOTPMessage, request);
  }
 
  template <typename SendOTPMessageRequestT = Model::SendOTPMessageRequest>
  void SendOTPMessageAsync(const SendOTPMessageRequestT& request, const SendOTPMessageResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::SendOTPMessage, request, handler, context);
  }
 
  virtual Model::SendUsersMessagesOutcome SendUsersMessages(const Model::SendUsersMessagesRequest& request) const;
 
  template <typename SendUsersMessagesRequestT = Model::SendUsersMessagesRequest>
  Model::SendUsersMessagesOutcomeCallable SendUsersMessagesCallable(const SendUsersMessagesRequestT& request) const {
    return SubmitCallable(&PinpointClient::SendUsersMessages, request);
  }
 
  template <typename SendUsersMessagesRequestT = Model::SendUsersMessagesRequest>
  void SendUsersMessagesAsync(const SendUsersMessagesRequestT& request, const SendUsersMessagesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::SendUsersMessages, 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(&PinpointClient::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(&PinpointClient::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(&PinpointClient::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(&PinpointClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateAdmChannelOutcome UpdateAdmChannel(const Model::UpdateAdmChannelRequest& request) const;
 
  template <typename UpdateAdmChannelRequestT = Model::UpdateAdmChannelRequest>
  Model::UpdateAdmChannelOutcomeCallable UpdateAdmChannelCallable(const UpdateAdmChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::UpdateAdmChannel, request);
  }
 
  template <typename UpdateAdmChannelRequestT = Model::UpdateAdmChannelRequest>
  void UpdateAdmChannelAsync(const UpdateAdmChannelRequestT& request, const UpdateAdmChannelResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::UpdateAdmChannel, request, handler, context);
  }
 
  virtual Model::UpdateApnsChannelOutcome UpdateApnsChannel(const Model::UpdateApnsChannelRequest& request) const;
 
  template <typename UpdateApnsChannelRequestT = Model::UpdateApnsChannelRequest>
  Model::UpdateApnsChannelOutcomeCallable UpdateApnsChannelCallable(const UpdateApnsChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::UpdateApnsChannel, request);
  }
 
  template <typename UpdateApnsChannelRequestT = Model::UpdateApnsChannelRequest>
  void UpdateApnsChannelAsync(const UpdateApnsChannelRequestT& request, const UpdateApnsChannelResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::UpdateApnsChannel, request, handler, context);
  }
 
  virtual Model::UpdateApnsSandboxChannelOutcome UpdateApnsSandboxChannel(const Model::UpdateApnsSandboxChannelRequest& request) const;
 
  template <typename UpdateApnsSandboxChannelRequestT = Model::UpdateApnsSandboxChannelRequest>
  Model::UpdateApnsSandboxChannelOutcomeCallable UpdateApnsSandboxChannelCallable(const UpdateApnsSandboxChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::UpdateApnsSandboxChannel, request);
  }
 
  template <typename UpdateApnsSandboxChannelRequestT = Model::UpdateApnsSandboxChannelRequest>
  void UpdateApnsSandboxChannelAsync(const UpdateApnsSandboxChannelRequestT& request,
                                     const UpdateApnsSandboxChannelResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::UpdateApnsSandboxChannel, request, handler, context);
  }
 
  virtual Model::UpdateApnsVoipChannelOutcome UpdateApnsVoipChannel(const Model::UpdateApnsVoipChannelRequest& request) const;
 
  template <typename UpdateApnsVoipChannelRequestT = Model::UpdateApnsVoipChannelRequest>
  Model::UpdateApnsVoipChannelOutcomeCallable UpdateApnsVoipChannelCallable(const UpdateApnsVoipChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::UpdateApnsVoipChannel, request);
  }
 
  template <typename UpdateApnsVoipChannelRequestT = Model::UpdateApnsVoipChannelRequest>
  void UpdateApnsVoipChannelAsync(const UpdateApnsVoipChannelRequestT& request, const UpdateApnsVoipChannelResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::UpdateApnsVoipChannel, request, handler, context);
  }
 
  virtual Model::UpdateApnsVoipSandboxChannelOutcome UpdateApnsVoipSandboxChannel(
      const Model::UpdateApnsVoipSandboxChannelRequest& request) const;
 
  template <typename UpdateApnsVoipSandboxChannelRequestT = Model::UpdateApnsVoipSandboxChannelRequest>
  Model::UpdateApnsVoipSandboxChannelOutcomeCallable UpdateApnsVoipSandboxChannelCallable(
      const UpdateApnsVoipSandboxChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::UpdateApnsVoipSandboxChannel, request);
  }
 
  template <typename UpdateApnsVoipSandboxChannelRequestT = Model::UpdateApnsVoipSandboxChannelRequest>
  void UpdateApnsVoipSandboxChannelAsync(const UpdateApnsVoipSandboxChannelRequestT& request,
                                         const UpdateApnsVoipSandboxChannelResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::UpdateApnsVoipSandboxChannel, request, handler, context);
  }
 
  virtual Model::UpdateApplicationSettingsOutcome UpdateApplicationSettings(const Model::UpdateApplicationSettingsRequest& request) const;
 
  template <typename UpdateApplicationSettingsRequestT = Model::UpdateApplicationSettingsRequest>
  Model::UpdateApplicationSettingsOutcomeCallable UpdateApplicationSettingsCallable(
      const UpdateApplicationSettingsRequestT& request) const {
    return SubmitCallable(&PinpointClient::UpdateApplicationSettings, request);
  }
 
  template <typename UpdateApplicationSettingsRequestT = Model::UpdateApplicationSettingsRequest>
  void UpdateApplicationSettingsAsync(const UpdateApplicationSettingsRequestT& request,
                                      const UpdateApplicationSettingsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::UpdateApplicationSettings, request, handler, context);
  }
 
  virtual Model::UpdateBaiduChannelOutcome UpdateBaiduChannel(const Model::UpdateBaiduChannelRequest& request) const;
 
  template <typename UpdateBaiduChannelRequestT = Model::UpdateBaiduChannelRequest>
  Model::UpdateBaiduChannelOutcomeCallable UpdateBaiduChannelCallable(const UpdateBaiduChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::UpdateBaiduChannel, request);
  }
 
  template <typename UpdateBaiduChannelRequestT = Model::UpdateBaiduChannelRequest>
  void UpdateBaiduChannelAsync(const UpdateBaiduChannelRequestT& request, const UpdateBaiduChannelResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::UpdateBaiduChannel, request, handler, context);
  }
 
  virtual Model::UpdateCampaignOutcome UpdateCampaign(const Model::UpdateCampaignRequest& request) const;
 
  template <typename UpdateCampaignRequestT = Model::UpdateCampaignRequest>
  Model::UpdateCampaignOutcomeCallable UpdateCampaignCallable(const UpdateCampaignRequestT& request) const {
    return SubmitCallable(&PinpointClient::UpdateCampaign, request);
  }
 
  template <typename UpdateCampaignRequestT = Model::UpdateCampaignRequest>
  void UpdateCampaignAsync(const UpdateCampaignRequestT& request, const UpdateCampaignResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::UpdateCampaign, request, handler, context);
  }
 
  virtual Model::UpdateEmailChannelOutcome UpdateEmailChannel(const Model::UpdateEmailChannelRequest& request) const;
 
  template <typename UpdateEmailChannelRequestT = Model::UpdateEmailChannelRequest>
  Model::UpdateEmailChannelOutcomeCallable UpdateEmailChannelCallable(const UpdateEmailChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::UpdateEmailChannel, request);
  }
 
  template <typename UpdateEmailChannelRequestT = Model::UpdateEmailChannelRequest>
  void UpdateEmailChannelAsync(const UpdateEmailChannelRequestT& request, const UpdateEmailChannelResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::UpdateEmailChannel, request, handler, context);
  }
 
  virtual Model::UpdateEmailTemplateOutcome UpdateEmailTemplate(const Model::UpdateEmailTemplateRequest& request) const;
 
  template <typename UpdateEmailTemplateRequestT = Model::UpdateEmailTemplateRequest>
  Model::UpdateEmailTemplateOutcomeCallable UpdateEmailTemplateCallable(const UpdateEmailTemplateRequestT& request) const {
    return SubmitCallable(&PinpointClient::UpdateEmailTemplate, request);
  }
 
  template <typename UpdateEmailTemplateRequestT = Model::UpdateEmailTemplateRequest>
  void UpdateEmailTemplateAsync(const UpdateEmailTemplateRequestT& request, const UpdateEmailTemplateResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::UpdateEmailTemplate, request, handler, context);
  }
 
  virtual Model::UpdateEndpointOutcome UpdateEndpoint(const Model::UpdateEndpointRequest& request) const;
 
  template <typename UpdateEndpointRequestT = Model::UpdateEndpointRequest>
  Model::UpdateEndpointOutcomeCallable UpdateEndpointCallable(const UpdateEndpointRequestT& request) const {
    return SubmitCallable(&PinpointClient::UpdateEndpoint, request);
  }
 
  template <typename UpdateEndpointRequestT = Model::UpdateEndpointRequest>
  void UpdateEndpointAsync(const UpdateEndpointRequestT& request, const UpdateEndpointResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::UpdateEndpoint, request, handler, context);
  }
 
  virtual Model::UpdateEndpointsBatchOutcome UpdateEndpointsBatch(const Model::UpdateEndpointsBatchRequest& request) const;
 
  template <typename UpdateEndpointsBatchRequestT = Model::UpdateEndpointsBatchRequest>
  Model::UpdateEndpointsBatchOutcomeCallable UpdateEndpointsBatchCallable(const UpdateEndpointsBatchRequestT& request) const {
    return SubmitCallable(&PinpointClient::UpdateEndpointsBatch, request);
  }
 
  template <typename UpdateEndpointsBatchRequestT = Model::UpdateEndpointsBatchRequest>
  void UpdateEndpointsBatchAsync(const UpdateEndpointsBatchRequestT& request, const UpdateEndpointsBatchResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::UpdateEndpointsBatch, request, handler, context);
  }
 
  virtual Model::UpdateGcmChannelOutcome UpdateGcmChannel(const Model::UpdateGcmChannelRequest& request) const;
 
  template <typename UpdateGcmChannelRequestT = Model::UpdateGcmChannelRequest>
  Model::UpdateGcmChannelOutcomeCallable UpdateGcmChannelCallable(const UpdateGcmChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::UpdateGcmChannel, request);
  }
 
  template <typename UpdateGcmChannelRequestT = Model::UpdateGcmChannelRequest>
  void UpdateGcmChannelAsync(const UpdateGcmChannelRequestT& request, const UpdateGcmChannelResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::UpdateGcmChannel, request, handler, context);
  }
 
  virtual Model::UpdateInAppTemplateOutcome UpdateInAppTemplate(const Model::UpdateInAppTemplateRequest& request) const;
 
  template <typename UpdateInAppTemplateRequestT = Model::UpdateInAppTemplateRequest>
  Model::UpdateInAppTemplateOutcomeCallable UpdateInAppTemplateCallable(const UpdateInAppTemplateRequestT& request) const {
    return SubmitCallable(&PinpointClient::UpdateInAppTemplate, request);
  }
 
  template <typename UpdateInAppTemplateRequestT = Model::UpdateInAppTemplateRequest>
  void UpdateInAppTemplateAsync(const UpdateInAppTemplateRequestT& request, const UpdateInAppTemplateResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::UpdateInAppTemplate, request, handler, context);
  }
 
  virtual Model::UpdateJourneyOutcome UpdateJourney(const Model::UpdateJourneyRequest& request) const;
 
  template <typename UpdateJourneyRequestT = Model::UpdateJourneyRequest>
  Model::UpdateJourneyOutcomeCallable UpdateJourneyCallable(const UpdateJourneyRequestT& request) const {
    return SubmitCallable(&PinpointClient::UpdateJourney, request);
  }
 
  template <typename UpdateJourneyRequestT = Model::UpdateJourneyRequest>
  void UpdateJourneyAsync(const UpdateJourneyRequestT& request, const UpdateJourneyResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::UpdateJourney, request, handler, context);
  }
 
  virtual Model::UpdateJourneyStateOutcome UpdateJourneyState(const Model::UpdateJourneyStateRequest& request) const;
 
  template <typename UpdateJourneyStateRequestT = Model::UpdateJourneyStateRequest>
  Model::UpdateJourneyStateOutcomeCallable UpdateJourneyStateCallable(const UpdateJourneyStateRequestT& request) const {
    return SubmitCallable(&PinpointClient::UpdateJourneyState, request);
  }
 
  template <typename UpdateJourneyStateRequestT = Model::UpdateJourneyStateRequest>
  void UpdateJourneyStateAsync(const UpdateJourneyStateRequestT& request, const UpdateJourneyStateResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::UpdateJourneyState, request, handler, context);
  }
 
  virtual Model::UpdatePushTemplateOutcome UpdatePushTemplate(const Model::UpdatePushTemplateRequest& request) const;
 
  template <typename UpdatePushTemplateRequestT = Model::UpdatePushTemplateRequest>
  Model::UpdatePushTemplateOutcomeCallable UpdatePushTemplateCallable(const UpdatePushTemplateRequestT& request) const {
    return SubmitCallable(&PinpointClient::UpdatePushTemplate, request);
  }
 
  template <typename UpdatePushTemplateRequestT = Model::UpdatePushTemplateRequest>
  void UpdatePushTemplateAsync(const UpdatePushTemplateRequestT& request, const UpdatePushTemplateResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::UpdatePushTemplate, request, handler, context);
  }
 
  virtual Model::UpdateRecommenderConfigurationOutcome UpdateRecommenderConfiguration(
      const Model::UpdateRecommenderConfigurationRequest& request) const;
 
  template <typename UpdateRecommenderConfigurationRequestT = Model::UpdateRecommenderConfigurationRequest>
  Model::UpdateRecommenderConfigurationOutcomeCallable UpdateRecommenderConfigurationCallable(
      const UpdateRecommenderConfigurationRequestT& request) const {
    return SubmitCallable(&PinpointClient::UpdateRecommenderConfiguration, request);
  }
 
  template <typename UpdateRecommenderConfigurationRequestT = Model::UpdateRecommenderConfigurationRequest>
  void UpdateRecommenderConfigurationAsync(const UpdateRecommenderConfigurationRequestT& request,
                                           const UpdateRecommenderConfigurationResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::UpdateRecommenderConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateSegmentOutcome UpdateSegment(const Model::UpdateSegmentRequest& request) const;
 
  template <typename UpdateSegmentRequestT = Model::UpdateSegmentRequest>
  Model::UpdateSegmentOutcomeCallable UpdateSegmentCallable(const UpdateSegmentRequestT& request) const {
    return SubmitCallable(&PinpointClient::UpdateSegment, request);
  }
 
  template <typename UpdateSegmentRequestT = Model::UpdateSegmentRequest>
  void UpdateSegmentAsync(const UpdateSegmentRequestT& request, const UpdateSegmentResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::UpdateSegment, request, handler, context);
  }
 
  virtual Model::UpdateSmsChannelOutcome UpdateSmsChannel(const Model::UpdateSmsChannelRequest& request) const;
 
  template <typename UpdateSmsChannelRequestT = Model::UpdateSmsChannelRequest>
  Model::UpdateSmsChannelOutcomeCallable UpdateSmsChannelCallable(const UpdateSmsChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::UpdateSmsChannel, request);
  }
 
  template <typename UpdateSmsChannelRequestT = Model::UpdateSmsChannelRequest>
  void UpdateSmsChannelAsync(const UpdateSmsChannelRequestT& request, const UpdateSmsChannelResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::UpdateSmsChannel, request, handler, context);
  }
 
  virtual Model::UpdateSmsTemplateOutcome UpdateSmsTemplate(const Model::UpdateSmsTemplateRequest& request) const;
 
  template <typename UpdateSmsTemplateRequestT = Model::UpdateSmsTemplateRequest>
  Model::UpdateSmsTemplateOutcomeCallable UpdateSmsTemplateCallable(const UpdateSmsTemplateRequestT& request) const {
    return SubmitCallable(&PinpointClient::UpdateSmsTemplate, request);
  }
 
  template <typename UpdateSmsTemplateRequestT = Model::UpdateSmsTemplateRequest>
  void UpdateSmsTemplateAsync(const UpdateSmsTemplateRequestT& request, const UpdateSmsTemplateResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::UpdateSmsTemplate, request, handler, context);
  }
 
  virtual Model::UpdateTemplateActiveVersionOutcome UpdateTemplateActiveVersion(
      const Model::UpdateTemplateActiveVersionRequest& request) const;
 
  template <typename UpdateTemplateActiveVersionRequestT = Model::UpdateTemplateActiveVersionRequest>
  Model::UpdateTemplateActiveVersionOutcomeCallable UpdateTemplateActiveVersionCallable(
      const UpdateTemplateActiveVersionRequestT& request) const {
    return SubmitCallable(&PinpointClient::UpdateTemplateActiveVersion, request);
  }
 
  template <typename UpdateTemplateActiveVersionRequestT = Model::UpdateTemplateActiveVersionRequest>
  void UpdateTemplateActiveVersionAsync(const UpdateTemplateActiveVersionRequestT& request,
                                        const UpdateTemplateActiveVersionResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::UpdateTemplateActiveVersion, request, handler, context);
  }
 
  virtual Model::UpdateVoiceChannelOutcome UpdateVoiceChannel(const Model::UpdateVoiceChannelRequest& request) const;
 
  template <typename UpdateVoiceChannelRequestT = Model::UpdateVoiceChannelRequest>
  Model::UpdateVoiceChannelOutcomeCallable UpdateVoiceChannelCallable(const UpdateVoiceChannelRequestT& request) const {
    return SubmitCallable(&PinpointClient::UpdateVoiceChannel, request);
  }
 
  template <typename UpdateVoiceChannelRequestT = Model::UpdateVoiceChannelRequest>
  void UpdateVoiceChannelAsync(const UpdateVoiceChannelRequestT& request, const UpdateVoiceChannelResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::UpdateVoiceChannel, request, handler, context);
  }
 
  virtual Model::UpdateVoiceTemplateOutcome UpdateVoiceTemplate(const Model::UpdateVoiceTemplateRequest& request) const;
 
  template <typename UpdateVoiceTemplateRequestT = Model::UpdateVoiceTemplateRequest>
  Model::UpdateVoiceTemplateOutcomeCallable UpdateVoiceTemplateCallable(const UpdateVoiceTemplateRequestT& request) const {
    return SubmitCallable(&PinpointClient::UpdateVoiceTemplate, request);
  }
 
  template <typename UpdateVoiceTemplateRequestT = Model::UpdateVoiceTemplateRequest>
  void UpdateVoiceTemplateAsync(const UpdateVoiceTemplateRequestT& request, const UpdateVoiceTemplateResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::UpdateVoiceTemplate, request, handler, context);
  }
 
  virtual Model::VerifyOTPMessageOutcome VerifyOTPMessage(const Model::VerifyOTPMessageRequest& request) const;
 
  template <typename VerifyOTPMessageRequestT = Model::VerifyOTPMessageRequest>
  Model::VerifyOTPMessageOutcomeCallable VerifyOTPMessageCallable(const VerifyOTPMessageRequestT& request) const {
    return SubmitCallable(&PinpointClient::VerifyOTPMessage, request);
  }
 
  template <typename VerifyOTPMessageRequestT = Model::VerifyOTPMessageRequest>
  void VerifyOTPMessageAsync(const VerifyOTPMessageRequestT& request, const VerifyOTPMessageResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PinpointClient::VerifyOTPMessage, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<PinpointEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<PinpointClient>;
  void init(const PinpointClientConfiguration& clientConfiguration);
 
  PinpointClientConfiguration m_clientConfiguration;
  std::shared_ptr<PinpointEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Pinpoint
}  // namespace Aws