SESV2Client.h

 
#pragma once
#include <aws/sesv2/SESV2_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/sesv2/SESV2ServiceClientModel.h>
 
namespace Aws
{
namespace SESV2
{
  class AWS_SESV2_API SESV2Client : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<SESV2Client>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef SESV2ClientConfiguration ClientConfigurationType;
      typedef SESV2EndpointProvider EndpointProviderType;
 
        SESV2Client(const Aws::SESV2::SESV2ClientConfiguration& clientConfiguration = Aws::SESV2::SESV2ClientConfiguration(),
                    std::shared_ptr<SESV2EndpointProviderBase> endpointProvider = nullptr);
 
        SESV2Client(const Aws::Auth::AWSCredentials& credentials,
                    std::shared_ptr<SESV2EndpointProviderBase> endpointProvider = nullptr,
                    const Aws::SESV2::SESV2ClientConfiguration& clientConfiguration = Aws::SESV2::SESV2ClientConfiguration());
 
        SESV2Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                    std::shared_ptr<SESV2EndpointProviderBase> endpointProvider = nullptr,
                    const Aws::SESV2::SESV2ClientConfiguration& clientConfiguration = Aws::SESV2::SESV2ClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        SESV2Client(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SESV2Client(const Aws::Auth::AWSCredentials& credentials,
                    const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SESV2Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                    const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~SESV2Client();
 
        virtual Model::BatchGetMetricDataOutcome BatchGetMetricData(const Model::BatchGetMetricDataRequest& request) const;
 
        template<typename BatchGetMetricDataRequestT = Model::BatchGetMetricDataRequest>
        Model::BatchGetMetricDataOutcomeCallable BatchGetMetricDataCallable(const BatchGetMetricDataRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::BatchGetMetricData, request);
        }
 
        template<typename BatchGetMetricDataRequestT = Model::BatchGetMetricDataRequest>
        void BatchGetMetricDataAsync(const BatchGetMetricDataRequestT& request, const BatchGetMetricDataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::BatchGetMetricData, request, handler, context);
        }
 
        virtual Model::CancelExportJobOutcome CancelExportJob(const Model::CancelExportJobRequest& request) const;
 
        template<typename CancelExportJobRequestT = Model::CancelExportJobRequest>
        Model::CancelExportJobOutcomeCallable CancelExportJobCallable(const CancelExportJobRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::CancelExportJob, request);
        }
 
        template<typename CancelExportJobRequestT = Model::CancelExportJobRequest>
        void CancelExportJobAsync(const CancelExportJobRequestT& request, const CancelExportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::CancelExportJob, request, handler, context);
        }
 
        virtual Model::CreateConfigurationSetOutcome CreateConfigurationSet(const Model::CreateConfigurationSetRequest& request) const;
 
        template<typename CreateConfigurationSetRequestT = Model::CreateConfigurationSetRequest>
        Model::CreateConfigurationSetOutcomeCallable CreateConfigurationSetCallable(const CreateConfigurationSetRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::CreateConfigurationSetEventDestination, request, handler, context);
        }
 
        virtual Model::CreateContactOutcome CreateContact(const Model::CreateContactRequest& request) const;
 
        template<typename CreateContactRequestT = Model::CreateContactRequest>
        Model::CreateContactOutcomeCallable CreateContactCallable(const CreateContactRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::CreateContact, request);
        }
 
        template<typename CreateContactRequestT = Model::CreateContactRequest>
        void CreateContactAsync(const CreateContactRequestT& request, const CreateContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::CreateContact, request, handler, context);
        }
 
        virtual Model::CreateContactListOutcome CreateContactList(const Model::CreateContactListRequest& request) const;
 
        template<typename CreateContactListRequestT = Model::CreateContactListRequest>
        Model::CreateContactListOutcomeCallable CreateContactListCallable(const CreateContactListRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::CreateContactList, request);
        }
 
        template<typename CreateContactListRequestT = Model::CreateContactListRequest>
        void CreateContactListAsync(const CreateContactListRequestT& request, const CreateContactListResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::CreateContactList, request, handler, context);
        }
 
        virtual Model::CreateCustomVerificationEmailTemplateOutcome CreateCustomVerificationEmailTemplate(const Model::CreateCustomVerificationEmailTemplateRequest& request) const;
 
        template<typename CreateCustomVerificationEmailTemplateRequestT = Model::CreateCustomVerificationEmailTemplateRequest>
        Model::CreateCustomVerificationEmailTemplateOutcomeCallable CreateCustomVerificationEmailTemplateCallable(const CreateCustomVerificationEmailTemplateRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::CreateCustomVerificationEmailTemplate, request);
        }
 
        template<typename CreateCustomVerificationEmailTemplateRequestT = Model::CreateCustomVerificationEmailTemplateRequest>
        void CreateCustomVerificationEmailTemplateAsync(const CreateCustomVerificationEmailTemplateRequestT& request, const CreateCustomVerificationEmailTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::CreateCustomVerificationEmailTemplate, 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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::CreateEmailIdentity, request, handler, context);
        }
 
        virtual Model::CreateEmailIdentityPolicyOutcome CreateEmailIdentityPolicy(const Model::CreateEmailIdentityPolicyRequest& request) const;
 
        template<typename CreateEmailIdentityPolicyRequestT = Model::CreateEmailIdentityPolicyRequest>
        Model::CreateEmailIdentityPolicyOutcomeCallable CreateEmailIdentityPolicyCallable(const CreateEmailIdentityPolicyRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::CreateEmailIdentityPolicy, request);
        }
 
        template<typename CreateEmailIdentityPolicyRequestT = Model::CreateEmailIdentityPolicyRequest>
        void CreateEmailIdentityPolicyAsync(const CreateEmailIdentityPolicyRequestT& request, const CreateEmailIdentityPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::CreateEmailIdentityPolicy, 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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::CreateImportJob, 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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::DeleteConfigurationSetEventDestination, request, handler, context);
        }
 
        virtual Model::DeleteContactOutcome DeleteContact(const Model::DeleteContactRequest& request) const;
 
        template<typename DeleteContactRequestT = Model::DeleteContactRequest>
        Model::DeleteContactOutcomeCallable DeleteContactCallable(const DeleteContactRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::DeleteContact, request);
        }
 
        template<typename DeleteContactRequestT = Model::DeleteContactRequest>
        void DeleteContactAsync(const DeleteContactRequestT& request, const DeleteContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::DeleteContact, request, handler, context);
        }
 
        virtual Model::DeleteContactListOutcome DeleteContactList(const Model::DeleteContactListRequest& request) const;
 
        template<typename DeleteContactListRequestT = Model::DeleteContactListRequest>
        Model::DeleteContactListOutcomeCallable DeleteContactListCallable(const DeleteContactListRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::DeleteContactList, request);
        }
 
        template<typename DeleteContactListRequestT = Model::DeleteContactListRequest>
        void DeleteContactListAsync(const DeleteContactListRequestT& request, const DeleteContactListResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::DeleteContactList, request, handler, context);
        }
 
        virtual Model::DeleteCustomVerificationEmailTemplateOutcome DeleteCustomVerificationEmailTemplate(const Model::DeleteCustomVerificationEmailTemplateRequest& request) const;
 
        template<typename DeleteCustomVerificationEmailTemplateRequestT = Model::DeleteCustomVerificationEmailTemplateRequest>
        Model::DeleteCustomVerificationEmailTemplateOutcomeCallable DeleteCustomVerificationEmailTemplateCallable(const DeleteCustomVerificationEmailTemplateRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::DeleteCustomVerificationEmailTemplate, request);
        }
 
        template<typename DeleteCustomVerificationEmailTemplateRequestT = Model::DeleteCustomVerificationEmailTemplateRequest>
        void DeleteCustomVerificationEmailTemplateAsync(const DeleteCustomVerificationEmailTemplateRequestT& request, const DeleteCustomVerificationEmailTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::DeleteCustomVerificationEmailTemplate, 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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::DeleteEmailIdentity, request, handler, context);
        }
 
        virtual Model::DeleteEmailIdentityPolicyOutcome DeleteEmailIdentityPolicy(const Model::DeleteEmailIdentityPolicyRequest& request) const;
 
        template<typename DeleteEmailIdentityPolicyRequestT = Model::DeleteEmailIdentityPolicyRequest>
        Model::DeleteEmailIdentityPolicyOutcomeCallable DeleteEmailIdentityPolicyCallable(const DeleteEmailIdentityPolicyRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::DeleteEmailIdentityPolicy, request);
        }
 
        template<typename DeleteEmailIdentityPolicyRequestT = Model::DeleteEmailIdentityPolicyRequest>
        void DeleteEmailIdentityPolicyAsync(const DeleteEmailIdentityPolicyRequestT& request, const DeleteEmailIdentityPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::DeleteEmailIdentityPolicy, 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(&SESV2Client::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(&SESV2Client::DeleteEmailTemplate, request, handler, context);
        }
 
        virtual Model::DeleteSuppressedDestinationOutcome DeleteSuppressedDestination(const Model::DeleteSuppressedDestinationRequest& request) const;
 
        template<typename DeleteSuppressedDestinationRequestT = Model::DeleteSuppressedDestinationRequest>
        Model::DeleteSuppressedDestinationOutcomeCallable DeleteSuppressedDestinationCallable(const DeleteSuppressedDestinationRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::DeleteSuppressedDestination, request);
        }
 
        template<typename DeleteSuppressedDestinationRequestT = Model::DeleteSuppressedDestinationRequest>
        void DeleteSuppressedDestinationAsync(const DeleteSuppressedDestinationRequestT& request, const DeleteSuppressedDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::DeleteSuppressedDestination, 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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::GetConfigurationSetEventDestinations, request, handler, context);
        }
 
        virtual Model::GetContactOutcome GetContact(const Model::GetContactRequest& request) const;
 
        template<typename GetContactRequestT = Model::GetContactRequest>
        Model::GetContactOutcomeCallable GetContactCallable(const GetContactRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::GetContact, request);
        }
 
        template<typename GetContactRequestT = Model::GetContactRequest>
        void GetContactAsync(const GetContactRequestT& request, const GetContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::GetContact, request, handler, context);
        }
 
        virtual Model::GetContactListOutcome GetContactList(const Model::GetContactListRequest& request) const;
 
        template<typename GetContactListRequestT = Model::GetContactListRequest>
        Model::GetContactListOutcomeCallable GetContactListCallable(const GetContactListRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::GetContactList, request);
        }
 
        template<typename GetContactListRequestT = Model::GetContactListRequest>
        void GetContactListAsync(const GetContactListRequestT& request, const GetContactListResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::GetContactList, request, handler, context);
        }
 
        virtual Model::GetCustomVerificationEmailTemplateOutcome GetCustomVerificationEmailTemplate(const Model::GetCustomVerificationEmailTemplateRequest& request) const;
 
        template<typename GetCustomVerificationEmailTemplateRequestT = Model::GetCustomVerificationEmailTemplateRequest>
        Model::GetCustomVerificationEmailTemplateOutcomeCallable GetCustomVerificationEmailTemplateCallable(const GetCustomVerificationEmailTemplateRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::GetCustomVerificationEmailTemplate, request);
        }
 
        template<typename GetCustomVerificationEmailTemplateRequestT = Model::GetCustomVerificationEmailTemplateRequest>
        void GetCustomVerificationEmailTemplateAsync(const GetCustomVerificationEmailTemplateRequestT& request, const GetCustomVerificationEmailTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::GetCustomVerificationEmailTemplate, 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(&SESV2Client::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(&SESV2Client::GetDedicatedIp, request, handler, context);
        }
 
        virtual Model::GetDedicatedIpPoolOutcome GetDedicatedIpPool(const Model::GetDedicatedIpPoolRequest& request) const;
 
        template<typename GetDedicatedIpPoolRequestT = Model::GetDedicatedIpPoolRequest>
        Model::GetDedicatedIpPoolOutcomeCallable GetDedicatedIpPoolCallable(const GetDedicatedIpPoolRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::GetDedicatedIpPool, request);
        }
 
        template<typename GetDedicatedIpPoolRequestT = Model::GetDedicatedIpPoolRequest>
        void GetDedicatedIpPoolAsync(const GetDedicatedIpPoolRequestT& request, const GetDedicatedIpPoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::GetDedicatedIpPool, 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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::GetEmailIdentity, request, handler, context);
        }
 
        virtual Model::GetEmailIdentityPoliciesOutcome GetEmailIdentityPolicies(const Model::GetEmailIdentityPoliciesRequest& request) const;
 
        template<typename GetEmailIdentityPoliciesRequestT = Model::GetEmailIdentityPoliciesRequest>
        Model::GetEmailIdentityPoliciesOutcomeCallable GetEmailIdentityPoliciesCallable(const GetEmailIdentityPoliciesRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::GetEmailIdentityPolicies, request);
        }
 
        template<typename GetEmailIdentityPoliciesRequestT = Model::GetEmailIdentityPoliciesRequest>
        void GetEmailIdentityPoliciesAsync(const GetEmailIdentityPoliciesRequestT& request, const GetEmailIdentityPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::GetEmailIdentityPolicies, 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(&SESV2Client::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(&SESV2Client::GetEmailTemplate, 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(&SESV2Client::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(&SESV2Client::GetExportJob, 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(&SESV2Client::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(&SESV2Client::GetImportJob, request, handler, context);
        }
 
        virtual Model::GetMessageInsightsOutcome GetMessageInsights(const Model::GetMessageInsightsRequest& request) const;
 
        template<typename GetMessageInsightsRequestT = Model::GetMessageInsightsRequest>
        Model::GetMessageInsightsOutcomeCallable GetMessageInsightsCallable(const GetMessageInsightsRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::GetMessageInsights, request);
        }
 
        template<typename GetMessageInsightsRequestT = Model::GetMessageInsightsRequest>
        void GetMessageInsightsAsync(const GetMessageInsightsRequestT& request, const GetMessageInsightsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::GetMessageInsights, request, handler, context);
        }
 
        virtual Model::GetSuppressedDestinationOutcome GetSuppressedDestination(const Model::GetSuppressedDestinationRequest& request) const;
 
        template<typename GetSuppressedDestinationRequestT = Model::GetSuppressedDestinationRequest>
        Model::GetSuppressedDestinationOutcomeCallable GetSuppressedDestinationCallable(const GetSuppressedDestinationRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::GetSuppressedDestination, request);
        }
 
        template<typename GetSuppressedDestinationRequestT = Model::GetSuppressedDestinationRequest>
        void GetSuppressedDestinationAsync(const GetSuppressedDestinationRequestT& request, const GetSuppressedDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::GetSuppressedDestination, 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(&SESV2Client::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(&SESV2Client::ListConfigurationSets, request, handler, context);
        }
 
        virtual Model::ListContactListsOutcome ListContactLists(const Model::ListContactListsRequest& request = {}) const;
 
        template<typename ListContactListsRequestT = Model::ListContactListsRequest>
        Model::ListContactListsOutcomeCallable ListContactListsCallable(const ListContactListsRequestT& request = {}) const
        {
            return SubmitCallable(&SESV2Client::ListContactLists, request);
        }
 
        template<typename ListContactListsRequestT = Model::ListContactListsRequest>
        void ListContactListsAsync(const ListContactListsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListContactListsRequestT& request = {}) const
        {
            return SubmitAsync(&SESV2Client::ListContactLists, request, handler, context);
        }
 
        virtual Model::ListContactsOutcome ListContacts(const Model::ListContactsRequest& request) const;
 
        template<typename ListContactsRequestT = Model::ListContactsRequest>
        Model::ListContactsOutcomeCallable ListContactsCallable(const ListContactsRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::ListContacts, request);
        }
 
        template<typename ListContactsRequestT = Model::ListContactsRequest>
        void ListContactsAsync(const ListContactsRequestT& request, const ListContactsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::ListContacts, request, handler, context);
        }
 
        virtual Model::ListCustomVerificationEmailTemplatesOutcome ListCustomVerificationEmailTemplates(const Model::ListCustomVerificationEmailTemplatesRequest& request = {}) const;
 
        template<typename ListCustomVerificationEmailTemplatesRequestT = Model::ListCustomVerificationEmailTemplatesRequest>
        Model::ListCustomVerificationEmailTemplatesOutcomeCallable ListCustomVerificationEmailTemplatesCallable(const ListCustomVerificationEmailTemplatesRequestT& request = {}) const
        {
            return SubmitCallable(&SESV2Client::ListCustomVerificationEmailTemplates, request);
        }
 
        template<typename ListCustomVerificationEmailTemplatesRequestT = Model::ListCustomVerificationEmailTemplatesRequest>
        void ListCustomVerificationEmailTemplatesAsync(const ListCustomVerificationEmailTemplatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCustomVerificationEmailTemplatesRequestT& request = {}) const
        {
            return SubmitAsync(&SESV2Client::ListCustomVerificationEmailTemplates, 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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::ListEmailIdentities, request, handler, context);
        }
 
        virtual Model::ListEmailTemplatesOutcome ListEmailTemplates(const Model::ListEmailTemplatesRequest& request = {}) const;
 
        template<typename ListEmailTemplatesRequestT = Model::ListEmailTemplatesRequest>
        Model::ListEmailTemplatesOutcomeCallable ListEmailTemplatesCallable(const ListEmailTemplatesRequestT& request = {}) const
        {
            return SubmitCallable(&SESV2Client::ListEmailTemplates, request);
        }
 
        template<typename ListEmailTemplatesRequestT = Model::ListEmailTemplatesRequest>
        void ListEmailTemplatesAsync(const ListEmailTemplatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListEmailTemplatesRequestT& request = {}) const
        {
            return SubmitAsync(&SESV2Client::ListEmailTemplates, request, handler, context);
        }
 
        virtual Model::ListExportJobsOutcome ListExportJobs(const Model::ListExportJobsRequest& request = {}) const;
 
        template<typename ListExportJobsRequestT = Model::ListExportJobsRequest>
        Model::ListExportJobsOutcomeCallable ListExportJobsCallable(const ListExportJobsRequestT& request = {}) const
        {
            return SubmitCallable(&SESV2Client::ListExportJobs, request);
        }
 
        template<typename ListExportJobsRequestT = Model::ListExportJobsRequest>
        void ListExportJobsAsync(const ListExportJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListExportJobsRequestT& request = {}) const
        {
            return SubmitAsync(&SESV2Client::ListExportJobs, request, handler, context);
        }
 
        virtual Model::ListImportJobsOutcome ListImportJobs(const Model::ListImportJobsRequest& request = {}) const;
 
        template<typename ListImportJobsRequestT = Model::ListImportJobsRequest>
        Model::ListImportJobsOutcomeCallable ListImportJobsCallable(const ListImportJobsRequestT& request = {}) const
        {
            return SubmitCallable(&SESV2Client::ListImportJobs, request);
        }
 
        template<typename ListImportJobsRequestT = Model::ListImportJobsRequest>
        void ListImportJobsAsync(const ListImportJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListImportJobsRequestT& request = {}) const
        {
            return SubmitAsync(&SESV2Client::ListImportJobs, request, handler, context);
        }
 
        virtual Model::ListRecommendationsOutcome ListRecommendations(const Model::ListRecommendationsRequest& request = {}) const;
 
        template<typename ListRecommendationsRequestT = Model::ListRecommendationsRequest>
        Model::ListRecommendationsOutcomeCallable ListRecommendationsCallable(const ListRecommendationsRequestT& request = {}) const
        {
            return SubmitCallable(&SESV2Client::ListRecommendations, request);
        }
 
        template<typename ListRecommendationsRequestT = Model::ListRecommendationsRequest>
        void ListRecommendationsAsync(const ListRecommendationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListRecommendationsRequestT& request = {}) const
        {
            return SubmitAsync(&SESV2Client::ListRecommendations, request, handler, context);
        }
 
        virtual Model::ListSuppressedDestinationsOutcome ListSuppressedDestinations(const Model::ListSuppressedDestinationsRequest& request = {}) const;
 
        template<typename ListSuppressedDestinationsRequestT = Model::ListSuppressedDestinationsRequest>
        Model::ListSuppressedDestinationsOutcomeCallable ListSuppressedDestinationsCallable(const ListSuppressedDestinationsRequestT& request = {}) const
        {
            return SubmitCallable(&SESV2Client::ListSuppressedDestinations, request);
        }
 
        template<typename ListSuppressedDestinationsRequestT = Model::ListSuppressedDestinationsRequest>
        void ListSuppressedDestinationsAsync(const ListSuppressedDestinationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSuppressedDestinationsRequestT& request = {}) const
        {
            return SubmitAsync(&SESV2Client::ListSuppressedDestinations, 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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::PutAccountDedicatedIpWarmupAttributes, request, handler, context);
        }
 
        virtual Model::PutAccountDetailsOutcome PutAccountDetails(const Model::PutAccountDetailsRequest& request) const;
 
        template<typename PutAccountDetailsRequestT = Model::PutAccountDetailsRequest>
        Model::PutAccountDetailsOutcomeCallable PutAccountDetailsCallable(const PutAccountDetailsRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::PutAccountDetails, request);
        }
 
        template<typename PutAccountDetailsRequestT = Model::PutAccountDetailsRequest>
        void PutAccountDetailsAsync(const PutAccountDetailsRequestT& request, const PutAccountDetailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::PutAccountDetails, 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(&SESV2Client::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(&SESV2Client::PutAccountSendingAttributes, request, handler, context);
        }
 
        virtual Model::PutAccountSuppressionAttributesOutcome PutAccountSuppressionAttributes(const Model::PutAccountSuppressionAttributesRequest& request = {}) const;
 
        template<typename PutAccountSuppressionAttributesRequestT = Model::PutAccountSuppressionAttributesRequest>
        Model::PutAccountSuppressionAttributesOutcomeCallable PutAccountSuppressionAttributesCallable(const PutAccountSuppressionAttributesRequestT& request = {}) const
        {
            return SubmitCallable(&SESV2Client::PutAccountSuppressionAttributes, request);
        }
 
        template<typename PutAccountSuppressionAttributesRequestT = Model::PutAccountSuppressionAttributesRequest>
        void PutAccountSuppressionAttributesAsync(const PutAccountSuppressionAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const PutAccountSuppressionAttributesRequestT& request = {}) const
        {
            return SubmitAsync(&SESV2Client::PutAccountSuppressionAttributes, request, handler, context);
        }
 
        virtual Model::PutAccountVdmAttributesOutcome PutAccountVdmAttributes(const Model::PutAccountVdmAttributesRequest& request) const;
 
        template<typename PutAccountVdmAttributesRequestT = Model::PutAccountVdmAttributesRequest>
        Model::PutAccountVdmAttributesOutcomeCallable PutAccountVdmAttributesCallable(const PutAccountVdmAttributesRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::PutAccountVdmAttributes, request);
        }
 
        template<typename PutAccountVdmAttributesRequestT = Model::PutAccountVdmAttributesRequest>
        void PutAccountVdmAttributesAsync(const PutAccountVdmAttributesRequestT& request, const PutAccountVdmAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::PutAccountVdmAttributes, 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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::PutConfigurationSetSendingOptions, request, handler, context);
        }
 
        virtual Model::PutConfigurationSetSuppressionOptionsOutcome PutConfigurationSetSuppressionOptions(const Model::PutConfigurationSetSuppressionOptionsRequest& request) const;
 
        template<typename PutConfigurationSetSuppressionOptionsRequestT = Model::PutConfigurationSetSuppressionOptionsRequest>
        Model::PutConfigurationSetSuppressionOptionsOutcomeCallable PutConfigurationSetSuppressionOptionsCallable(const PutConfigurationSetSuppressionOptionsRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::PutConfigurationSetSuppressionOptions, request);
        }
 
        template<typename PutConfigurationSetSuppressionOptionsRequestT = Model::PutConfigurationSetSuppressionOptionsRequest>
        void PutConfigurationSetSuppressionOptionsAsync(const PutConfigurationSetSuppressionOptionsRequestT& request, const PutConfigurationSetSuppressionOptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::PutConfigurationSetSuppressionOptions, 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(&SESV2Client::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(&SESV2Client::PutConfigurationSetTrackingOptions, request, handler, context);
        }
 
        virtual Model::PutConfigurationSetVdmOptionsOutcome PutConfigurationSetVdmOptions(const Model::PutConfigurationSetVdmOptionsRequest& request) const;
 
        template<typename PutConfigurationSetVdmOptionsRequestT = Model::PutConfigurationSetVdmOptionsRequest>
        Model::PutConfigurationSetVdmOptionsOutcomeCallable PutConfigurationSetVdmOptionsCallable(const PutConfigurationSetVdmOptionsRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::PutConfigurationSetVdmOptions, request);
        }
 
        template<typename PutConfigurationSetVdmOptionsRequestT = Model::PutConfigurationSetVdmOptionsRequest>
        void PutConfigurationSetVdmOptionsAsync(const PutConfigurationSetVdmOptionsRequestT& request, const PutConfigurationSetVdmOptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::PutConfigurationSetVdmOptions, 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(&SESV2Client::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(&SESV2Client::PutDedicatedIpInPool, request, handler, context);
        }
 
        virtual Model::PutDedicatedIpPoolScalingAttributesOutcome PutDedicatedIpPoolScalingAttributes(const Model::PutDedicatedIpPoolScalingAttributesRequest& request) const;
 
        template<typename PutDedicatedIpPoolScalingAttributesRequestT = Model::PutDedicatedIpPoolScalingAttributesRequest>
        Model::PutDedicatedIpPoolScalingAttributesOutcomeCallable PutDedicatedIpPoolScalingAttributesCallable(const PutDedicatedIpPoolScalingAttributesRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::PutDedicatedIpPoolScalingAttributes, request);
        }
 
        template<typename PutDedicatedIpPoolScalingAttributesRequestT = Model::PutDedicatedIpPoolScalingAttributesRequest>
        void PutDedicatedIpPoolScalingAttributesAsync(const PutDedicatedIpPoolScalingAttributesRequestT& request, const PutDedicatedIpPoolScalingAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::PutDedicatedIpPoolScalingAttributes, 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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::PutDeliverabilityDashboardOption, request, handler, context);
        }
 
        virtual Model::PutEmailIdentityConfigurationSetAttributesOutcome PutEmailIdentityConfigurationSetAttributes(const Model::PutEmailIdentityConfigurationSetAttributesRequest& request) const;
 
        template<typename PutEmailIdentityConfigurationSetAttributesRequestT = Model::PutEmailIdentityConfigurationSetAttributesRequest>
        Model::PutEmailIdentityConfigurationSetAttributesOutcomeCallable PutEmailIdentityConfigurationSetAttributesCallable(const PutEmailIdentityConfigurationSetAttributesRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::PutEmailIdentityConfigurationSetAttributes, request);
        }
 
        template<typename PutEmailIdentityConfigurationSetAttributesRequestT = Model::PutEmailIdentityConfigurationSetAttributesRequest>
        void PutEmailIdentityConfigurationSetAttributesAsync(const PutEmailIdentityConfigurationSetAttributesRequestT& request, const PutEmailIdentityConfigurationSetAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::PutEmailIdentityConfigurationSetAttributes, 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(&SESV2Client::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(&SESV2Client::PutEmailIdentityDkimAttributes, request, handler, context);
        }
 
        virtual Model::PutEmailIdentityDkimSigningAttributesOutcome PutEmailIdentityDkimSigningAttributes(const Model::PutEmailIdentityDkimSigningAttributesRequest& request) const;
 
        template<typename PutEmailIdentityDkimSigningAttributesRequestT = Model::PutEmailIdentityDkimSigningAttributesRequest>
        Model::PutEmailIdentityDkimSigningAttributesOutcomeCallable PutEmailIdentityDkimSigningAttributesCallable(const PutEmailIdentityDkimSigningAttributesRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::PutEmailIdentityDkimSigningAttributes, request);
        }
 
        template<typename PutEmailIdentityDkimSigningAttributesRequestT = Model::PutEmailIdentityDkimSigningAttributesRequest>
        void PutEmailIdentityDkimSigningAttributesAsync(const PutEmailIdentityDkimSigningAttributesRequestT& request, const PutEmailIdentityDkimSigningAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::PutEmailIdentityDkimSigningAttributes, 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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::PutEmailIdentityMailFromAttributes, request, handler, context);
        }
 
        virtual Model::PutSuppressedDestinationOutcome PutSuppressedDestination(const Model::PutSuppressedDestinationRequest& request) const;
 
        template<typename PutSuppressedDestinationRequestT = Model::PutSuppressedDestinationRequest>
        Model::PutSuppressedDestinationOutcomeCallable PutSuppressedDestinationCallable(const PutSuppressedDestinationRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::PutSuppressedDestination, request);
        }
 
        template<typename PutSuppressedDestinationRequestT = Model::PutSuppressedDestinationRequest>
        void PutSuppressedDestinationAsync(const PutSuppressedDestinationRequestT& request, const PutSuppressedDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::PutSuppressedDestination, request, handler, context);
        }
 
        virtual Model::SendBulkEmailOutcome SendBulkEmail(const Model::SendBulkEmailRequest& request) const;
 
        template<typename SendBulkEmailRequestT = Model::SendBulkEmailRequest>
        Model::SendBulkEmailOutcomeCallable SendBulkEmailCallable(const SendBulkEmailRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::SendBulkEmail, request);
        }
 
        template<typename SendBulkEmailRequestT = Model::SendBulkEmailRequest>
        void SendBulkEmailAsync(const SendBulkEmailRequestT& request, const SendBulkEmailResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::SendBulkEmail, request, handler, context);
        }
 
        virtual Model::SendCustomVerificationEmailOutcome SendCustomVerificationEmail(const Model::SendCustomVerificationEmailRequest& request) const;
 
        template<typename SendCustomVerificationEmailRequestT = Model::SendCustomVerificationEmailRequest>
        Model::SendCustomVerificationEmailOutcomeCallable SendCustomVerificationEmailCallable(const SendCustomVerificationEmailRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::SendCustomVerificationEmail, request);
        }
 
        template<typename SendCustomVerificationEmailRequestT = Model::SendCustomVerificationEmailRequest>
        void SendCustomVerificationEmailAsync(const SendCustomVerificationEmailRequestT& request, const SendCustomVerificationEmailResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::SendCustomVerificationEmail, 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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::TagResource, request, handler, context);
        }
 
        virtual Model::TestRenderEmailTemplateOutcome TestRenderEmailTemplate(const Model::TestRenderEmailTemplateRequest& request) const;
 
        template<typename TestRenderEmailTemplateRequestT = Model::TestRenderEmailTemplateRequest>
        Model::TestRenderEmailTemplateOutcomeCallable TestRenderEmailTemplateCallable(const TestRenderEmailTemplateRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::TestRenderEmailTemplate, request);
        }
 
        template<typename TestRenderEmailTemplateRequestT = Model::TestRenderEmailTemplateRequest>
        void TestRenderEmailTemplateAsync(const TestRenderEmailTemplateRequestT& request, const TestRenderEmailTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::TestRenderEmailTemplate, 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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::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(&SESV2Client::UpdateConfigurationSetEventDestination, request, handler, context);
        }
 
        virtual Model::UpdateContactOutcome UpdateContact(const Model::UpdateContactRequest& request) const;
 
        template<typename UpdateContactRequestT = Model::UpdateContactRequest>
        Model::UpdateContactOutcomeCallable UpdateContactCallable(const UpdateContactRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::UpdateContact, request);
        }
 
        template<typename UpdateContactRequestT = Model::UpdateContactRequest>
        void UpdateContactAsync(const UpdateContactRequestT& request, const UpdateContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::UpdateContact, request, handler, context);
        }
 
        virtual Model::UpdateContactListOutcome UpdateContactList(const Model::UpdateContactListRequest& request) const;
 
        template<typename UpdateContactListRequestT = Model::UpdateContactListRequest>
        Model::UpdateContactListOutcomeCallable UpdateContactListCallable(const UpdateContactListRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::UpdateContactList, request);
        }
 
        template<typename UpdateContactListRequestT = Model::UpdateContactListRequest>
        void UpdateContactListAsync(const UpdateContactListRequestT& request, const UpdateContactListResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::UpdateContactList, request, handler, context);
        }
 
        virtual Model::UpdateCustomVerificationEmailTemplateOutcome UpdateCustomVerificationEmailTemplate(const Model::UpdateCustomVerificationEmailTemplateRequest& request) const;
 
        template<typename UpdateCustomVerificationEmailTemplateRequestT = Model::UpdateCustomVerificationEmailTemplateRequest>
        Model::UpdateCustomVerificationEmailTemplateOutcomeCallable UpdateCustomVerificationEmailTemplateCallable(const UpdateCustomVerificationEmailTemplateRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::UpdateCustomVerificationEmailTemplate, request);
        }
 
        template<typename UpdateCustomVerificationEmailTemplateRequestT = Model::UpdateCustomVerificationEmailTemplateRequest>
        void UpdateCustomVerificationEmailTemplateAsync(const UpdateCustomVerificationEmailTemplateRequestT& request, const UpdateCustomVerificationEmailTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::UpdateCustomVerificationEmailTemplate, request, handler, context);
        }
 
        virtual Model::UpdateEmailIdentityPolicyOutcome UpdateEmailIdentityPolicy(const Model::UpdateEmailIdentityPolicyRequest& request) const;
 
        template<typename UpdateEmailIdentityPolicyRequestT = Model::UpdateEmailIdentityPolicyRequest>
        Model::UpdateEmailIdentityPolicyOutcomeCallable UpdateEmailIdentityPolicyCallable(const UpdateEmailIdentityPolicyRequestT& request) const
        {
            return SubmitCallable(&SESV2Client::UpdateEmailIdentityPolicy, request);
        }
 
        template<typename UpdateEmailIdentityPolicyRequestT = Model::UpdateEmailIdentityPolicyRequest>
        void UpdateEmailIdentityPolicyAsync(const UpdateEmailIdentityPolicyRequestT& request, const UpdateEmailIdentityPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESV2Client::UpdateEmailIdentityPolicy, 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(&SESV2Client::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(&SESV2Client::UpdateEmailTemplate, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<SESV2EndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<SESV2Client>;
      void init(const SESV2ClientConfiguration& clientConfiguration);
 
      SESV2ClientConfiguration m_clientConfiguration;
      std::shared_ptr<SESV2EndpointProviderBase> m_endpointProvider;
  };
 
} // namespace SESV2
} // namespace Aws