MailManagerClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/mailmanager/MailManagerPaginationBase.h>
#include <aws/mailmanager/MailManagerServiceClientModel.h>
#include <aws/mailmanager/MailManagerWaiter.h>
#include <aws/mailmanager/MailManager_EXPORTS.h>
 
namespace Aws {
namespace MailManager {
class AWS_MAILMANAGER_API MailManagerClient : public Aws::Client::AWSJsonClient,
                                              public Aws::Client::ClientWithAsyncTemplateMethods<MailManagerClient>,
                                              public MailManagerPaginationBase<MailManagerClient>,
                                              public MailManagerWaiter<MailManagerClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef MailManagerClientConfiguration ClientConfigurationType;
  typedef MailManagerEndpointProvider EndpointProviderType;
 
  MailManagerClient(
      const Aws::MailManager::MailManagerClientConfiguration& clientConfiguration = Aws::MailManager::MailManagerClientConfiguration(),
      std::shared_ptr<MailManagerEndpointProviderBase> endpointProvider = nullptr);
 
  MailManagerClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<MailManagerEndpointProviderBase> endpointProvider = nullptr,
      const Aws::MailManager::MailManagerClientConfiguration& clientConfiguration = Aws::MailManager::MailManagerClientConfiguration());
 
  MailManagerClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<MailManagerEndpointProviderBase> endpointProvider = nullptr,
      const Aws::MailManager::MailManagerClientConfiguration& clientConfiguration = Aws::MailManager::MailManagerClientConfiguration());
 
  /* Legacy constructors due deprecation */
  MailManagerClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  MailManagerClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  MailManagerClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                    const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~MailManagerClient();
 
  virtual Model::CreateAddonInstanceOutcome CreateAddonInstance(const Model::CreateAddonInstanceRequest& request) const;
 
  template <typename CreateAddonInstanceRequestT = Model::CreateAddonInstanceRequest>
  Model::CreateAddonInstanceOutcomeCallable CreateAddonInstanceCallable(const CreateAddonInstanceRequestT& request) const {
    return SubmitCallable(&MailManagerClient::CreateAddonInstance, request);
  }
 
  template <typename CreateAddonInstanceRequestT = Model::CreateAddonInstanceRequest>
  void CreateAddonInstanceAsync(const CreateAddonInstanceRequestT& request, const CreateAddonInstanceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::CreateAddonInstance, request, handler, context);
  }
 
  virtual Model::CreateAddonSubscriptionOutcome CreateAddonSubscription(const Model::CreateAddonSubscriptionRequest& request) const;
 
  template <typename CreateAddonSubscriptionRequestT = Model::CreateAddonSubscriptionRequest>
  Model::CreateAddonSubscriptionOutcomeCallable CreateAddonSubscriptionCallable(const CreateAddonSubscriptionRequestT& request) const {
    return SubmitCallable(&MailManagerClient::CreateAddonSubscription, request);
  }
 
  template <typename CreateAddonSubscriptionRequestT = Model::CreateAddonSubscriptionRequest>
  void CreateAddonSubscriptionAsync(const CreateAddonSubscriptionRequestT& request,
                                    const CreateAddonSubscriptionResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::CreateAddonSubscription, request, handler, context);
  }
 
  virtual Model::CreateAddressListOutcome CreateAddressList(const Model::CreateAddressListRequest& request) const;
 
  template <typename CreateAddressListRequestT = Model::CreateAddressListRequest>
  Model::CreateAddressListOutcomeCallable CreateAddressListCallable(const CreateAddressListRequestT& request) const {
    return SubmitCallable(&MailManagerClient::CreateAddressList, request);
  }
 
  template <typename CreateAddressListRequestT = Model::CreateAddressListRequest>
  void CreateAddressListAsync(const CreateAddressListRequestT& request, const CreateAddressListResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::CreateAddressList, request, handler, context);
  }
 
  virtual Model::CreateAddressListImportJobOutcome CreateAddressListImportJob(
      const Model::CreateAddressListImportJobRequest& request) const;
 
  template <typename CreateAddressListImportJobRequestT = Model::CreateAddressListImportJobRequest>
  Model::CreateAddressListImportJobOutcomeCallable CreateAddressListImportJobCallable(
      const CreateAddressListImportJobRequestT& request) const {
    return SubmitCallable(&MailManagerClient::CreateAddressListImportJob, request);
  }
 
  template <typename CreateAddressListImportJobRequestT = Model::CreateAddressListImportJobRequest>
  void CreateAddressListImportJobAsync(const CreateAddressListImportJobRequestT& request,
                                       const CreateAddressListImportJobResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::CreateAddressListImportJob, request, handler, context);
  }
 
  virtual Model::CreateArchiveOutcome CreateArchive(const Model::CreateArchiveRequest& request) const;
 
  template <typename CreateArchiveRequestT = Model::CreateArchiveRequest>
  Model::CreateArchiveOutcomeCallable CreateArchiveCallable(const CreateArchiveRequestT& request) const {
    return SubmitCallable(&MailManagerClient::CreateArchive, request);
  }
 
  template <typename CreateArchiveRequestT = Model::CreateArchiveRequest>
  void CreateArchiveAsync(const CreateArchiveRequestT& request, const CreateArchiveResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::CreateArchive, request, handler, context);
  }
 
  virtual Model::CreateIngressPointOutcome CreateIngressPoint(const Model::CreateIngressPointRequest& request) const;
 
  template <typename CreateIngressPointRequestT = Model::CreateIngressPointRequest>
  Model::CreateIngressPointOutcomeCallable CreateIngressPointCallable(const CreateIngressPointRequestT& request) const {
    return SubmitCallable(&MailManagerClient::CreateIngressPoint, request);
  }
 
  template <typename CreateIngressPointRequestT = Model::CreateIngressPointRequest>
  void CreateIngressPointAsync(const CreateIngressPointRequestT& request, const CreateIngressPointResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::CreateIngressPoint, request, handler, context);
  }
 
  virtual Model::CreateRelayOutcome CreateRelay(const Model::CreateRelayRequest& request) const;
 
  template <typename CreateRelayRequestT = Model::CreateRelayRequest>
  Model::CreateRelayOutcomeCallable CreateRelayCallable(const CreateRelayRequestT& request) const {
    return SubmitCallable(&MailManagerClient::CreateRelay, request);
  }
 
  template <typename CreateRelayRequestT = Model::CreateRelayRequest>
  void CreateRelayAsync(const CreateRelayRequestT& request, const CreateRelayResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::CreateRelay, request, handler, context);
  }
 
  virtual Model::CreateRuleSetOutcome CreateRuleSet(const Model::CreateRuleSetRequest& request) const;
 
  template <typename CreateRuleSetRequestT = Model::CreateRuleSetRequest>
  Model::CreateRuleSetOutcomeCallable CreateRuleSetCallable(const CreateRuleSetRequestT& request) const {
    return SubmitCallable(&MailManagerClient::CreateRuleSet, request);
  }
 
  template <typename CreateRuleSetRequestT = Model::CreateRuleSetRequest>
  void CreateRuleSetAsync(const CreateRuleSetRequestT& request, const CreateRuleSetResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::CreateRuleSet, request, handler, context);
  }
 
  virtual Model::CreateTrafficPolicyOutcome CreateTrafficPolicy(const Model::CreateTrafficPolicyRequest& request) const;
 
  template <typename CreateTrafficPolicyRequestT = Model::CreateTrafficPolicyRequest>
  Model::CreateTrafficPolicyOutcomeCallable CreateTrafficPolicyCallable(const CreateTrafficPolicyRequestT& request) const {
    return SubmitCallable(&MailManagerClient::CreateTrafficPolicy, request);
  }
 
  template <typename CreateTrafficPolicyRequestT = Model::CreateTrafficPolicyRequest>
  void CreateTrafficPolicyAsync(const CreateTrafficPolicyRequestT& request, const CreateTrafficPolicyResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::CreateTrafficPolicy, request, handler, context);
  }
 
  virtual Model::DeleteAddonInstanceOutcome DeleteAddonInstance(const Model::DeleteAddonInstanceRequest& request) const;
 
  template <typename DeleteAddonInstanceRequestT = Model::DeleteAddonInstanceRequest>
  Model::DeleteAddonInstanceOutcomeCallable DeleteAddonInstanceCallable(const DeleteAddonInstanceRequestT& request) const {
    return SubmitCallable(&MailManagerClient::DeleteAddonInstance, request);
  }
 
  template <typename DeleteAddonInstanceRequestT = Model::DeleteAddonInstanceRequest>
  void DeleteAddonInstanceAsync(const DeleteAddonInstanceRequestT& request, const DeleteAddonInstanceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::DeleteAddonInstance, request, handler, context);
  }
 
  virtual Model::DeleteAddonSubscriptionOutcome DeleteAddonSubscription(const Model::DeleteAddonSubscriptionRequest& request) const;
 
  template <typename DeleteAddonSubscriptionRequestT = Model::DeleteAddonSubscriptionRequest>
  Model::DeleteAddonSubscriptionOutcomeCallable DeleteAddonSubscriptionCallable(const DeleteAddonSubscriptionRequestT& request) const {
    return SubmitCallable(&MailManagerClient::DeleteAddonSubscription, request);
  }
 
  template <typename DeleteAddonSubscriptionRequestT = Model::DeleteAddonSubscriptionRequest>
  void DeleteAddonSubscriptionAsync(const DeleteAddonSubscriptionRequestT& request,
                                    const DeleteAddonSubscriptionResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::DeleteAddonSubscription, request, handler, context);
  }
 
  virtual Model::DeleteAddressListOutcome DeleteAddressList(const Model::DeleteAddressListRequest& request) const;
 
  template <typename DeleteAddressListRequestT = Model::DeleteAddressListRequest>
  Model::DeleteAddressListOutcomeCallable DeleteAddressListCallable(const DeleteAddressListRequestT& request) const {
    return SubmitCallable(&MailManagerClient::DeleteAddressList, request);
  }
 
  template <typename DeleteAddressListRequestT = Model::DeleteAddressListRequest>
  void DeleteAddressListAsync(const DeleteAddressListRequestT& request, const DeleteAddressListResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::DeleteAddressList, request, handler, context);
  }
 
  virtual Model::DeleteArchiveOutcome DeleteArchive(const Model::DeleteArchiveRequest& request) const;
 
  template <typename DeleteArchiveRequestT = Model::DeleteArchiveRequest>
  Model::DeleteArchiveOutcomeCallable DeleteArchiveCallable(const DeleteArchiveRequestT& request) const {
    return SubmitCallable(&MailManagerClient::DeleteArchive, request);
  }
 
  template <typename DeleteArchiveRequestT = Model::DeleteArchiveRequest>
  void DeleteArchiveAsync(const DeleteArchiveRequestT& request, const DeleteArchiveResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::DeleteArchive, request, handler, context);
  }
 
  virtual Model::DeleteIngressPointOutcome DeleteIngressPoint(const Model::DeleteIngressPointRequest& request) const;
 
  template <typename DeleteIngressPointRequestT = Model::DeleteIngressPointRequest>
  Model::DeleteIngressPointOutcomeCallable DeleteIngressPointCallable(const DeleteIngressPointRequestT& request) const {
    return SubmitCallable(&MailManagerClient::DeleteIngressPoint, request);
  }
 
  template <typename DeleteIngressPointRequestT = Model::DeleteIngressPointRequest>
  void DeleteIngressPointAsync(const DeleteIngressPointRequestT& request, const DeleteIngressPointResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::DeleteIngressPoint, request, handler, context);
  }
 
  virtual Model::DeleteRelayOutcome DeleteRelay(const Model::DeleteRelayRequest& request) const;
 
  template <typename DeleteRelayRequestT = Model::DeleteRelayRequest>
  Model::DeleteRelayOutcomeCallable DeleteRelayCallable(const DeleteRelayRequestT& request) const {
    return SubmitCallable(&MailManagerClient::DeleteRelay, request);
  }
 
  template <typename DeleteRelayRequestT = Model::DeleteRelayRequest>
  void DeleteRelayAsync(const DeleteRelayRequestT& request, const DeleteRelayResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::DeleteRelay, request, handler, context);
  }
 
  virtual Model::DeleteRuleSetOutcome DeleteRuleSet(const Model::DeleteRuleSetRequest& request) const;
 
  template <typename DeleteRuleSetRequestT = Model::DeleteRuleSetRequest>
  Model::DeleteRuleSetOutcomeCallable DeleteRuleSetCallable(const DeleteRuleSetRequestT& request) const {
    return SubmitCallable(&MailManagerClient::DeleteRuleSet, request);
  }
 
  template <typename DeleteRuleSetRequestT = Model::DeleteRuleSetRequest>
  void DeleteRuleSetAsync(const DeleteRuleSetRequestT& request, const DeleteRuleSetResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::DeleteRuleSet, request, handler, context);
  }
 
  virtual Model::DeleteTrafficPolicyOutcome DeleteTrafficPolicy(const Model::DeleteTrafficPolicyRequest& request) const;
 
  template <typename DeleteTrafficPolicyRequestT = Model::DeleteTrafficPolicyRequest>
  Model::DeleteTrafficPolicyOutcomeCallable DeleteTrafficPolicyCallable(const DeleteTrafficPolicyRequestT& request) const {
    return SubmitCallable(&MailManagerClient::DeleteTrafficPolicy, request);
  }
 
  template <typename DeleteTrafficPolicyRequestT = Model::DeleteTrafficPolicyRequest>
  void DeleteTrafficPolicyAsync(const DeleteTrafficPolicyRequestT& request, const DeleteTrafficPolicyResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::DeleteTrafficPolicy, request, handler, context);
  }
 
  virtual Model::DeregisterMemberFromAddressListOutcome DeregisterMemberFromAddressList(
      const Model::DeregisterMemberFromAddressListRequest& request) const;
 
  template <typename DeregisterMemberFromAddressListRequestT = Model::DeregisterMemberFromAddressListRequest>
  Model::DeregisterMemberFromAddressListOutcomeCallable DeregisterMemberFromAddressListCallable(
      const DeregisterMemberFromAddressListRequestT& request) const {
    return SubmitCallable(&MailManagerClient::DeregisterMemberFromAddressList, request);
  }
 
  template <typename DeregisterMemberFromAddressListRequestT = Model::DeregisterMemberFromAddressListRequest>
  void DeregisterMemberFromAddressListAsync(const DeregisterMemberFromAddressListRequestT& request,
                                            const DeregisterMemberFromAddressListResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::DeregisterMemberFromAddressList, request, handler, context);
  }
 
  virtual Model::GetAddonInstanceOutcome GetAddonInstance(const Model::GetAddonInstanceRequest& request) const;
 
  template <typename GetAddonInstanceRequestT = Model::GetAddonInstanceRequest>
  Model::GetAddonInstanceOutcomeCallable GetAddonInstanceCallable(const GetAddonInstanceRequestT& request) const {
    return SubmitCallable(&MailManagerClient::GetAddonInstance, request);
  }
 
  template <typename GetAddonInstanceRequestT = Model::GetAddonInstanceRequest>
  void GetAddonInstanceAsync(const GetAddonInstanceRequestT& request, const GetAddonInstanceResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::GetAddonInstance, request, handler, context);
  }
 
  virtual Model::GetAddonSubscriptionOutcome GetAddonSubscription(const Model::GetAddonSubscriptionRequest& request) const;
 
  template <typename GetAddonSubscriptionRequestT = Model::GetAddonSubscriptionRequest>
  Model::GetAddonSubscriptionOutcomeCallable GetAddonSubscriptionCallable(const GetAddonSubscriptionRequestT& request) const {
    return SubmitCallable(&MailManagerClient::GetAddonSubscription, request);
  }
 
  template <typename GetAddonSubscriptionRequestT = Model::GetAddonSubscriptionRequest>
  void GetAddonSubscriptionAsync(const GetAddonSubscriptionRequestT& request, const GetAddonSubscriptionResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::GetAddonSubscription, request, handler, context);
  }
 
  virtual Model::GetAddressListOutcome GetAddressList(const Model::GetAddressListRequest& request) const;
 
  template <typename GetAddressListRequestT = Model::GetAddressListRequest>
  Model::GetAddressListOutcomeCallable GetAddressListCallable(const GetAddressListRequestT& request) const {
    return SubmitCallable(&MailManagerClient::GetAddressList, request);
  }
 
  template <typename GetAddressListRequestT = Model::GetAddressListRequest>
  void GetAddressListAsync(const GetAddressListRequestT& request, const GetAddressListResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::GetAddressList, request, handler, context);
  }
 
  virtual Model::GetAddressListImportJobOutcome GetAddressListImportJob(const Model::GetAddressListImportJobRequest& request) const;
 
  template <typename GetAddressListImportJobRequestT = Model::GetAddressListImportJobRequest>
  Model::GetAddressListImportJobOutcomeCallable GetAddressListImportJobCallable(const GetAddressListImportJobRequestT& request) const {
    return SubmitCallable(&MailManagerClient::GetAddressListImportJob, request);
  }
 
  template <typename GetAddressListImportJobRequestT = Model::GetAddressListImportJobRequest>
  void GetAddressListImportJobAsync(const GetAddressListImportJobRequestT& request,
                                    const GetAddressListImportJobResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::GetAddressListImportJob, request, handler, context);
  }
 
  virtual Model::GetArchiveOutcome GetArchive(const Model::GetArchiveRequest& request) const;
 
  template <typename GetArchiveRequestT = Model::GetArchiveRequest>
  Model::GetArchiveOutcomeCallable GetArchiveCallable(const GetArchiveRequestT& request) const {
    return SubmitCallable(&MailManagerClient::GetArchive, request);
  }
 
  template <typename GetArchiveRequestT = Model::GetArchiveRequest>
  void GetArchiveAsync(const GetArchiveRequestT& request, const GetArchiveResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::GetArchive, request, handler, context);
  }
 
  virtual Model::GetArchiveExportOutcome GetArchiveExport(const Model::GetArchiveExportRequest& request) const;
 
  template <typename GetArchiveExportRequestT = Model::GetArchiveExportRequest>
  Model::GetArchiveExportOutcomeCallable GetArchiveExportCallable(const GetArchiveExportRequestT& request) const {
    return SubmitCallable(&MailManagerClient::GetArchiveExport, request);
  }
 
  template <typename GetArchiveExportRequestT = Model::GetArchiveExportRequest>
  void GetArchiveExportAsync(const GetArchiveExportRequestT& request, const GetArchiveExportResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::GetArchiveExport, request, handler, context);
  }
 
  virtual Model::GetArchiveMessageOutcome GetArchiveMessage(const Model::GetArchiveMessageRequest& request) const;
 
  template <typename GetArchiveMessageRequestT = Model::GetArchiveMessageRequest>
  Model::GetArchiveMessageOutcomeCallable GetArchiveMessageCallable(const GetArchiveMessageRequestT& request) const {
    return SubmitCallable(&MailManagerClient::GetArchiveMessage, request);
  }
 
  template <typename GetArchiveMessageRequestT = Model::GetArchiveMessageRequest>
  void GetArchiveMessageAsync(const GetArchiveMessageRequestT& request, const GetArchiveMessageResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::GetArchiveMessage, request, handler, context);
  }
 
  virtual Model::GetArchiveMessageContentOutcome GetArchiveMessageContent(const Model::GetArchiveMessageContentRequest& request) const;
 
  template <typename GetArchiveMessageContentRequestT = Model::GetArchiveMessageContentRequest>
  Model::GetArchiveMessageContentOutcomeCallable GetArchiveMessageContentCallable(const GetArchiveMessageContentRequestT& request) const {
    return SubmitCallable(&MailManagerClient::GetArchiveMessageContent, request);
  }
 
  template <typename GetArchiveMessageContentRequestT = Model::GetArchiveMessageContentRequest>
  void GetArchiveMessageContentAsync(const GetArchiveMessageContentRequestT& request,
                                     const GetArchiveMessageContentResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::GetArchiveMessageContent, request, handler, context);
  }
 
  virtual Model::GetArchiveSearchOutcome GetArchiveSearch(const Model::GetArchiveSearchRequest& request) const;
 
  template <typename GetArchiveSearchRequestT = Model::GetArchiveSearchRequest>
  Model::GetArchiveSearchOutcomeCallable GetArchiveSearchCallable(const GetArchiveSearchRequestT& request) const {
    return SubmitCallable(&MailManagerClient::GetArchiveSearch, request);
  }
 
  template <typename GetArchiveSearchRequestT = Model::GetArchiveSearchRequest>
  void GetArchiveSearchAsync(const GetArchiveSearchRequestT& request, const GetArchiveSearchResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::GetArchiveSearch, request, handler, context);
  }
 
  virtual Model::GetArchiveSearchResultsOutcome GetArchiveSearchResults(const Model::GetArchiveSearchResultsRequest& request) const;
 
  template <typename GetArchiveSearchResultsRequestT = Model::GetArchiveSearchResultsRequest>
  Model::GetArchiveSearchResultsOutcomeCallable GetArchiveSearchResultsCallable(const GetArchiveSearchResultsRequestT& request) const {
    return SubmitCallable(&MailManagerClient::GetArchiveSearchResults, request);
  }
 
  template <typename GetArchiveSearchResultsRequestT = Model::GetArchiveSearchResultsRequest>
  void GetArchiveSearchResultsAsync(const GetArchiveSearchResultsRequestT& request,
                                    const GetArchiveSearchResultsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::GetArchiveSearchResults, request, handler, context);
  }
 
  virtual Model::GetIngressPointOutcome GetIngressPoint(const Model::GetIngressPointRequest& request) const;
 
  template <typename GetIngressPointRequestT = Model::GetIngressPointRequest>
  Model::GetIngressPointOutcomeCallable GetIngressPointCallable(const GetIngressPointRequestT& request) const {
    return SubmitCallable(&MailManagerClient::GetIngressPoint, request);
  }
 
  template <typename GetIngressPointRequestT = Model::GetIngressPointRequest>
  void GetIngressPointAsync(const GetIngressPointRequestT& request, const GetIngressPointResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::GetIngressPoint, request, handler, context);
  }
 
  virtual Model::GetMemberOfAddressListOutcome GetMemberOfAddressList(const Model::GetMemberOfAddressListRequest& request) const;
 
  template <typename GetMemberOfAddressListRequestT = Model::GetMemberOfAddressListRequest>
  Model::GetMemberOfAddressListOutcomeCallable GetMemberOfAddressListCallable(const GetMemberOfAddressListRequestT& request) const {
    return SubmitCallable(&MailManagerClient::GetMemberOfAddressList, request);
  }
 
  template <typename GetMemberOfAddressListRequestT = Model::GetMemberOfAddressListRequest>
  void GetMemberOfAddressListAsync(const GetMemberOfAddressListRequestT& request,
                                   const GetMemberOfAddressListResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::GetMemberOfAddressList, request, handler, context);
  }
 
  virtual Model::GetRelayOutcome GetRelay(const Model::GetRelayRequest& request) const;
 
  template <typename GetRelayRequestT = Model::GetRelayRequest>
  Model::GetRelayOutcomeCallable GetRelayCallable(const GetRelayRequestT& request) const {
    return SubmitCallable(&MailManagerClient::GetRelay, request);
  }
 
  template <typename GetRelayRequestT = Model::GetRelayRequest>
  void GetRelayAsync(const GetRelayRequestT& request, const GetRelayResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::GetRelay, request, handler, context);
  }
 
  virtual Model::GetRuleSetOutcome GetRuleSet(const Model::GetRuleSetRequest& request) const;
 
  template <typename GetRuleSetRequestT = Model::GetRuleSetRequest>
  Model::GetRuleSetOutcomeCallable GetRuleSetCallable(const GetRuleSetRequestT& request) const {
    return SubmitCallable(&MailManagerClient::GetRuleSet, request);
  }
 
  template <typename GetRuleSetRequestT = Model::GetRuleSetRequest>
  void GetRuleSetAsync(const GetRuleSetRequestT& request, const GetRuleSetResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::GetRuleSet, request, handler, context);
  }
 
  virtual Model::GetTrafficPolicyOutcome GetTrafficPolicy(const Model::GetTrafficPolicyRequest& request) const;
 
  template <typename GetTrafficPolicyRequestT = Model::GetTrafficPolicyRequest>
  Model::GetTrafficPolicyOutcomeCallable GetTrafficPolicyCallable(const GetTrafficPolicyRequestT& request) const {
    return SubmitCallable(&MailManagerClient::GetTrafficPolicy, request);
  }
 
  template <typename GetTrafficPolicyRequestT = Model::GetTrafficPolicyRequest>
  void GetTrafficPolicyAsync(const GetTrafficPolicyRequestT& request, const GetTrafficPolicyResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::GetTrafficPolicy, request, handler, context);
  }
 
  virtual Model::ListAddonInstancesOutcome ListAddonInstances(const Model::ListAddonInstancesRequest& request = {}) const;
 
  template <typename ListAddonInstancesRequestT = Model::ListAddonInstancesRequest>
  Model::ListAddonInstancesOutcomeCallable ListAddonInstancesCallable(const ListAddonInstancesRequestT& request = {}) const {
    return SubmitCallable(&MailManagerClient::ListAddonInstances, request);
  }
 
  template <typename ListAddonInstancesRequestT = Model::ListAddonInstancesRequest>
  void ListAddonInstancesAsync(const ListAddonInstancesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListAddonInstancesRequestT& request = {}) const {
    return SubmitAsync(&MailManagerClient::ListAddonInstances, request, handler, context);
  }
 
  virtual Model::ListAddonSubscriptionsOutcome ListAddonSubscriptions(const Model::ListAddonSubscriptionsRequest& request = {}) const;
 
  template <typename ListAddonSubscriptionsRequestT = Model::ListAddonSubscriptionsRequest>
  Model::ListAddonSubscriptionsOutcomeCallable ListAddonSubscriptionsCallable(const ListAddonSubscriptionsRequestT& request = {}) const {
    return SubmitCallable(&MailManagerClient::ListAddonSubscriptions, request);
  }
 
  template <typename ListAddonSubscriptionsRequestT = Model::ListAddonSubscriptionsRequest>
  void ListAddonSubscriptionsAsync(const ListAddonSubscriptionsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListAddonSubscriptionsRequestT& request = {}) const {
    return SubmitAsync(&MailManagerClient::ListAddonSubscriptions, request, handler, context);
  }
 
  virtual Model::ListAddressListImportJobsOutcome ListAddressListImportJobs(const Model::ListAddressListImportJobsRequest& request) const;
 
  template <typename ListAddressListImportJobsRequestT = Model::ListAddressListImportJobsRequest>
  Model::ListAddressListImportJobsOutcomeCallable ListAddressListImportJobsCallable(
      const ListAddressListImportJobsRequestT& request) const {
    return SubmitCallable(&MailManagerClient::ListAddressListImportJobs, request);
  }
 
  template <typename ListAddressListImportJobsRequestT = Model::ListAddressListImportJobsRequest>
  void ListAddressListImportJobsAsync(const ListAddressListImportJobsRequestT& request,
                                      const ListAddressListImportJobsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::ListAddressListImportJobs, request, handler, context);
  }
 
  virtual Model::ListAddressListsOutcome ListAddressLists(const Model::ListAddressListsRequest& request = {}) const;
 
  template <typename ListAddressListsRequestT = Model::ListAddressListsRequest>
  Model::ListAddressListsOutcomeCallable ListAddressListsCallable(const ListAddressListsRequestT& request = {}) const {
    return SubmitCallable(&MailManagerClient::ListAddressLists, request);
  }
 
  template <typename ListAddressListsRequestT = Model::ListAddressListsRequest>
  void ListAddressListsAsync(const ListAddressListsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListAddressListsRequestT& request = {}) const {
    return SubmitAsync(&MailManagerClient::ListAddressLists, request, handler, context);
  }
 
  virtual Model::ListArchiveExportsOutcome ListArchiveExports(const Model::ListArchiveExportsRequest& request) const;
 
  template <typename ListArchiveExportsRequestT = Model::ListArchiveExportsRequest>
  Model::ListArchiveExportsOutcomeCallable ListArchiveExportsCallable(const ListArchiveExportsRequestT& request) const {
    return SubmitCallable(&MailManagerClient::ListArchiveExports, request);
  }
 
  template <typename ListArchiveExportsRequestT = Model::ListArchiveExportsRequest>
  void ListArchiveExportsAsync(const ListArchiveExportsRequestT& request, const ListArchiveExportsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::ListArchiveExports, request, handler, context);
  }
 
  virtual Model::ListArchiveSearchesOutcome ListArchiveSearches(const Model::ListArchiveSearchesRequest& request) const;
 
  template <typename ListArchiveSearchesRequestT = Model::ListArchiveSearchesRequest>
  Model::ListArchiveSearchesOutcomeCallable ListArchiveSearchesCallable(const ListArchiveSearchesRequestT& request) const {
    return SubmitCallable(&MailManagerClient::ListArchiveSearches, request);
  }
 
  template <typename ListArchiveSearchesRequestT = Model::ListArchiveSearchesRequest>
  void ListArchiveSearchesAsync(const ListArchiveSearchesRequestT& request, const ListArchiveSearchesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::ListArchiveSearches, request, handler, context);
  }
 
  virtual Model::ListArchivesOutcome ListArchives(const Model::ListArchivesRequest& request = {}) const;
 
  template <typename ListArchivesRequestT = Model::ListArchivesRequest>
  Model::ListArchivesOutcomeCallable ListArchivesCallable(const ListArchivesRequestT& request = {}) const {
    return SubmitCallable(&MailManagerClient::ListArchives, request);
  }
 
  template <typename ListArchivesRequestT = Model::ListArchivesRequest>
  void ListArchivesAsync(const ListArchivesResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListArchivesRequestT& request = {}) const {
    return SubmitAsync(&MailManagerClient::ListArchives, request, handler, context);
  }
 
  virtual Model::ListIngressPointsOutcome ListIngressPoints(const Model::ListIngressPointsRequest& request = {}) const;
 
  template <typename ListIngressPointsRequestT = Model::ListIngressPointsRequest>
  Model::ListIngressPointsOutcomeCallable ListIngressPointsCallable(const ListIngressPointsRequestT& request = {}) const {
    return SubmitCallable(&MailManagerClient::ListIngressPoints, request);
  }
 
  template <typename ListIngressPointsRequestT = Model::ListIngressPointsRequest>
  void ListIngressPointsAsync(const ListIngressPointsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListIngressPointsRequestT& request = {}) const {
    return SubmitAsync(&MailManagerClient::ListIngressPoints, request, handler, context);
  }
 
  virtual Model::ListMembersOfAddressListOutcome ListMembersOfAddressList(const Model::ListMembersOfAddressListRequest& request) const;
 
  template <typename ListMembersOfAddressListRequestT = Model::ListMembersOfAddressListRequest>
  Model::ListMembersOfAddressListOutcomeCallable ListMembersOfAddressListCallable(const ListMembersOfAddressListRequestT& request) const {
    return SubmitCallable(&MailManagerClient::ListMembersOfAddressList, request);
  }
 
  template <typename ListMembersOfAddressListRequestT = Model::ListMembersOfAddressListRequest>
  void ListMembersOfAddressListAsync(const ListMembersOfAddressListRequestT& request,
                                     const ListMembersOfAddressListResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::ListMembersOfAddressList, request, handler, context);
  }
 
  virtual Model::ListRelaysOutcome ListRelays(const Model::ListRelaysRequest& request = {}) const;
 
  template <typename ListRelaysRequestT = Model::ListRelaysRequest>
  Model::ListRelaysOutcomeCallable ListRelaysCallable(const ListRelaysRequestT& request = {}) const {
    return SubmitCallable(&MailManagerClient::ListRelays, request);
  }
 
  template <typename ListRelaysRequestT = Model::ListRelaysRequest>
  void ListRelaysAsync(const ListRelaysResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                       const ListRelaysRequestT& request = {}) const {
    return SubmitAsync(&MailManagerClient::ListRelays, request, handler, context);
  }
 
  virtual Model::ListRuleSetsOutcome ListRuleSets(const Model::ListRuleSetsRequest& request = {}) const;
 
  template <typename ListRuleSetsRequestT = Model::ListRuleSetsRequest>
  Model::ListRuleSetsOutcomeCallable ListRuleSetsCallable(const ListRuleSetsRequestT& request = {}) const {
    return SubmitCallable(&MailManagerClient::ListRuleSets, request);
  }
 
  template <typename ListRuleSetsRequestT = Model::ListRuleSetsRequest>
  void ListRuleSetsAsync(const ListRuleSetsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListRuleSetsRequestT& request = {}) const {
    return SubmitAsync(&MailManagerClient::ListRuleSets, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&MailManagerClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListTrafficPoliciesOutcome ListTrafficPolicies(const Model::ListTrafficPoliciesRequest& request = {}) const;
 
  template <typename ListTrafficPoliciesRequestT = Model::ListTrafficPoliciesRequest>
  Model::ListTrafficPoliciesOutcomeCallable ListTrafficPoliciesCallable(const ListTrafficPoliciesRequestT& request = {}) const {
    return SubmitCallable(&MailManagerClient::ListTrafficPolicies, request);
  }
 
  template <typename ListTrafficPoliciesRequestT = Model::ListTrafficPoliciesRequest>
  void ListTrafficPoliciesAsync(const ListTrafficPoliciesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListTrafficPoliciesRequestT& request = {}) const {
    return SubmitAsync(&MailManagerClient::ListTrafficPolicies, request, handler, context);
  }
 
  virtual Model::RegisterMemberToAddressListOutcome RegisterMemberToAddressList(
      const Model::RegisterMemberToAddressListRequest& request) const;
 
  template <typename RegisterMemberToAddressListRequestT = Model::RegisterMemberToAddressListRequest>
  Model::RegisterMemberToAddressListOutcomeCallable RegisterMemberToAddressListCallable(
      const RegisterMemberToAddressListRequestT& request) const {
    return SubmitCallable(&MailManagerClient::RegisterMemberToAddressList, request);
  }
 
  template <typename RegisterMemberToAddressListRequestT = Model::RegisterMemberToAddressListRequest>
  void RegisterMemberToAddressListAsync(const RegisterMemberToAddressListRequestT& request,
                                        const RegisterMemberToAddressListResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::RegisterMemberToAddressList, request, handler, context);
  }
 
  virtual Model::StartAddressListImportJobOutcome StartAddressListImportJob(const Model::StartAddressListImportJobRequest& request) const;
 
  template <typename StartAddressListImportJobRequestT = Model::StartAddressListImportJobRequest>
  Model::StartAddressListImportJobOutcomeCallable StartAddressListImportJobCallable(
      const StartAddressListImportJobRequestT& request) const {
    return SubmitCallable(&MailManagerClient::StartAddressListImportJob, request);
  }
 
  template <typename StartAddressListImportJobRequestT = Model::StartAddressListImportJobRequest>
  void StartAddressListImportJobAsync(const StartAddressListImportJobRequestT& request,
                                      const StartAddressListImportJobResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::StartAddressListImportJob, request, handler, context);
  }
 
  virtual Model::StartArchiveExportOutcome StartArchiveExport(const Model::StartArchiveExportRequest& request) const;
 
  template <typename StartArchiveExportRequestT = Model::StartArchiveExportRequest>
  Model::StartArchiveExportOutcomeCallable StartArchiveExportCallable(const StartArchiveExportRequestT& request) const {
    return SubmitCallable(&MailManagerClient::StartArchiveExport, request);
  }
 
  template <typename StartArchiveExportRequestT = Model::StartArchiveExportRequest>
  void StartArchiveExportAsync(const StartArchiveExportRequestT& request, const StartArchiveExportResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::StartArchiveExport, request, handler, context);
  }
 
  virtual Model::StartArchiveSearchOutcome StartArchiveSearch(const Model::StartArchiveSearchRequest& request) const;
 
  template <typename StartArchiveSearchRequestT = Model::StartArchiveSearchRequest>
  Model::StartArchiveSearchOutcomeCallable StartArchiveSearchCallable(const StartArchiveSearchRequestT& request) const {
    return SubmitCallable(&MailManagerClient::StartArchiveSearch, request);
  }
 
  template <typename StartArchiveSearchRequestT = Model::StartArchiveSearchRequest>
  void StartArchiveSearchAsync(const StartArchiveSearchRequestT& request, const StartArchiveSearchResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::StartArchiveSearch, request, handler, context);
  }
 
  virtual Model::StopAddressListImportJobOutcome StopAddressListImportJob(const Model::StopAddressListImportJobRequest& request) const;
 
  template <typename StopAddressListImportJobRequestT = Model::StopAddressListImportJobRequest>
  Model::StopAddressListImportJobOutcomeCallable StopAddressListImportJobCallable(const StopAddressListImportJobRequestT& request) const {
    return SubmitCallable(&MailManagerClient::StopAddressListImportJob, request);
  }
 
  template <typename StopAddressListImportJobRequestT = Model::StopAddressListImportJobRequest>
  void StopAddressListImportJobAsync(const StopAddressListImportJobRequestT& request,
                                     const StopAddressListImportJobResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::StopAddressListImportJob, request, handler, context);
  }
 
  virtual Model::StopArchiveExportOutcome StopArchiveExport(const Model::StopArchiveExportRequest& request) const;
 
  template <typename StopArchiveExportRequestT = Model::StopArchiveExportRequest>
  Model::StopArchiveExportOutcomeCallable StopArchiveExportCallable(const StopArchiveExportRequestT& request) const {
    return SubmitCallable(&MailManagerClient::StopArchiveExport, request);
  }
 
  template <typename StopArchiveExportRequestT = Model::StopArchiveExportRequest>
  void StopArchiveExportAsync(const StopArchiveExportRequestT& request, const StopArchiveExportResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::StopArchiveExport, request, handler, context);
  }
 
  virtual Model::StopArchiveSearchOutcome StopArchiveSearch(const Model::StopArchiveSearchRequest& request) const;
 
  template <typename StopArchiveSearchRequestT = Model::StopArchiveSearchRequest>
  Model::StopArchiveSearchOutcomeCallable StopArchiveSearchCallable(const StopArchiveSearchRequestT& request) const {
    return SubmitCallable(&MailManagerClient::StopArchiveSearch, request);
  }
 
  template <typename StopArchiveSearchRequestT = Model::StopArchiveSearchRequest>
  void StopArchiveSearchAsync(const StopArchiveSearchRequestT& request, const StopArchiveSearchResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::StopArchiveSearch, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&MailManagerClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&MailManagerClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateArchiveOutcome UpdateArchive(const Model::UpdateArchiveRequest& request) const;
 
  template <typename UpdateArchiveRequestT = Model::UpdateArchiveRequest>
  Model::UpdateArchiveOutcomeCallable UpdateArchiveCallable(const UpdateArchiveRequestT& request) const {
    return SubmitCallable(&MailManagerClient::UpdateArchive, request);
  }
 
  template <typename UpdateArchiveRequestT = Model::UpdateArchiveRequest>
  void UpdateArchiveAsync(const UpdateArchiveRequestT& request, const UpdateArchiveResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::UpdateArchive, request, handler, context);
  }
 
  virtual Model::UpdateIngressPointOutcome UpdateIngressPoint(const Model::UpdateIngressPointRequest& request) const;
 
  template <typename UpdateIngressPointRequestT = Model::UpdateIngressPointRequest>
  Model::UpdateIngressPointOutcomeCallable UpdateIngressPointCallable(const UpdateIngressPointRequestT& request) const {
    return SubmitCallable(&MailManagerClient::UpdateIngressPoint, request);
  }
 
  template <typename UpdateIngressPointRequestT = Model::UpdateIngressPointRequest>
  void UpdateIngressPointAsync(const UpdateIngressPointRequestT& request, const UpdateIngressPointResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::UpdateIngressPoint, request, handler, context);
  }
 
  virtual Model::UpdateRelayOutcome UpdateRelay(const Model::UpdateRelayRequest& request) const;
 
  template <typename UpdateRelayRequestT = Model::UpdateRelayRequest>
  Model::UpdateRelayOutcomeCallable UpdateRelayCallable(const UpdateRelayRequestT& request) const {
    return SubmitCallable(&MailManagerClient::UpdateRelay, request);
  }
 
  template <typename UpdateRelayRequestT = Model::UpdateRelayRequest>
  void UpdateRelayAsync(const UpdateRelayRequestT& request, const UpdateRelayResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::UpdateRelay, request, handler, context);
  }
 
  virtual Model::UpdateRuleSetOutcome UpdateRuleSet(const Model::UpdateRuleSetRequest& request) const;
 
  template <typename UpdateRuleSetRequestT = Model::UpdateRuleSetRequest>
  Model::UpdateRuleSetOutcomeCallable UpdateRuleSetCallable(const UpdateRuleSetRequestT& request) const {
    return SubmitCallable(&MailManagerClient::UpdateRuleSet, request);
  }
 
  template <typename UpdateRuleSetRequestT = Model::UpdateRuleSetRequest>
  void UpdateRuleSetAsync(const UpdateRuleSetRequestT& request, const UpdateRuleSetResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::UpdateRuleSet, request, handler, context);
  }
 
  virtual Model::UpdateTrafficPolicyOutcome UpdateTrafficPolicy(const Model::UpdateTrafficPolicyRequest& request) const;
 
  template <typename UpdateTrafficPolicyRequestT = Model::UpdateTrafficPolicyRequest>
  Model::UpdateTrafficPolicyOutcomeCallable UpdateTrafficPolicyCallable(const UpdateTrafficPolicyRequestT& request) const {
    return SubmitCallable(&MailManagerClient::UpdateTrafficPolicy, request);
  }
 
  template <typename UpdateTrafficPolicyRequestT = Model::UpdateTrafficPolicyRequest>
  void UpdateTrafficPolicyAsync(const UpdateTrafficPolicyRequestT& request, const UpdateTrafficPolicyResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MailManagerClient::UpdateTrafficPolicy, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<MailManagerEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<MailManagerClient>;
  void init(const MailManagerClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, MailManagerError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  MailManagerClientConfiguration m_clientConfiguration;
  std::shared_ptr<MailManagerEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace MailManager
}  // namespace Aws