PinpointEmailClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/pinpoint-email/PinpointEmailPaginationBase.h>
#include <aws/pinpoint-email/PinpointEmailServiceClientModel.h>
#include <aws/pinpoint-email/PinpointEmailWaiter.h>
#include <aws/pinpoint-email/PinpointEmail_EXPORTS.h>
 
namespace Aws {
namespace PinpointEmail {
class AWS_PINPOINTEMAIL_API PinpointEmailClient : public Aws::Client::AWSJsonClient,
                                                  public Aws::Client::ClientWithAsyncTemplateMethods<PinpointEmailClient>,
                                                  public PinpointEmailPaginationBase<PinpointEmailClient>,
                                                  public PinpointEmailWaiter<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<PinpointEmailEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<PinpointEmailClient>;
  void init(const PinpointEmailClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, PinpointEmailError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  PinpointEmailClientConfiguration m_clientConfiguration;
  std::shared_ptr<PinpointEmailEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace PinpointEmail
}  // namespace Aws