PinpointEmailClient.h

 
#pragma once
#include <aws/pinpoint-email/PinpointEmail_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-email/PinpointEmailServiceClientModel.h>
 
namespace Aws
{
namespace PinpointEmail
{
  class AWS_PINPOINTEMAIL_API PinpointEmailClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<PinpointEmailClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef PinpointEmailClientConfiguration ClientConfigurationType;
      typedef PinpointEmailEndpointProvider EndpointProviderType;
 
        PinpointEmailClient(const Aws::PinpointEmail::PinpointEmailClientConfiguration& clientConfiguration = Aws::PinpointEmail::PinpointEmailClientConfiguration(),
                            std::shared_ptr<PinpointEmailEndpointProviderBase> endpointProvider = nullptr);
 
        PinpointEmailClient(const Aws::Auth::AWSCredentials& credentials,
                            std::shared_ptr<PinpointEmailEndpointProviderBase> endpointProvider = nullptr,
                            const Aws::PinpointEmail::PinpointEmailClientConfiguration& clientConfiguration = Aws::PinpointEmail::PinpointEmailClientConfiguration());
 
        PinpointEmailClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                            std::shared_ptr<PinpointEmailEndpointProviderBase> endpointProvider = nullptr,
                            const Aws::PinpointEmail::PinpointEmailClientConfiguration& clientConfiguration = Aws::PinpointEmail::PinpointEmailClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        PinpointEmailClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        PinpointEmailClient(const Aws::Auth::AWSCredentials& credentials,
                            const Aws::Client::ClientConfiguration& clientConfiguration);
 
        PinpointEmailClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                            const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~PinpointEmailClient();
 
        virtual Model::CreateConfigurationSetOutcome CreateConfigurationSet(const Model::CreateConfigurationSetRequest& request) const;
 
        template<typename CreateConfigurationSetRequestT = Model::CreateConfigurationSetRequest>
        Model::CreateConfigurationSetOutcomeCallable CreateConfigurationSetCallable(const CreateConfigurationSetRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::CreateConfigurationSet, request);
        }
 
        template<typename CreateConfigurationSetRequestT = Model::CreateConfigurationSetRequest>
        void CreateConfigurationSetAsync(const CreateConfigurationSetRequestT& request, const CreateConfigurationSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::CreateConfigurationSet, request, handler, context);
        }
 
        virtual Model::CreateConfigurationSetEventDestinationOutcome CreateConfigurationSetEventDestination(const Model::CreateConfigurationSetEventDestinationRequest& request) const;
 
        template<typename CreateConfigurationSetEventDestinationRequestT = Model::CreateConfigurationSetEventDestinationRequest>
        Model::CreateConfigurationSetEventDestinationOutcomeCallable CreateConfigurationSetEventDestinationCallable(const CreateConfigurationSetEventDestinationRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::CreateConfigurationSetEventDestination, request);
        }
 
        template<typename CreateConfigurationSetEventDestinationRequestT = Model::CreateConfigurationSetEventDestinationRequest>
        void CreateConfigurationSetEventDestinationAsync(const CreateConfigurationSetEventDestinationRequestT& request, const CreateConfigurationSetEventDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::CreateConfigurationSetEventDestination, request, handler, context);
        }
 
        virtual Model::CreateDedicatedIpPoolOutcome CreateDedicatedIpPool(const Model::CreateDedicatedIpPoolRequest& request) const;
 
        template<typename CreateDedicatedIpPoolRequestT = Model::CreateDedicatedIpPoolRequest>
        Model::CreateDedicatedIpPoolOutcomeCallable CreateDedicatedIpPoolCallable(const CreateDedicatedIpPoolRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::CreateDedicatedIpPool, request);
        }
 
        template<typename CreateDedicatedIpPoolRequestT = Model::CreateDedicatedIpPoolRequest>
        void CreateDedicatedIpPoolAsync(const CreateDedicatedIpPoolRequestT& request, const CreateDedicatedIpPoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::CreateDedicatedIpPool, request, handler, context);
        }
 
        virtual Model::CreateDeliverabilityTestReportOutcome CreateDeliverabilityTestReport(const Model::CreateDeliverabilityTestReportRequest& request) const;
 
        template<typename CreateDeliverabilityTestReportRequestT = Model::CreateDeliverabilityTestReportRequest>
        Model::CreateDeliverabilityTestReportOutcomeCallable CreateDeliverabilityTestReportCallable(const CreateDeliverabilityTestReportRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::CreateDeliverabilityTestReport, request);
        }
 
        template<typename CreateDeliverabilityTestReportRequestT = Model::CreateDeliverabilityTestReportRequest>
        void CreateDeliverabilityTestReportAsync(const CreateDeliverabilityTestReportRequestT& request, const CreateDeliverabilityTestReportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::CreateDeliverabilityTestReport, request, handler, context);
        }
 
        virtual Model::CreateEmailIdentityOutcome CreateEmailIdentity(const Model::CreateEmailIdentityRequest& request) const;
 
        template<typename CreateEmailIdentityRequestT = Model::CreateEmailIdentityRequest>
        Model::CreateEmailIdentityOutcomeCallable CreateEmailIdentityCallable(const CreateEmailIdentityRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::CreateEmailIdentity, request);
        }
 
        template<typename CreateEmailIdentityRequestT = Model::CreateEmailIdentityRequest>
        void CreateEmailIdentityAsync(const CreateEmailIdentityRequestT& request, const CreateEmailIdentityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::CreateEmailIdentity, request, handler, context);
        }
 
        virtual Model::DeleteConfigurationSetOutcome DeleteConfigurationSet(const Model::DeleteConfigurationSetRequest& request) const;
 
        template<typename DeleteConfigurationSetRequestT = Model::DeleteConfigurationSetRequest>
        Model::DeleteConfigurationSetOutcomeCallable DeleteConfigurationSetCallable(const DeleteConfigurationSetRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::DeleteConfigurationSet, request);
        }
 
        template<typename DeleteConfigurationSetRequestT = Model::DeleteConfigurationSetRequest>
        void DeleteConfigurationSetAsync(const DeleteConfigurationSetRequestT& request, const DeleteConfigurationSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::DeleteConfigurationSet, request, handler, context);
        }
 
        virtual Model::DeleteConfigurationSetEventDestinationOutcome DeleteConfigurationSetEventDestination(const Model::DeleteConfigurationSetEventDestinationRequest& request) const;
 
        template<typename DeleteConfigurationSetEventDestinationRequestT = Model::DeleteConfigurationSetEventDestinationRequest>
        Model::DeleteConfigurationSetEventDestinationOutcomeCallable DeleteConfigurationSetEventDestinationCallable(const DeleteConfigurationSetEventDestinationRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::DeleteConfigurationSetEventDestination, request);
        }
 
        template<typename DeleteConfigurationSetEventDestinationRequestT = Model::DeleteConfigurationSetEventDestinationRequest>
        void DeleteConfigurationSetEventDestinationAsync(const DeleteConfigurationSetEventDestinationRequestT& request, const DeleteConfigurationSetEventDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::DeleteConfigurationSetEventDestination, request, handler, context);
        }
 
        virtual Model::DeleteDedicatedIpPoolOutcome DeleteDedicatedIpPool(const Model::DeleteDedicatedIpPoolRequest& request) const;
 
        template<typename DeleteDedicatedIpPoolRequestT = Model::DeleteDedicatedIpPoolRequest>
        Model::DeleteDedicatedIpPoolOutcomeCallable DeleteDedicatedIpPoolCallable(const DeleteDedicatedIpPoolRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::DeleteDedicatedIpPool, request);
        }
 
        template<typename DeleteDedicatedIpPoolRequestT = Model::DeleteDedicatedIpPoolRequest>
        void DeleteDedicatedIpPoolAsync(const DeleteDedicatedIpPoolRequestT& request, const DeleteDedicatedIpPoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::DeleteDedicatedIpPool, request, handler, context);
        }
 
        virtual Model::DeleteEmailIdentityOutcome DeleteEmailIdentity(const Model::DeleteEmailIdentityRequest& request) const;
 
        template<typename DeleteEmailIdentityRequestT = Model::DeleteEmailIdentityRequest>
        Model::DeleteEmailIdentityOutcomeCallable DeleteEmailIdentityCallable(const DeleteEmailIdentityRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::DeleteEmailIdentity, request);
        }
 
        template<typename DeleteEmailIdentityRequestT = Model::DeleteEmailIdentityRequest>
        void DeleteEmailIdentityAsync(const DeleteEmailIdentityRequestT& request, const DeleteEmailIdentityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::DeleteEmailIdentity, request, handler, context);
        }
 
        virtual Model::GetAccountOutcome GetAccount(const Model::GetAccountRequest& request = {}) const;
 
        template<typename GetAccountRequestT = Model::GetAccountRequest>
        Model::GetAccountOutcomeCallable GetAccountCallable(const GetAccountRequestT& request = {}) const
        {
            return SubmitCallable(&PinpointEmailClient::GetAccount, request);
        }
 
        template<typename GetAccountRequestT = Model::GetAccountRequest>
        void GetAccountAsync(const GetAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetAccountRequestT& request = {}) const
        {
            return SubmitAsync(&PinpointEmailClient::GetAccount, request, handler, context);
        }
 
        virtual Model::GetBlacklistReportsOutcome GetBlacklistReports(const Model::GetBlacklistReportsRequest& request) const;
 
        template<typename GetBlacklistReportsRequestT = Model::GetBlacklistReportsRequest>
        Model::GetBlacklistReportsOutcomeCallable GetBlacklistReportsCallable(const GetBlacklistReportsRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::GetBlacklistReports, request);
        }
 
        template<typename GetBlacklistReportsRequestT = Model::GetBlacklistReportsRequest>
        void GetBlacklistReportsAsync(const GetBlacklistReportsRequestT& request, const GetBlacklistReportsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::GetBlacklistReports, request, handler, context);
        }
 
        virtual Model::GetConfigurationSetOutcome GetConfigurationSet(const Model::GetConfigurationSetRequest& request) const;
 
        template<typename GetConfigurationSetRequestT = Model::GetConfigurationSetRequest>
        Model::GetConfigurationSetOutcomeCallable GetConfigurationSetCallable(const GetConfigurationSetRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::GetConfigurationSet, request);
        }
 
        template<typename GetConfigurationSetRequestT = Model::GetConfigurationSetRequest>
        void GetConfigurationSetAsync(const GetConfigurationSetRequestT& request, const GetConfigurationSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::GetConfigurationSet, request, handler, context);
        }
 
        virtual Model::GetConfigurationSetEventDestinationsOutcome GetConfigurationSetEventDestinations(const Model::GetConfigurationSetEventDestinationsRequest& request) const;
 
        template<typename GetConfigurationSetEventDestinationsRequestT = Model::GetConfigurationSetEventDestinationsRequest>
        Model::GetConfigurationSetEventDestinationsOutcomeCallable GetConfigurationSetEventDestinationsCallable(const GetConfigurationSetEventDestinationsRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::GetConfigurationSetEventDestinations, request);
        }
 
        template<typename GetConfigurationSetEventDestinationsRequestT = Model::GetConfigurationSetEventDestinationsRequest>
        void GetConfigurationSetEventDestinationsAsync(const GetConfigurationSetEventDestinationsRequestT& request, const GetConfigurationSetEventDestinationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::GetConfigurationSetEventDestinations, request, handler, context);
        }
 
        virtual Model::GetDedicatedIpOutcome GetDedicatedIp(const Model::GetDedicatedIpRequest& request) const;
 
        template<typename GetDedicatedIpRequestT = Model::GetDedicatedIpRequest>
        Model::GetDedicatedIpOutcomeCallable GetDedicatedIpCallable(const GetDedicatedIpRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::GetDedicatedIp, request);
        }
 
        template<typename GetDedicatedIpRequestT = Model::GetDedicatedIpRequest>
        void GetDedicatedIpAsync(const GetDedicatedIpRequestT& request, const GetDedicatedIpResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::GetDedicatedIp, request, handler, context);
        }
 
        virtual Model::GetDedicatedIpsOutcome GetDedicatedIps(const Model::GetDedicatedIpsRequest& request = {}) const;
 
        template<typename GetDedicatedIpsRequestT = Model::GetDedicatedIpsRequest>
        Model::GetDedicatedIpsOutcomeCallable GetDedicatedIpsCallable(const GetDedicatedIpsRequestT& request = {}) const
        {
            return SubmitCallable(&PinpointEmailClient::GetDedicatedIps, request);
        }
 
        template<typename GetDedicatedIpsRequestT = Model::GetDedicatedIpsRequest>
        void GetDedicatedIpsAsync(const GetDedicatedIpsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetDedicatedIpsRequestT& request = {}) const
        {
            return SubmitAsync(&PinpointEmailClient::GetDedicatedIps, request, handler, context);
        }
 
        virtual Model::GetDeliverabilityDashboardOptionsOutcome GetDeliverabilityDashboardOptions(const Model::GetDeliverabilityDashboardOptionsRequest& request = {}) const;
 
        template<typename GetDeliverabilityDashboardOptionsRequestT = Model::GetDeliverabilityDashboardOptionsRequest>
        Model::GetDeliverabilityDashboardOptionsOutcomeCallable GetDeliverabilityDashboardOptionsCallable(const GetDeliverabilityDashboardOptionsRequestT& request = {}) const
        {
            return SubmitCallable(&PinpointEmailClient::GetDeliverabilityDashboardOptions, request);
        }
 
        template<typename GetDeliverabilityDashboardOptionsRequestT = Model::GetDeliverabilityDashboardOptionsRequest>
        void GetDeliverabilityDashboardOptionsAsync(const GetDeliverabilityDashboardOptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetDeliverabilityDashboardOptionsRequestT& request = {}) const
        {
            return SubmitAsync(&PinpointEmailClient::GetDeliverabilityDashboardOptions, request, handler, context);
        }
 
        virtual Model::GetDeliverabilityTestReportOutcome GetDeliverabilityTestReport(const Model::GetDeliverabilityTestReportRequest& request) const;
 
        template<typename GetDeliverabilityTestReportRequestT = Model::GetDeliverabilityTestReportRequest>
        Model::GetDeliverabilityTestReportOutcomeCallable GetDeliverabilityTestReportCallable(const GetDeliverabilityTestReportRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::GetDeliverabilityTestReport, request);
        }
 
        template<typename GetDeliverabilityTestReportRequestT = Model::GetDeliverabilityTestReportRequest>
        void GetDeliverabilityTestReportAsync(const GetDeliverabilityTestReportRequestT& request, const GetDeliverabilityTestReportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::GetDeliverabilityTestReport, request, handler, context);
        }
 
        virtual Model::GetDomainDeliverabilityCampaignOutcome GetDomainDeliverabilityCampaign(const Model::GetDomainDeliverabilityCampaignRequest& request) const;
 
        template<typename GetDomainDeliverabilityCampaignRequestT = Model::GetDomainDeliverabilityCampaignRequest>
        Model::GetDomainDeliverabilityCampaignOutcomeCallable GetDomainDeliverabilityCampaignCallable(const GetDomainDeliverabilityCampaignRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::GetDomainDeliverabilityCampaign, request);
        }
 
        template<typename GetDomainDeliverabilityCampaignRequestT = Model::GetDomainDeliverabilityCampaignRequest>
        void GetDomainDeliverabilityCampaignAsync(const GetDomainDeliverabilityCampaignRequestT& request, const GetDomainDeliverabilityCampaignResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::GetDomainDeliverabilityCampaign, request, handler, context);
        }
 
        virtual Model::GetDomainStatisticsReportOutcome GetDomainStatisticsReport(const Model::GetDomainStatisticsReportRequest& request) const;
 
        template<typename GetDomainStatisticsReportRequestT = Model::GetDomainStatisticsReportRequest>
        Model::GetDomainStatisticsReportOutcomeCallable GetDomainStatisticsReportCallable(const GetDomainStatisticsReportRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::GetDomainStatisticsReport, request);
        }
 
        template<typename GetDomainStatisticsReportRequestT = Model::GetDomainStatisticsReportRequest>
        void GetDomainStatisticsReportAsync(const GetDomainStatisticsReportRequestT& request, const GetDomainStatisticsReportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::GetDomainStatisticsReport, request, handler, context);
        }
 
        virtual Model::GetEmailIdentityOutcome GetEmailIdentity(const Model::GetEmailIdentityRequest& request) const;
 
        template<typename GetEmailIdentityRequestT = Model::GetEmailIdentityRequest>
        Model::GetEmailIdentityOutcomeCallable GetEmailIdentityCallable(const GetEmailIdentityRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::GetEmailIdentity, request);
        }
 
        template<typename GetEmailIdentityRequestT = Model::GetEmailIdentityRequest>
        void GetEmailIdentityAsync(const GetEmailIdentityRequestT& request, const GetEmailIdentityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::GetEmailIdentity, request, handler, context);
        }
 
        virtual Model::ListConfigurationSetsOutcome ListConfigurationSets(const Model::ListConfigurationSetsRequest& request = {}) const;
 
        template<typename ListConfigurationSetsRequestT = Model::ListConfigurationSetsRequest>
        Model::ListConfigurationSetsOutcomeCallable ListConfigurationSetsCallable(const ListConfigurationSetsRequestT& request = {}) const
        {
            return SubmitCallable(&PinpointEmailClient::ListConfigurationSets, request);
        }
 
        template<typename ListConfigurationSetsRequestT = Model::ListConfigurationSetsRequest>
        void ListConfigurationSetsAsync(const ListConfigurationSetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListConfigurationSetsRequestT& request = {}) const
        {
            return SubmitAsync(&PinpointEmailClient::ListConfigurationSets, request, handler, context);
        }
 
        virtual Model::ListDedicatedIpPoolsOutcome ListDedicatedIpPools(const Model::ListDedicatedIpPoolsRequest& request = {}) const;
 
        template<typename ListDedicatedIpPoolsRequestT = Model::ListDedicatedIpPoolsRequest>
        Model::ListDedicatedIpPoolsOutcomeCallable ListDedicatedIpPoolsCallable(const ListDedicatedIpPoolsRequestT& request = {}) const
        {
            return SubmitCallable(&PinpointEmailClient::ListDedicatedIpPools, request);
        }
 
        template<typename ListDedicatedIpPoolsRequestT = Model::ListDedicatedIpPoolsRequest>
        void ListDedicatedIpPoolsAsync(const ListDedicatedIpPoolsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDedicatedIpPoolsRequestT& request = {}) const
        {
            return SubmitAsync(&PinpointEmailClient::ListDedicatedIpPools, request, handler, context);
        }
 
        virtual Model::ListDeliverabilityTestReportsOutcome ListDeliverabilityTestReports(const Model::ListDeliverabilityTestReportsRequest& request = {}) const;
 
        template<typename ListDeliverabilityTestReportsRequestT = Model::ListDeliverabilityTestReportsRequest>
        Model::ListDeliverabilityTestReportsOutcomeCallable ListDeliverabilityTestReportsCallable(const ListDeliverabilityTestReportsRequestT& request = {}) const
        {
            return SubmitCallable(&PinpointEmailClient::ListDeliverabilityTestReports, request);
        }
 
        template<typename ListDeliverabilityTestReportsRequestT = Model::ListDeliverabilityTestReportsRequest>
        void ListDeliverabilityTestReportsAsync(const ListDeliverabilityTestReportsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDeliverabilityTestReportsRequestT& request = {}) const
        {
            return SubmitAsync(&PinpointEmailClient::ListDeliverabilityTestReports, request, handler, context);
        }
 
        virtual Model::ListDomainDeliverabilityCampaignsOutcome ListDomainDeliverabilityCampaigns(const Model::ListDomainDeliverabilityCampaignsRequest& request) const;
 
        template<typename ListDomainDeliverabilityCampaignsRequestT = Model::ListDomainDeliverabilityCampaignsRequest>
        Model::ListDomainDeliverabilityCampaignsOutcomeCallable ListDomainDeliverabilityCampaignsCallable(const ListDomainDeliverabilityCampaignsRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::ListDomainDeliverabilityCampaigns, request);
        }
 
        template<typename ListDomainDeliverabilityCampaignsRequestT = Model::ListDomainDeliverabilityCampaignsRequest>
        void ListDomainDeliverabilityCampaignsAsync(const ListDomainDeliverabilityCampaignsRequestT& request, const ListDomainDeliverabilityCampaignsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::ListDomainDeliverabilityCampaigns, request, handler, context);
        }
 
        virtual Model::ListEmailIdentitiesOutcome ListEmailIdentities(const Model::ListEmailIdentitiesRequest& request = {}) const;
 
        template<typename ListEmailIdentitiesRequestT = Model::ListEmailIdentitiesRequest>
        Model::ListEmailIdentitiesOutcomeCallable ListEmailIdentitiesCallable(const ListEmailIdentitiesRequestT& request = {}) const
        {
            return SubmitCallable(&PinpointEmailClient::ListEmailIdentities, request);
        }
 
        template<typename ListEmailIdentitiesRequestT = Model::ListEmailIdentitiesRequest>
        void ListEmailIdentitiesAsync(const ListEmailIdentitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListEmailIdentitiesRequestT& request = {}) const
        {
            return SubmitAsync(&PinpointEmailClient::ListEmailIdentities, 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(&PinpointEmailClient::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(&PinpointEmailClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::PutAccountDedicatedIpWarmupAttributesOutcome PutAccountDedicatedIpWarmupAttributes(const Model::PutAccountDedicatedIpWarmupAttributesRequest& request = {}) const;
 
        template<typename PutAccountDedicatedIpWarmupAttributesRequestT = Model::PutAccountDedicatedIpWarmupAttributesRequest>
        Model::PutAccountDedicatedIpWarmupAttributesOutcomeCallable PutAccountDedicatedIpWarmupAttributesCallable(const PutAccountDedicatedIpWarmupAttributesRequestT& request = {}) const
        {
            return SubmitCallable(&PinpointEmailClient::PutAccountDedicatedIpWarmupAttributes, request);
        }
 
        template<typename PutAccountDedicatedIpWarmupAttributesRequestT = Model::PutAccountDedicatedIpWarmupAttributesRequest>
        void PutAccountDedicatedIpWarmupAttributesAsync(const PutAccountDedicatedIpWarmupAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const PutAccountDedicatedIpWarmupAttributesRequestT& request = {}) const
        {
            return SubmitAsync(&PinpointEmailClient::PutAccountDedicatedIpWarmupAttributes, request, handler, context);
        }
 
        virtual Model::PutAccountSendingAttributesOutcome PutAccountSendingAttributes(const Model::PutAccountSendingAttributesRequest& request = {}) const;
 
        template<typename PutAccountSendingAttributesRequestT = Model::PutAccountSendingAttributesRequest>
        Model::PutAccountSendingAttributesOutcomeCallable PutAccountSendingAttributesCallable(const PutAccountSendingAttributesRequestT& request = {}) const
        {
            return SubmitCallable(&PinpointEmailClient::PutAccountSendingAttributes, request);
        }
 
        template<typename PutAccountSendingAttributesRequestT = Model::PutAccountSendingAttributesRequest>
        void PutAccountSendingAttributesAsync(const PutAccountSendingAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const PutAccountSendingAttributesRequestT& request = {}) const
        {
            return SubmitAsync(&PinpointEmailClient::PutAccountSendingAttributes, request, handler, context);
        }
 
        virtual Model::PutConfigurationSetDeliveryOptionsOutcome PutConfigurationSetDeliveryOptions(const Model::PutConfigurationSetDeliveryOptionsRequest& request) const;
 
        template<typename PutConfigurationSetDeliveryOptionsRequestT = Model::PutConfigurationSetDeliveryOptionsRequest>
        Model::PutConfigurationSetDeliveryOptionsOutcomeCallable PutConfigurationSetDeliveryOptionsCallable(const PutConfigurationSetDeliveryOptionsRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::PutConfigurationSetDeliveryOptions, request);
        }
 
        template<typename PutConfigurationSetDeliveryOptionsRequestT = Model::PutConfigurationSetDeliveryOptionsRequest>
        void PutConfigurationSetDeliveryOptionsAsync(const PutConfigurationSetDeliveryOptionsRequestT& request, const PutConfigurationSetDeliveryOptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::PutConfigurationSetDeliveryOptions, request, handler, context);
        }
 
        virtual Model::PutConfigurationSetReputationOptionsOutcome PutConfigurationSetReputationOptions(const Model::PutConfigurationSetReputationOptionsRequest& request) const;
 
        template<typename PutConfigurationSetReputationOptionsRequestT = Model::PutConfigurationSetReputationOptionsRequest>
        Model::PutConfigurationSetReputationOptionsOutcomeCallable PutConfigurationSetReputationOptionsCallable(const PutConfigurationSetReputationOptionsRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::PutConfigurationSetReputationOptions, request);
        }
 
        template<typename PutConfigurationSetReputationOptionsRequestT = Model::PutConfigurationSetReputationOptionsRequest>
        void PutConfigurationSetReputationOptionsAsync(const PutConfigurationSetReputationOptionsRequestT& request, const PutConfigurationSetReputationOptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::PutConfigurationSetReputationOptions, request, handler, context);
        }
 
        virtual Model::PutConfigurationSetSendingOptionsOutcome PutConfigurationSetSendingOptions(const Model::PutConfigurationSetSendingOptionsRequest& request) const;
 
        template<typename PutConfigurationSetSendingOptionsRequestT = Model::PutConfigurationSetSendingOptionsRequest>
        Model::PutConfigurationSetSendingOptionsOutcomeCallable PutConfigurationSetSendingOptionsCallable(const PutConfigurationSetSendingOptionsRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::PutConfigurationSetSendingOptions, request);
        }
 
        template<typename PutConfigurationSetSendingOptionsRequestT = Model::PutConfigurationSetSendingOptionsRequest>
        void PutConfigurationSetSendingOptionsAsync(const PutConfigurationSetSendingOptionsRequestT& request, const PutConfigurationSetSendingOptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::PutConfigurationSetSendingOptions, request, handler, context);
        }
 
        virtual Model::PutConfigurationSetTrackingOptionsOutcome PutConfigurationSetTrackingOptions(const Model::PutConfigurationSetTrackingOptionsRequest& request) const;
 
        template<typename PutConfigurationSetTrackingOptionsRequestT = Model::PutConfigurationSetTrackingOptionsRequest>
        Model::PutConfigurationSetTrackingOptionsOutcomeCallable PutConfigurationSetTrackingOptionsCallable(const PutConfigurationSetTrackingOptionsRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::PutConfigurationSetTrackingOptions, request);
        }
 
        template<typename PutConfigurationSetTrackingOptionsRequestT = Model::PutConfigurationSetTrackingOptionsRequest>
        void PutConfigurationSetTrackingOptionsAsync(const PutConfigurationSetTrackingOptionsRequestT& request, const PutConfigurationSetTrackingOptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::PutConfigurationSetTrackingOptions, request, handler, context);
        }
 
        virtual Model::PutDedicatedIpInPoolOutcome PutDedicatedIpInPool(const Model::PutDedicatedIpInPoolRequest& request) const;
 
        template<typename PutDedicatedIpInPoolRequestT = Model::PutDedicatedIpInPoolRequest>
        Model::PutDedicatedIpInPoolOutcomeCallable PutDedicatedIpInPoolCallable(const PutDedicatedIpInPoolRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::PutDedicatedIpInPool, request);
        }
 
        template<typename PutDedicatedIpInPoolRequestT = Model::PutDedicatedIpInPoolRequest>
        void PutDedicatedIpInPoolAsync(const PutDedicatedIpInPoolRequestT& request, const PutDedicatedIpInPoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::PutDedicatedIpInPool, request, handler, context);
        }
 
        virtual Model::PutDedicatedIpWarmupAttributesOutcome PutDedicatedIpWarmupAttributes(const Model::PutDedicatedIpWarmupAttributesRequest& request) const;
 
        template<typename PutDedicatedIpWarmupAttributesRequestT = Model::PutDedicatedIpWarmupAttributesRequest>
        Model::PutDedicatedIpWarmupAttributesOutcomeCallable PutDedicatedIpWarmupAttributesCallable(const PutDedicatedIpWarmupAttributesRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::PutDedicatedIpWarmupAttributes, request);
        }
 
        template<typename PutDedicatedIpWarmupAttributesRequestT = Model::PutDedicatedIpWarmupAttributesRequest>
        void PutDedicatedIpWarmupAttributesAsync(const PutDedicatedIpWarmupAttributesRequestT& request, const PutDedicatedIpWarmupAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::PutDedicatedIpWarmupAttributes, request, handler, context);
        }
 
        virtual Model::PutDeliverabilityDashboardOptionOutcome PutDeliverabilityDashboardOption(const Model::PutDeliverabilityDashboardOptionRequest& request) const;
 
        template<typename PutDeliverabilityDashboardOptionRequestT = Model::PutDeliverabilityDashboardOptionRequest>
        Model::PutDeliverabilityDashboardOptionOutcomeCallable PutDeliverabilityDashboardOptionCallable(const PutDeliverabilityDashboardOptionRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::PutDeliverabilityDashboardOption, request);
        }
 
        template<typename PutDeliverabilityDashboardOptionRequestT = Model::PutDeliverabilityDashboardOptionRequest>
        void PutDeliverabilityDashboardOptionAsync(const PutDeliverabilityDashboardOptionRequestT& request, const PutDeliverabilityDashboardOptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::PutDeliverabilityDashboardOption, request, handler, context);
        }
 
        virtual Model::PutEmailIdentityDkimAttributesOutcome PutEmailIdentityDkimAttributes(const Model::PutEmailIdentityDkimAttributesRequest& request) const;
 
        template<typename PutEmailIdentityDkimAttributesRequestT = Model::PutEmailIdentityDkimAttributesRequest>
        Model::PutEmailIdentityDkimAttributesOutcomeCallable PutEmailIdentityDkimAttributesCallable(const PutEmailIdentityDkimAttributesRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::PutEmailIdentityDkimAttributes, request);
        }
 
        template<typename PutEmailIdentityDkimAttributesRequestT = Model::PutEmailIdentityDkimAttributesRequest>
        void PutEmailIdentityDkimAttributesAsync(const PutEmailIdentityDkimAttributesRequestT& request, const PutEmailIdentityDkimAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::PutEmailIdentityDkimAttributes, request, handler, context);
        }
 
        virtual Model::PutEmailIdentityFeedbackAttributesOutcome PutEmailIdentityFeedbackAttributes(const Model::PutEmailIdentityFeedbackAttributesRequest& request) const;
 
        template<typename PutEmailIdentityFeedbackAttributesRequestT = Model::PutEmailIdentityFeedbackAttributesRequest>
        Model::PutEmailIdentityFeedbackAttributesOutcomeCallable PutEmailIdentityFeedbackAttributesCallable(const PutEmailIdentityFeedbackAttributesRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::PutEmailIdentityFeedbackAttributes, request);
        }
 
        template<typename PutEmailIdentityFeedbackAttributesRequestT = Model::PutEmailIdentityFeedbackAttributesRequest>
        void PutEmailIdentityFeedbackAttributesAsync(const PutEmailIdentityFeedbackAttributesRequestT& request, const PutEmailIdentityFeedbackAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::PutEmailIdentityFeedbackAttributes, request, handler, context);
        }
 
        virtual Model::PutEmailIdentityMailFromAttributesOutcome PutEmailIdentityMailFromAttributes(const Model::PutEmailIdentityMailFromAttributesRequest& request) const;
 
        template<typename PutEmailIdentityMailFromAttributesRequestT = Model::PutEmailIdentityMailFromAttributesRequest>
        Model::PutEmailIdentityMailFromAttributesOutcomeCallable PutEmailIdentityMailFromAttributesCallable(const PutEmailIdentityMailFromAttributesRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::PutEmailIdentityMailFromAttributes, request);
        }
 
        template<typename PutEmailIdentityMailFromAttributesRequestT = Model::PutEmailIdentityMailFromAttributesRequest>
        void PutEmailIdentityMailFromAttributesAsync(const PutEmailIdentityMailFromAttributesRequestT& request, const PutEmailIdentityMailFromAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::PutEmailIdentityMailFromAttributes, request, handler, context);
        }
 
        virtual Model::SendEmailOutcome SendEmail(const Model::SendEmailRequest& request) const;
 
        template<typename SendEmailRequestT = Model::SendEmailRequest>
        Model::SendEmailOutcomeCallable SendEmailCallable(const SendEmailRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::SendEmail, request);
        }
 
        template<typename SendEmailRequestT = Model::SendEmailRequest>
        void SendEmailAsync(const SendEmailRequestT& request, const SendEmailResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::SendEmail, 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(&PinpointEmailClient::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(&PinpointEmailClient::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(&PinpointEmailClient::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(&PinpointEmailClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateConfigurationSetEventDestinationOutcome UpdateConfigurationSetEventDestination(const Model::UpdateConfigurationSetEventDestinationRequest& request) const;
 
        template<typename UpdateConfigurationSetEventDestinationRequestT = Model::UpdateConfigurationSetEventDestinationRequest>
        Model::UpdateConfigurationSetEventDestinationOutcomeCallable UpdateConfigurationSetEventDestinationCallable(const UpdateConfigurationSetEventDestinationRequestT& request) const
        {
            return SubmitCallable(&PinpointEmailClient::UpdateConfigurationSetEventDestination, request);
        }
 
        template<typename UpdateConfigurationSetEventDestinationRequestT = Model::UpdateConfigurationSetEventDestinationRequest>
        void UpdateConfigurationSetEventDestinationAsync(const UpdateConfigurationSetEventDestinationRequestT& request, const UpdateConfigurationSetEventDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PinpointEmailClient::UpdateConfigurationSetEventDestination, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<PinpointEmailEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<PinpointEmailClient>;
      void init(const PinpointEmailClientConfiguration& clientConfiguration);
 
      PinpointEmailClientConfiguration m_clientConfiguration;
      std::shared_ptr<PinpointEmailEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace PinpointEmail
} // namespace Aws