PinpointClient.h

 
#pragma once
#include <aws/pinpoint/Pinpoint_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/pinpoint/PinpointServiceClientModel.h>
 
namespace Aws
{
namespace Pinpoint
{
  class AWS_PINPOINT_API PinpointClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      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