SESClient.h

 
#pragma once
#include <aws/email/SES_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/email/SESServiceClientModel.h>
 
namespace Aws
{
namespace SES
{
  class AWS_SES_API SESClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods<SESClient>
  {
    public:
      typedef Aws::Client::AWSXMLClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef SESClientConfiguration ClientConfigurationType;
      typedef SESEndpointProvider EndpointProviderType;
 
        SESClient(const Aws::SES::SESClientConfiguration& clientConfiguration = Aws::SES::SESClientConfiguration(),
                  std::shared_ptr<SESEndpointProviderBase> endpointProvider = nullptr);
 
        SESClient(const Aws::Auth::AWSCredentials& credentials,
                  std::shared_ptr<SESEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::SES::SESClientConfiguration& clientConfiguration = Aws::SES::SESClientConfiguration());
 
        SESClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<SESEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::SES::SESClientConfiguration& clientConfiguration = Aws::SES::SESClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        SESClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SESClient(const Aws::Auth::AWSCredentials& credentials,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SESClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~SESClient();
 
 
        Aws::String ConvertRequestToPresignedUrl(const Aws::AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const;
 
 
        virtual Model::CloneReceiptRuleSetOutcome CloneReceiptRuleSet(const Model::CloneReceiptRuleSetRequest& request) const;
 
        template<typename CloneReceiptRuleSetRequestT = Model::CloneReceiptRuleSetRequest>
        Model::CloneReceiptRuleSetOutcomeCallable CloneReceiptRuleSetCallable(const CloneReceiptRuleSetRequestT& request) const
        {
            return SubmitCallable(&SESClient::CloneReceiptRuleSet, request);
        }
 
        template<typename CloneReceiptRuleSetRequestT = Model::CloneReceiptRuleSetRequest>
        void CloneReceiptRuleSetAsync(const CloneReceiptRuleSetRequestT& request, const CloneReceiptRuleSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::CloneReceiptRuleSet, 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(&SESClient::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(&SESClient::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(&SESClient::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(&SESClient::CreateConfigurationSetEventDestination, request, handler, context);
        }
 
        virtual Model::CreateConfigurationSetTrackingOptionsOutcome CreateConfigurationSetTrackingOptions(const Model::CreateConfigurationSetTrackingOptionsRequest& request) const;
 
        template<typename CreateConfigurationSetTrackingOptionsRequestT = Model::CreateConfigurationSetTrackingOptionsRequest>
        Model::CreateConfigurationSetTrackingOptionsOutcomeCallable CreateConfigurationSetTrackingOptionsCallable(const CreateConfigurationSetTrackingOptionsRequestT& request) const
        {
            return SubmitCallable(&SESClient::CreateConfigurationSetTrackingOptions, request);
        }
 
        template<typename CreateConfigurationSetTrackingOptionsRequestT = Model::CreateConfigurationSetTrackingOptionsRequest>
        void CreateConfigurationSetTrackingOptionsAsync(const CreateConfigurationSetTrackingOptionsRequestT& request, const CreateConfigurationSetTrackingOptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::CreateConfigurationSetTrackingOptions, 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(&SESClient::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(&SESClient::CreateCustomVerificationEmailTemplate, request, handler, context);
        }
 
        virtual Model::CreateReceiptFilterOutcome CreateReceiptFilter(const Model::CreateReceiptFilterRequest& request) const;
 
        template<typename CreateReceiptFilterRequestT = Model::CreateReceiptFilterRequest>
        Model::CreateReceiptFilterOutcomeCallable CreateReceiptFilterCallable(const CreateReceiptFilterRequestT& request) const
        {
            return SubmitCallable(&SESClient::CreateReceiptFilter, request);
        }
 
        template<typename CreateReceiptFilterRequestT = Model::CreateReceiptFilterRequest>
        void CreateReceiptFilterAsync(const CreateReceiptFilterRequestT& request, const CreateReceiptFilterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::CreateReceiptFilter, request, handler, context);
        }
 
        virtual Model::CreateReceiptRuleOutcome CreateReceiptRule(const Model::CreateReceiptRuleRequest& request) const;
 
        template<typename CreateReceiptRuleRequestT = Model::CreateReceiptRuleRequest>
        Model::CreateReceiptRuleOutcomeCallable CreateReceiptRuleCallable(const CreateReceiptRuleRequestT& request) const
        {
            return SubmitCallable(&SESClient::CreateReceiptRule, request);
        }
 
        template<typename CreateReceiptRuleRequestT = Model::CreateReceiptRuleRequest>
        void CreateReceiptRuleAsync(const CreateReceiptRuleRequestT& request, const CreateReceiptRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::CreateReceiptRule, request, handler, context);
        }
 
        virtual Model::CreateReceiptRuleSetOutcome CreateReceiptRuleSet(const Model::CreateReceiptRuleSetRequest& request) const;
 
        template<typename CreateReceiptRuleSetRequestT = Model::CreateReceiptRuleSetRequest>
        Model::CreateReceiptRuleSetOutcomeCallable CreateReceiptRuleSetCallable(const CreateReceiptRuleSetRequestT& request) const
        {
            return SubmitCallable(&SESClient::CreateReceiptRuleSet, request);
        }
 
        template<typename CreateReceiptRuleSetRequestT = Model::CreateReceiptRuleSetRequest>
        void CreateReceiptRuleSetAsync(const CreateReceiptRuleSetRequestT& request, const CreateReceiptRuleSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::CreateReceiptRuleSet, request, handler, context);
        }
 
        virtual Model::CreateTemplateOutcome CreateTemplate(const Model::CreateTemplateRequest& request) const;
 
        template<typename CreateTemplateRequestT = Model::CreateTemplateRequest>
        Model::CreateTemplateOutcomeCallable CreateTemplateCallable(const CreateTemplateRequestT& request) const
        {
            return SubmitCallable(&SESClient::CreateTemplate, request);
        }
 
        template<typename CreateTemplateRequestT = Model::CreateTemplateRequest>
        void CreateTemplateAsync(const CreateTemplateRequestT& request, const CreateTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::CreateTemplate, 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(&SESClient::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(&SESClient::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(&SESClient::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(&SESClient::DeleteConfigurationSetEventDestination, request, handler, context);
        }
 
        virtual Model::DeleteConfigurationSetTrackingOptionsOutcome DeleteConfigurationSetTrackingOptions(const Model::DeleteConfigurationSetTrackingOptionsRequest& request) const;
 
        template<typename DeleteConfigurationSetTrackingOptionsRequestT = Model::DeleteConfigurationSetTrackingOptionsRequest>
        Model::DeleteConfigurationSetTrackingOptionsOutcomeCallable DeleteConfigurationSetTrackingOptionsCallable(const DeleteConfigurationSetTrackingOptionsRequestT& request) const
        {
            return SubmitCallable(&SESClient::DeleteConfigurationSetTrackingOptions, request);
        }
 
        template<typename DeleteConfigurationSetTrackingOptionsRequestT = Model::DeleteConfigurationSetTrackingOptionsRequest>
        void DeleteConfigurationSetTrackingOptionsAsync(const DeleteConfigurationSetTrackingOptionsRequestT& request, const DeleteConfigurationSetTrackingOptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::DeleteConfigurationSetTrackingOptions, 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(&SESClient::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(&SESClient::DeleteCustomVerificationEmailTemplate, request, handler, context);
        }
 
        virtual Model::DeleteIdentityOutcome DeleteIdentity(const Model::DeleteIdentityRequest& request) const;
 
        template<typename DeleteIdentityRequestT = Model::DeleteIdentityRequest>
        Model::DeleteIdentityOutcomeCallable DeleteIdentityCallable(const DeleteIdentityRequestT& request) const
        {
            return SubmitCallable(&SESClient::DeleteIdentity, request);
        }
 
        template<typename DeleteIdentityRequestT = Model::DeleteIdentityRequest>
        void DeleteIdentityAsync(const DeleteIdentityRequestT& request, const DeleteIdentityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::DeleteIdentity, request, handler, context);
        }
 
        virtual Model::DeleteIdentityPolicyOutcome DeleteIdentityPolicy(const Model::DeleteIdentityPolicyRequest& request) const;
 
        template<typename DeleteIdentityPolicyRequestT = Model::DeleteIdentityPolicyRequest>
        Model::DeleteIdentityPolicyOutcomeCallable DeleteIdentityPolicyCallable(const DeleteIdentityPolicyRequestT& request) const
        {
            return SubmitCallable(&SESClient::DeleteIdentityPolicy, request);
        }
 
        template<typename DeleteIdentityPolicyRequestT = Model::DeleteIdentityPolicyRequest>
        void DeleteIdentityPolicyAsync(const DeleteIdentityPolicyRequestT& request, const DeleteIdentityPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::DeleteIdentityPolicy, request, handler, context);
        }
 
        virtual Model::DeleteReceiptFilterOutcome DeleteReceiptFilter(const Model::DeleteReceiptFilterRequest& request) const;
 
        template<typename DeleteReceiptFilterRequestT = Model::DeleteReceiptFilterRequest>
        Model::DeleteReceiptFilterOutcomeCallable DeleteReceiptFilterCallable(const DeleteReceiptFilterRequestT& request) const
        {
            return SubmitCallable(&SESClient::DeleteReceiptFilter, request);
        }
 
        template<typename DeleteReceiptFilterRequestT = Model::DeleteReceiptFilterRequest>
        void DeleteReceiptFilterAsync(const DeleteReceiptFilterRequestT& request, const DeleteReceiptFilterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::DeleteReceiptFilter, request, handler, context);
        }
 
        virtual Model::DeleteReceiptRuleOutcome DeleteReceiptRule(const Model::DeleteReceiptRuleRequest& request) const;
 
        template<typename DeleteReceiptRuleRequestT = Model::DeleteReceiptRuleRequest>
        Model::DeleteReceiptRuleOutcomeCallable DeleteReceiptRuleCallable(const DeleteReceiptRuleRequestT& request) const
        {
            return SubmitCallable(&SESClient::DeleteReceiptRule, request);
        }
 
        template<typename DeleteReceiptRuleRequestT = Model::DeleteReceiptRuleRequest>
        void DeleteReceiptRuleAsync(const DeleteReceiptRuleRequestT& request, const DeleteReceiptRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::DeleteReceiptRule, request, handler, context);
        }
 
        virtual Model::DeleteReceiptRuleSetOutcome DeleteReceiptRuleSet(const Model::DeleteReceiptRuleSetRequest& request) const;
 
        template<typename DeleteReceiptRuleSetRequestT = Model::DeleteReceiptRuleSetRequest>
        Model::DeleteReceiptRuleSetOutcomeCallable DeleteReceiptRuleSetCallable(const DeleteReceiptRuleSetRequestT& request) const
        {
            return SubmitCallable(&SESClient::DeleteReceiptRuleSet, request);
        }
 
        template<typename DeleteReceiptRuleSetRequestT = Model::DeleteReceiptRuleSetRequest>
        void DeleteReceiptRuleSetAsync(const DeleteReceiptRuleSetRequestT& request, const DeleteReceiptRuleSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::DeleteReceiptRuleSet, request, handler, context);
        }
 
        virtual Model::DeleteTemplateOutcome DeleteTemplate(const Model::DeleteTemplateRequest& request) const;
 
        template<typename DeleteTemplateRequestT = Model::DeleteTemplateRequest>
        Model::DeleteTemplateOutcomeCallable DeleteTemplateCallable(const DeleteTemplateRequestT& request) const
        {
            return SubmitCallable(&SESClient::DeleteTemplate, request);
        }
 
        template<typename DeleteTemplateRequestT = Model::DeleteTemplateRequest>
        void DeleteTemplateAsync(const DeleteTemplateRequestT& request, const DeleteTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::DeleteTemplate, request, handler, context);
        }
 
        virtual Model::DeleteVerifiedEmailAddressOutcome DeleteVerifiedEmailAddress(const Model::DeleteVerifiedEmailAddressRequest& request) const;
 
        template<typename DeleteVerifiedEmailAddressRequestT = Model::DeleteVerifiedEmailAddressRequest>
        Model::DeleteVerifiedEmailAddressOutcomeCallable DeleteVerifiedEmailAddressCallable(const DeleteVerifiedEmailAddressRequestT& request) const
        {
            return SubmitCallable(&SESClient::DeleteVerifiedEmailAddress, request);
        }
 
        template<typename DeleteVerifiedEmailAddressRequestT = Model::DeleteVerifiedEmailAddressRequest>
        void DeleteVerifiedEmailAddressAsync(const DeleteVerifiedEmailAddressRequestT& request, const DeleteVerifiedEmailAddressResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::DeleteVerifiedEmailAddress, request, handler, context);
        }
 
        virtual Model::DescribeActiveReceiptRuleSetOutcome DescribeActiveReceiptRuleSet(const Model::DescribeActiveReceiptRuleSetRequest& request = {}) const;
 
        template<typename DescribeActiveReceiptRuleSetRequestT = Model::DescribeActiveReceiptRuleSetRequest>
        Model::DescribeActiveReceiptRuleSetOutcomeCallable DescribeActiveReceiptRuleSetCallable(const DescribeActiveReceiptRuleSetRequestT& request = {}) const
        {
            return SubmitCallable(&SESClient::DescribeActiveReceiptRuleSet, request);
        }
 
        template<typename DescribeActiveReceiptRuleSetRequestT = Model::DescribeActiveReceiptRuleSetRequest>
        void DescribeActiveReceiptRuleSetAsync(const DescribeActiveReceiptRuleSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeActiveReceiptRuleSetRequestT& request = {}) const
        {
            return SubmitAsync(&SESClient::DescribeActiveReceiptRuleSet, request, handler, context);
        }
 
        virtual Model::DescribeConfigurationSetOutcome DescribeConfigurationSet(const Model::DescribeConfigurationSetRequest& request) const;
 
        template<typename DescribeConfigurationSetRequestT = Model::DescribeConfigurationSetRequest>
        Model::DescribeConfigurationSetOutcomeCallable DescribeConfigurationSetCallable(const DescribeConfigurationSetRequestT& request) const
        {
            return SubmitCallable(&SESClient::DescribeConfigurationSet, request);
        }
 
        template<typename DescribeConfigurationSetRequestT = Model::DescribeConfigurationSetRequest>
        void DescribeConfigurationSetAsync(const DescribeConfigurationSetRequestT& request, const DescribeConfigurationSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::DescribeConfigurationSet, request, handler, context);
        }
 
        virtual Model::DescribeReceiptRuleOutcome DescribeReceiptRule(const Model::DescribeReceiptRuleRequest& request) const;
 
        template<typename DescribeReceiptRuleRequestT = Model::DescribeReceiptRuleRequest>
        Model::DescribeReceiptRuleOutcomeCallable DescribeReceiptRuleCallable(const DescribeReceiptRuleRequestT& request) const
        {
            return SubmitCallable(&SESClient::DescribeReceiptRule, request);
        }
 
        template<typename DescribeReceiptRuleRequestT = Model::DescribeReceiptRuleRequest>
        void DescribeReceiptRuleAsync(const DescribeReceiptRuleRequestT& request, const DescribeReceiptRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::DescribeReceiptRule, request, handler, context);
        }
 
        virtual Model::DescribeReceiptRuleSetOutcome DescribeReceiptRuleSet(const Model::DescribeReceiptRuleSetRequest& request) const;
 
        template<typename DescribeReceiptRuleSetRequestT = Model::DescribeReceiptRuleSetRequest>
        Model::DescribeReceiptRuleSetOutcomeCallable DescribeReceiptRuleSetCallable(const DescribeReceiptRuleSetRequestT& request) const
        {
            return SubmitCallable(&SESClient::DescribeReceiptRuleSet, request);
        }
 
        template<typename DescribeReceiptRuleSetRequestT = Model::DescribeReceiptRuleSetRequest>
        void DescribeReceiptRuleSetAsync(const DescribeReceiptRuleSetRequestT& request, const DescribeReceiptRuleSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::DescribeReceiptRuleSet, request, handler, context);
        }
 
        virtual Model::GetAccountSendingEnabledOutcome GetAccountSendingEnabled(const Model::GetAccountSendingEnabledRequest& request = {}) const;
 
        template<typename GetAccountSendingEnabledRequestT = Model::GetAccountSendingEnabledRequest>
        Model::GetAccountSendingEnabledOutcomeCallable GetAccountSendingEnabledCallable(const GetAccountSendingEnabledRequestT& request = {}) const
        {
            return SubmitCallable(&SESClient::GetAccountSendingEnabled, request);
        }
 
        template<typename GetAccountSendingEnabledRequestT = Model::GetAccountSendingEnabledRequest>
        void GetAccountSendingEnabledAsync(const GetAccountSendingEnabledResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetAccountSendingEnabledRequestT& request = {}) const
        {
            return SubmitAsync(&SESClient::GetAccountSendingEnabled, 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(&SESClient::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(&SESClient::GetCustomVerificationEmailTemplate, request, handler, context);
        }
 
        virtual Model::GetIdentityDkimAttributesOutcome GetIdentityDkimAttributes(const Model::GetIdentityDkimAttributesRequest& request) const;
 
        template<typename GetIdentityDkimAttributesRequestT = Model::GetIdentityDkimAttributesRequest>
        Model::GetIdentityDkimAttributesOutcomeCallable GetIdentityDkimAttributesCallable(const GetIdentityDkimAttributesRequestT& request) const
        {
            return SubmitCallable(&SESClient::GetIdentityDkimAttributes, request);
        }
 
        template<typename GetIdentityDkimAttributesRequestT = Model::GetIdentityDkimAttributesRequest>
        void GetIdentityDkimAttributesAsync(const GetIdentityDkimAttributesRequestT& request, const GetIdentityDkimAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::GetIdentityDkimAttributes, request, handler, context);
        }
 
        virtual Model::GetIdentityMailFromDomainAttributesOutcome GetIdentityMailFromDomainAttributes(const Model::GetIdentityMailFromDomainAttributesRequest& request) const;
 
        template<typename GetIdentityMailFromDomainAttributesRequestT = Model::GetIdentityMailFromDomainAttributesRequest>
        Model::GetIdentityMailFromDomainAttributesOutcomeCallable GetIdentityMailFromDomainAttributesCallable(const GetIdentityMailFromDomainAttributesRequestT& request) const
        {
            return SubmitCallable(&SESClient::GetIdentityMailFromDomainAttributes, request);
        }
 
        template<typename GetIdentityMailFromDomainAttributesRequestT = Model::GetIdentityMailFromDomainAttributesRequest>
        void GetIdentityMailFromDomainAttributesAsync(const GetIdentityMailFromDomainAttributesRequestT& request, const GetIdentityMailFromDomainAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::GetIdentityMailFromDomainAttributes, request, handler, context);
        }
 
        virtual Model::GetIdentityNotificationAttributesOutcome GetIdentityNotificationAttributes(const Model::GetIdentityNotificationAttributesRequest& request) const;
 
        template<typename GetIdentityNotificationAttributesRequestT = Model::GetIdentityNotificationAttributesRequest>
        Model::GetIdentityNotificationAttributesOutcomeCallable GetIdentityNotificationAttributesCallable(const GetIdentityNotificationAttributesRequestT& request) const
        {
            return SubmitCallable(&SESClient::GetIdentityNotificationAttributes, request);
        }
 
        template<typename GetIdentityNotificationAttributesRequestT = Model::GetIdentityNotificationAttributesRequest>
        void GetIdentityNotificationAttributesAsync(const GetIdentityNotificationAttributesRequestT& request, const GetIdentityNotificationAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::GetIdentityNotificationAttributes, request, handler, context);
        }
 
        virtual Model::GetIdentityPoliciesOutcome GetIdentityPolicies(const Model::GetIdentityPoliciesRequest& request) const;
 
        template<typename GetIdentityPoliciesRequestT = Model::GetIdentityPoliciesRequest>
        Model::GetIdentityPoliciesOutcomeCallable GetIdentityPoliciesCallable(const GetIdentityPoliciesRequestT& request) const
        {
            return SubmitCallable(&SESClient::GetIdentityPolicies, request);
        }
 
        template<typename GetIdentityPoliciesRequestT = Model::GetIdentityPoliciesRequest>
        void GetIdentityPoliciesAsync(const GetIdentityPoliciesRequestT& request, const GetIdentityPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::GetIdentityPolicies, request, handler, context);
        }
 
        virtual Model::GetIdentityVerificationAttributesOutcome GetIdentityVerificationAttributes(const Model::GetIdentityVerificationAttributesRequest& request) const;
 
        template<typename GetIdentityVerificationAttributesRequestT = Model::GetIdentityVerificationAttributesRequest>
        Model::GetIdentityVerificationAttributesOutcomeCallable GetIdentityVerificationAttributesCallable(const GetIdentityVerificationAttributesRequestT& request) const
        {
            return SubmitCallable(&SESClient::GetIdentityVerificationAttributes, request);
        }
 
        template<typename GetIdentityVerificationAttributesRequestT = Model::GetIdentityVerificationAttributesRequest>
        void GetIdentityVerificationAttributesAsync(const GetIdentityVerificationAttributesRequestT& request, const GetIdentityVerificationAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::GetIdentityVerificationAttributes, request, handler, context);
        }
 
        virtual Model::GetSendQuotaOutcome GetSendQuota(const Model::GetSendQuotaRequest& request = {}) const;
 
        template<typename GetSendQuotaRequestT = Model::GetSendQuotaRequest>
        Model::GetSendQuotaOutcomeCallable GetSendQuotaCallable(const GetSendQuotaRequestT& request = {}) const
        {
            return SubmitCallable(&SESClient::GetSendQuota, request);
        }
 
        template<typename GetSendQuotaRequestT = Model::GetSendQuotaRequest>
        void GetSendQuotaAsync(const GetSendQuotaResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetSendQuotaRequestT& request = {}) const
        {
            return SubmitAsync(&SESClient::GetSendQuota, request, handler, context);
        }
 
        virtual Model::GetSendStatisticsOutcome GetSendStatistics(const Model::GetSendStatisticsRequest& request = {}) const;
 
        template<typename GetSendStatisticsRequestT = Model::GetSendStatisticsRequest>
        Model::GetSendStatisticsOutcomeCallable GetSendStatisticsCallable(const GetSendStatisticsRequestT& request = {}) const
        {
            return SubmitCallable(&SESClient::GetSendStatistics, request);
        }
 
        template<typename GetSendStatisticsRequestT = Model::GetSendStatisticsRequest>
        void GetSendStatisticsAsync(const GetSendStatisticsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetSendStatisticsRequestT& request = {}) const
        {
            return SubmitAsync(&SESClient::GetSendStatistics, request, handler, context);
        }
 
        virtual Model::GetTemplateOutcome GetTemplate(const Model::GetTemplateRequest& request) const;
 
        template<typename GetTemplateRequestT = Model::GetTemplateRequest>
        Model::GetTemplateOutcomeCallable GetTemplateCallable(const GetTemplateRequestT& request) const
        {
            return SubmitCallable(&SESClient::GetTemplate, request);
        }
 
        template<typename GetTemplateRequestT = Model::GetTemplateRequest>
        void GetTemplateAsync(const GetTemplateRequestT& request, const GetTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::GetTemplate, 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(&SESClient::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(&SESClient::ListConfigurationSets, 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(&SESClient::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(&SESClient::ListCustomVerificationEmailTemplates, request, handler, context);
        }
 
        virtual Model::ListIdentitiesOutcome ListIdentities(const Model::ListIdentitiesRequest& request = {}) const;
 
        template<typename ListIdentitiesRequestT = Model::ListIdentitiesRequest>
        Model::ListIdentitiesOutcomeCallable ListIdentitiesCallable(const ListIdentitiesRequestT& request = {}) const
        {
            return SubmitCallable(&SESClient::ListIdentities, request);
        }
 
        template<typename ListIdentitiesRequestT = Model::ListIdentitiesRequest>
        void ListIdentitiesAsync(const ListIdentitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListIdentitiesRequestT& request = {}) const
        {
            return SubmitAsync(&SESClient::ListIdentities, request, handler, context);
        }
 
        virtual Model::ListIdentityPoliciesOutcome ListIdentityPolicies(const Model::ListIdentityPoliciesRequest& request) const;
 
        template<typename ListIdentityPoliciesRequestT = Model::ListIdentityPoliciesRequest>
        Model::ListIdentityPoliciesOutcomeCallable ListIdentityPoliciesCallable(const ListIdentityPoliciesRequestT& request) const
        {
            return SubmitCallable(&SESClient::ListIdentityPolicies, request);
        }
 
        template<typename ListIdentityPoliciesRequestT = Model::ListIdentityPoliciesRequest>
        void ListIdentityPoliciesAsync(const ListIdentityPoliciesRequestT& request, const ListIdentityPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::ListIdentityPolicies, request, handler, context);
        }
 
        virtual Model::ListReceiptFiltersOutcome ListReceiptFilters(const Model::ListReceiptFiltersRequest& request = {}) const;
 
        template<typename ListReceiptFiltersRequestT = Model::ListReceiptFiltersRequest>
        Model::ListReceiptFiltersOutcomeCallable ListReceiptFiltersCallable(const ListReceiptFiltersRequestT& request = {}) const
        {
            return SubmitCallable(&SESClient::ListReceiptFilters, request);
        }
 
        template<typename ListReceiptFiltersRequestT = Model::ListReceiptFiltersRequest>
        void ListReceiptFiltersAsync(const ListReceiptFiltersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListReceiptFiltersRequestT& request = {}) const
        {
            return SubmitAsync(&SESClient::ListReceiptFilters, request, handler, context);
        }
 
        virtual Model::ListReceiptRuleSetsOutcome ListReceiptRuleSets(const Model::ListReceiptRuleSetsRequest& request = {}) const;
 
        template<typename ListReceiptRuleSetsRequestT = Model::ListReceiptRuleSetsRequest>
        Model::ListReceiptRuleSetsOutcomeCallable ListReceiptRuleSetsCallable(const ListReceiptRuleSetsRequestT& request = {}) const
        {
            return SubmitCallable(&SESClient::ListReceiptRuleSets, request);
        }
 
        template<typename ListReceiptRuleSetsRequestT = Model::ListReceiptRuleSetsRequest>
        void ListReceiptRuleSetsAsync(const ListReceiptRuleSetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListReceiptRuleSetsRequestT& request = {}) const
        {
            return SubmitAsync(&SESClient::ListReceiptRuleSets, request, handler, context);
        }
 
        virtual Model::ListTemplatesOutcome ListTemplates(const Model::ListTemplatesRequest& request = {}) const;
 
        template<typename ListTemplatesRequestT = Model::ListTemplatesRequest>
        Model::ListTemplatesOutcomeCallable ListTemplatesCallable(const ListTemplatesRequestT& request = {}) const
        {
            return SubmitCallable(&SESClient::ListTemplates, request);
        }
 
        template<typename ListTemplatesRequestT = Model::ListTemplatesRequest>
        void ListTemplatesAsync(const ListTemplatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTemplatesRequestT& request = {}) const
        {
            return SubmitAsync(&SESClient::ListTemplates, request, handler, context);
        }
 
        virtual Model::ListVerifiedEmailAddressesOutcome ListVerifiedEmailAddresses(const Model::ListVerifiedEmailAddressesRequest& request = {}) const;
 
        template<typename ListVerifiedEmailAddressesRequestT = Model::ListVerifiedEmailAddressesRequest>
        Model::ListVerifiedEmailAddressesOutcomeCallable ListVerifiedEmailAddressesCallable(const ListVerifiedEmailAddressesRequestT& request = {}) const
        {
            return SubmitCallable(&SESClient::ListVerifiedEmailAddresses, request);
        }
 
        template<typename ListVerifiedEmailAddressesRequestT = Model::ListVerifiedEmailAddressesRequest>
        void ListVerifiedEmailAddressesAsync(const ListVerifiedEmailAddressesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListVerifiedEmailAddressesRequestT& request = {}) const
        {
            return SubmitAsync(&SESClient::ListVerifiedEmailAddresses, 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(&SESClient::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(&SESClient::PutConfigurationSetDeliveryOptions, request, handler, context);
        }
 
        virtual Model::PutIdentityPolicyOutcome PutIdentityPolicy(const Model::PutIdentityPolicyRequest& request) const;
 
        template<typename PutIdentityPolicyRequestT = Model::PutIdentityPolicyRequest>
        Model::PutIdentityPolicyOutcomeCallable PutIdentityPolicyCallable(const PutIdentityPolicyRequestT& request) const
        {
            return SubmitCallable(&SESClient::PutIdentityPolicy, request);
        }
 
        template<typename PutIdentityPolicyRequestT = Model::PutIdentityPolicyRequest>
        void PutIdentityPolicyAsync(const PutIdentityPolicyRequestT& request, const PutIdentityPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::PutIdentityPolicy, request, handler, context);
        }
 
        virtual Model::ReorderReceiptRuleSetOutcome ReorderReceiptRuleSet(const Model::ReorderReceiptRuleSetRequest& request) const;
 
        template<typename ReorderReceiptRuleSetRequestT = Model::ReorderReceiptRuleSetRequest>
        Model::ReorderReceiptRuleSetOutcomeCallable ReorderReceiptRuleSetCallable(const ReorderReceiptRuleSetRequestT& request) const
        {
            return SubmitCallable(&SESClient::ReorderReceiptRuleSet, request);
        }
 
        template<typename ReorderReceiptRuleSetRequestT = Model::ReorderReceiptRuleSetRequest>
        void ReorderReceiptRuleSetAsync(const ReorderReceiptRuleSetRequestT& request, const ReorderReceiptRuleSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::ReorderReceiptRuleSet, request, handler, context);
        }
 
        virtual Model::SendBounceOutcome SendBounce(const Model::SendBounceRequest& request) const;
 
        template<typename SendBounceRequestT = Model::SendBounceRequest>
        Model::SendBounceOutcomeCallable SendBounceCallable(const SendBounceRequestT& request) const
        {
            return SubmitCallable(&SESClient::SendBounce, request);
        }
 
        template<typename SendBounceRequestT = Model::SendBounceRequest>
        void SendBounceAsync(const SendBounceRequestT& request, const SendBounceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::SendBounce, request, handler, context);
        }
 
        virtual Model::SendBulkTemplatedEmailOutcome SendBulkTemplatedEmail(const Model::SendBulkTemplatedEmailRequest& request) const;
 
        template<typename SendBulkTemplatedEmailRequestT = Model::SendBulkTemplatedEmailRequest>
        Model::SendBulkTemplatedEmailOutcomeCallable SendBulkTemplatedEmailCallable(const SendBulkTemplatedEmailRequestT& request) const
        {
            return SubmitCallable(&SESClient::SendBulkTemplatedEmail, request);
        }
 
        template<typename SendBulkTemplatedEmailRequestT = Model::SendBulkTemplatedEmailRequest>
        void SendBulkTemplatedEmailAsync(const SendBulkTemplatedEmailRequestT& request, const SendBulkTemplatedEmailResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::SendBulkTemplatedEmail, 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(&SESClient::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(&SESClient::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(&SESClient::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(&SESClient::SendEmail, request, handler, context);
        }
 
        virtual Model::SendRawEmailOutcome SendRawEmail(const Model::SendRawEmailRequest& request) const;
 
        template<typename SendRawEmailRequestT = Model::SendRawEmailRequest>
        Model::SendRawEmailOutcomeCallable SendRawEmailCallable(const SendRawEmailRequestT& request) const
        {
            return SubmitCallable(&SESClient::SendRawEmail, request);
        }
 
        template<typename SendRawEmailRequestT = Model::SendRawEmailRequest>
        void SendRawEmailAsync(const SendRawEmailRequestT& request, const SendRawEmailResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::SendRawEmail, request, handler, context);
        }
 
        virtual Model::SendTemplatedEmailOutcome SendTemplatedEmail(const Model::SendTemplatedEmailRequest& request) const;
 
        template<typename SendTemplatedEmailRequestT = Model::SendTemplatedEmailRequest>
        Model::SendTemplatedEmailOutcomeCallable SendTemplatedEmailCallable(const SendTemplatedEmailRequestT& request) const
        {
            return SubmitCallable(&SESClient::SendTemplatedEmail, request);
        }
 
        template<typename SendTemplatedEmailRequestT = Model::SendTemplatedEmailRequest>
        void SendTemplatedEmailAsync(const SendTemplatedEmailRequestT& request, const SendTemplatedEmailResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::SendTemplatedEmail, request, handler, context);
        }
 
        virtual Model::SetActiveReceiptRuleSetOutcome SetActiveReceiptRuleSet(const Model::SetActiveReceiptRuleSetRequest& request = {}) const;
 
        template<typename SetActiveReceiptRuleSetRequestT = Model::SetActiveReceiptRuleSetRequest>
        Model::SetActiveReceiptRuleSetOutcomeCallable SetActiveReceiptRuleSetCallable(const SetActiveReceiptRuleSetRequestT& request = {}) const
        {
            return SubmitCallable(&SESClient::SetActiveReceiptRuleSet, request);
        }
 
        template<typename SetActiveReceiptRuleSetRequestT = Model::SetActiveReceiptRuleSetRequest>
        void SetActiveReceiptRuleSetAsync(const SetActiveReceiptRuleSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const SetActiveReceiptRuleSetRequestT& request = {}) const
        {
            return SubmitAsync(&SESClient::SetActiveReceiptRuleSet, request, handler, context);
        }
 
        virtual Model::SetIdentityDkimEnabledOutcome SetIdentityDkimEnabled(const Model::SetIdentityDkimEnabledRequest& request) const;
 
        template<typename SetIdentityDkimEnabledRequestT = Model::SetIdentityDkimEnabledRequest>
        Model::SetIdentityDkimEnabledOutcomeCallable SetIdentityDkimEnabledCallable(const SetIdentityDkimEnabledRequestT& request) const
        {
            return SubmitCallable(&SESClient::SetIdentityDkimEnabled, request);
        }
 
        template<typename SetIdentityDkimEnabledRequestT = Model::SetIdentityDkimEnabledRequest>
        void SetIdentityDkimEnabledAsync(const SetIdentityDkimEnabledRequestT& request, const SetIdentityDkimEnabledResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::SetIdentityDkimEnabled, request, handler, context);
        }
 
        virtual Model::SetIdentityFeedbackForwardingEnabledOutcome SetIdentityFeedbackForwardingEnabled(const Model::SetIdentityFeedbackForwardingEnabledRequest& request) const;
 
        template<typename SetIdentityFeedbackForwardingEnabledRequestT = Model::SetIdentityFeedbackForwardingEnabledRequest>
        Model::SetIdentityFeedbackForwardingEnabledOutcomeCallable SetIdentityFeedbackForwardingEnabledCallable(const SetIdentityFeedbackForwardingEnabledRequestT& request) const
        {
            return SubmitCallable(&SESClient::SetIdentityFeedbackForwardingEnabled, request);
        }
 
        template<typename SetIdentityFeedbackForwardingEnabledRequestT = Model::SetIdentityFeedbackForwardingEnabledRequest>
        void SetIdentityFeedbackForwardingEnabledAsync(const SetIdentityFeedbackForwardingEnabledRequestT& request, const SetIdentityFeedbackForwardingEnabledResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::SetIdentityFeedbackForwardingEnabled, request, handler, context);
        }
 
        virtual Model::SetIdentityHeadersInNotificationsEnabledOutcome SetIdentityHeadersInNotificationsEnabled(const Model::SetIdentityHeadersInNotificationsEnabledRequest& request) const;
 
        template<typename SetIdentityHeadersInNotificationsEnabledRequestT = Model::SetIdentityHeadersInNotificationsEnabledRequest>
        Model::SetIdentityHeadersInNotificationsEnabledOutcomeCallable SetIdentityHeadersInNotificationsEnabledCallable(const SetIdentityHeadersInNotificationsEnabledRequestT& request) const
        {
            return SubmitCallable(&SESClient::SetIdentityHeadersInNotificationsEnabled, request);
        }
 
        template<typename SetIdentityHeadersInNotificationsEnabledRequestT = Model::SetIdentityHeadersInNotificationsEnabledRequest>
        void SetIdentityHeadersInNotificationsEnabledAsync(const SetIdentityHeadersInNotificationsEnabledRequestT& request, const SetIdentityHeadersInNotificationsEnabledResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::SetIdentityHeadersInNotificationsEnabled, request, handler, context);
        }
 
        virtual Model::SetIdentityMailFromDomainOutcome SetIdentityMailFromDomain(const Model::SetIdentityMailFromDomainRequest& request) const;
 
        template<typename SetIdentityMailFromDomainRequestT = Model::SetIdentityMailFromDomainRequest>
        Model::SetIdentityMailFromDomainOutcomeCallable SetIdentityMailFromDomainCallable(const SetIdentityMailFromDomainRequestT& request) const
        {
            return SubmitCallable(&SESClient::SetIdentityMailFromDomain, request);
        }
 
        template<typename SetIdentityMailFromDomainRequestT = Model::SetIdentityMailFromDomainRequest>
        void SetIdentityMailFromDomainAsync(const SetIdentityMailFromDomainRequestT& request, const SetIdentityMailFromDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::SetIdentityMailFromDomain, request, handler, context);
        }
 
        virtual Model::SetIdentityNotificationTopicOutcome SetIdentityNotificationTopic(const Model::SetIdentityNotificationTopicRequest& request) const;
 
        template<typename SetIdentityNotificationTopicRequestT = Model::SetIdentityNotificationTopicRequest>
        Model::SetIdentityNotificationTopicOutcomeCallable SetIdentityNotificationTopicCallable(const SetIdentityNotificationTopicRequestT& request) const
        {
            return SubmitCallable(&SESClient::SetIdentityNotificationTopic, request);
        }
 
        template<typename SetIdentityNotificationTopicRequestT = Model::SetIdentityNotificationTopicRequest>
        void SetIdentityNotificationTopicAsync(const SetIdentityNotificationTopicRequestT& request, const SetIdentityNotificationTopicResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::SetIdentityNotificationTopic, request, handler, context);
        }
 
        virtual Model::SetReceiptRulePositionOutcome SetReceiptRulePosition(const Model::SetReceiptRulePositionRequest& request) const;
 
        template<typename SetReceiptRulePositionRequestT = Model::SetReceiptRulePositionRequest>
        Model::SetReceiptRulePositionOutcomeCallable SetReceiptRulePositionCallable(const SetReceiptRulePositionRequestT& request) const
        {
            return SubmitCallable(&SESClient::SetReceiptRulePosition, request);
        }
 
        template<typename SetReceiptRulePositionRequestT = Model::SetReceiptRulePositionRequest>
        void SetReceiptRulePositionAsync(const SetReceiptRulePositionRequestT& request, const SetReceiptRulePositionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::SetReceiptRulePosition, request, handler, context);
        }
 
        virtual Model::TestRenderTemplateOutcome TestRenderTemplate(const Model::TestRenderTemplateRequest& request) const;
 
        template<typename TestRenderTemplateRequestT = Model::TestRenderTemplateRequest>
        Model::TestRenderTemplateOutcomeCallable TestRenderTemplateCallable(const TestRenderTemplateRequestT& request) const
        {
            return SubmitCallable(&SESClient::TestRenderTemplate, request);
        }
 
        template<typename TestRenderTemplateRequestT = Model::TestRenderTemplateRequest>
        void TestRenderTemplateAsync(const TestRenderTemplateRequestT& request, const TestRenderTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::TestRenderTemplate, request, handler, context);
        }
 
        virtual Model::UpdateAccountSendingEnabledOutcome UpdateAccountSendingEnabled(const Model::UpdateAccountSendingEnabledRequest& request = {}) const;
 
        template<typename UpdateAccountSendingEnabledRequestT = Model::UpdateAccountSendingEnabledRequest>
        Model::UpdateAccountSendingEnabledOutcomeCallable UpdateAccountSendingEnabledCallable(const UpdateAccountSendingEnabledRequestT& request = {}) const
        {
            return SubmitCallable(&SESClient::UpdateAccountSendingEnabled, request);
        }
 
        template<typename UpdateAccountSendingEnabledRequestT = Model::UpdateAccountSendingEnabledRequest>
        void UpdateAccountSendingEnabledAsync(const UpdateAccountSendingEnabledResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateAccountSendingEnabledRequestT& request = {}) const
        {
            return SubmitAsync(&SESClient::UpdateAccountSendingEnabled, 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(&SESClient::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(&SESClient::UpdateConfigurationSetEventDestination, request, handler, context);
        }
 
        virtual Model::UpdateConfigurationSetReputationMetricsEnabledOutcome UpdateConfigurationSetReputationMetricsEnabled(const Model::UpdateConfigurationSetReputationMetricsEnabledRequest& request) const;
 
        template<typename UpdateConfigurationSetReputationMetricsEnabledRequestT = Model::UpdateConfigurationSetReputationMetricsEnabledRequest>
        Model::UpdateConfigurationSetReputationMetricsEnabledOutcomeCallable UpdateConfigurationSetReputationMetricsEnabledCallable(const UpdateConfigurationSetReputationMetricsEnabledRequestT& request) const
        {
            return SubmitCallable(&SESClient::UpdateConfigurationSetReputationMetricsEnabled, request);
        }
 
        template<typename UpdateConfigurationSetReputationMetricsEnabledRequestT = Model::UpdateConfigurationSetReputationMetricsEnabledRequest>
        void UpdateConfigurationSetReputationMetricsEnabledAsync(const UpdateConfigurationSetReputationMetricsEnabledRequestT& request, const UpdateConfigurationSetReputationMetricsEnabledResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::UpdateConfigurationSetReputationMetricsEnabled, request, handler, context);
        }
 
        virtual Model::UpdateConfigurationSetSendingEnabledOutcome UpdateConfigurationSetSendingEnabled(const Model::UpdateConfigurationSetSendingEnabledRequest& request) const;
 
        template<typename UpdateConfigurationSetSendingEnabledRequestT = Model::UpdateConfigurationSetSendingEnabledRequest>
        Model::UpdateConfigurationSetSendingEnabledOutcomeCallable UpdateConfigurationSetSendingEnabledCallable(const UpdateConfigurationSetSendingEnabledRequestT& request) const
        {
            return SubmitCallable(&SESClient::UpdateConfigurationSetSendingEnabled, request);
        }
 
        template<typename UpdateConfigurationSetSendingEnabledRequestT = Model::UpdateConfigurationSetSendingEnabledRequest>
        void UpdateConfigurationSetSendingEnabledAsync(const UpdateConfigurationSetSendingEnabledRequestT& request, const UpdateConfigurationSetSendingEnabledResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::UpdateConfigurationSetSendingEnabled, request, handler, context);
        }
 
        virtual Model::UpdateConfigurationSetTrackingOptionsOutcome UpdateConfigurationSetTrackingOptions(const Model::UpdateConfigurationSetTrackingOptionsRequest& request) const;
 
        template<typename UpdateConfigurationSetTrackingOptionsRequestT = Model::UpdateConfigurationSetTrackingOptionsRequest>
        Model::UpdateConfigurationSetTrackingOptionsOutcomeCallable UpdateConfigurationSetTrackingOptionsCallable(const UpdateConfigurationSetTrackingOptionsRequestT& request) const
        {
            return SubmitCallable(&SESClient::UpdateConfigurationSetTrackingOptions, request);
        }
 
        template<typename UpdateConfigurationSetTrackingOptionsRequestT = Model::UpdateConfigurationSetTrackingOptionsRequest>
        void UpdateConfigurationSetTrackingOptionsAsync(const UpdateConfigurationSetTrackingOptionsRequestT& request, const UpdateConfigurationSetTrackingOptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::UpdateConfigurationSetTrackingOptions, 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(&SESClient::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(&SESClient::UpdateCustomVerificationEmailTemplate, request, handler, context);
        }
 
        virtual Model::UpdateReceiptRuleOutcome UpdateReceiptRule(const Model::UpdateReceiptRuleRequest& request) const;
 
        template<typename UpdateReceiptRuleRequestT = Model::UpdateReceiptRuleRequest>
        Model::UpdateReceiptRuleOutcomeCallable UpdateReceiptRuleCallable(const UpdateReceiptRuleRequestT& request) const
        {
            return SubmitCallable(&SESClient::UpdateReceiptRule, request);
        }
 
        template<typename UpdateReceiptRuleRequestT = Model::UpdateReceiptRuleRequest>
        void UpdateReceiptRuleAsync(const UpdateReceiptRuleRequestT& request, const UpdateReceiptRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::UpdateReceiptRule, request, handler, context);
        }
 
        virtual Model::UpdateTemplateOutcome UpdateTemplate(const Model::UpdateTemplateRequest& request) const;
 
        template<typename UpdateTemplateRequestT = Model::UpdateTemplateRequest>
        Model::UpdateTemplateOutcomeCallable UpdateTemplateCallable(const UpdateTemplateRequestT& request) const
        {
            return SubmitCallable(&SESClient::UpdateTemplate, request);
        }
 
        template<typename UpdateTemplateRequestT = Model::UpdateTemplateRequest>
        void UpdateTemplateAsync(const UpdateTemplateRequestT& request, const UpdateTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::UpdateTemplate, request, handler, context);
        }
 
        virtual Model::VerifyDomainDkimOutcome VerifyDomainDkim(const Model::VerifyDomainDkimRequest& request) const;
 
        template<typename VerifyDomainDkimRequestT = Model::VerifyDomainDkimRequest>
        Model::VerifyDomainDkimOutcomeCallable VerifyDomainDkimCallable(const VerifyDomainDkimRequestT& request) const
        {
            return SubmitCallable(&SESClient::VerifyDomainDkim, request);
        }
 
        template<typename VerifyDomainDkimRequestT = Model::VerifyDomainDkimRequest>
        void VerifyDomainDkimAsync(const VerifyDomainDkimRequestT& request, const VerifyDomainDkimResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::VerifyDomainDkim, request, handler, context);
        }
 
        virtual Model::VerifyDomainIdentityOutcome VerifyDomainIdentity(const Model::VerifyDomainIdentityRequest& request) const;
 
        template<typename VerifyDomainIdentityRequestT = Model::VerifyDomainIdentityRequest>
        Model::VerifyDomainIdentityOutcomeCallable VerifyDomainIdentityCallable(const VerifyDomainIdentityRequestT& request) const
        {
            return SubmitCallable(&SESClient::VerifyDomainIdentity, request);
        }
 
        template<typename VerifyDomainIdentityRequestT = Model::VerifyDomainIdentityRequest>
        void VerifyDomainIdentityAsync(const VerifyDomainIdentityRequestT& request, const VerifyDomainIdentityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::VerifyDomainIdentity, request, handler, context);
        }
 
        virtual Model::VerifyEmailAddressOutcome VerifyEmailAddress(const Model::VerifyEmailAddressRequest& request) const;
 
        template<typename VerifyEmailAddressRequestT = Model::VerifyEmailAddressRequest>
        Model::VerifyEmailAddressOutcomeCallable VerifyEmailAddressCallable(const VerifyEmailAddressRequestT& request) const
        {
            return SubmitCallable(&SESClient::VerifyEmailAddress, request);
        }
 
        template<typename VerifyEmailAddressRequestT = Model::VerifyEmailAddressRequest>
        void VerifyEmailAddressAsync(const VerifyEmailAddressRequestT& request, const VerifyEmailAddressResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::VerifyEmailAddress, request, handler, context);
        }
 
        virtual Model::VerifyEmailIdentityOutcome VerifyEmailIdentity(const Model::VerifyEmailIdentityRequest& request) const;
 
        template<typename VerifyEmailIdentityRequestT = Model::VerifyEmailIdentityRequest>
        Model::VerifyEmailIdentityOutcomeCallable VerifyEmailIdentityCallable(const VerifyEmailIdentityRequestT& request) const
        {
            return SubmitCallable(&SESClient::VerifyEmailIdentity, request);
        }
 
        template<typename VerifyEmailIdentityRequestT = Model::VerifyEmailIdentityRequest>
        void VerifyEmailIdentityAsync(const VerifyEmailIdentityRequestT& request, const VerifyEmailIdentityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SESClient::VerifyEmailIdentity, request, handler, context);
        }
 
 
        void OverrideEndpoint(const Aws::String& endpoint);
        std::shared_ptr<SESEndpointProviderBase>& accessEndpointProvider();
  private:
        friend class Aws::Client::ClientWithAsyncTemplateMethods<SESClient>;
        void init(const SESClientConfiguration& clientConfiguration);
 
        SESClientConfiguration m_clientConfiguration;
        std::shared_ptr<SESEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace SES
} // namespace Aws