SESClient.h

 
#pragma once
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/email/SESPaginationBase.h>
#include <aws/email/SESServiceClientModel.h>
#include <aws/email/SESWaiter.h>
#include <aws/email/SES_EXPORTS.h>
 
namespace Aws {
namespace SES {
class AWS_SES_API SESClient : public Aws::Client::AWSXMLClient,
                              public Aws::Client::ClientWithAsyncTemplateMethods<SESClient>,
                              public SESPaginationBase<SESClient>,
                              public SESWaiter<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<SESEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<SESClient>;
  void init(const SESClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, SESError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  SESClientConfiguration m_clientConfiguration;
  std::shared_ptr<SESEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace SES
}  // namespace Aws