MailManagerClient.h

 
#pragma once
#include <aws/mailmanager/MailManager_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/mailmanager/MailManagerServiceClientModel.h>
 
namespace Aws
{
namespace MailManager
{
  class AWS_MAILMANAGER_API MailManagerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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::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::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::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::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::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::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::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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<MailManagerEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<MailManagerClient>;
      void init(const MailManagerClientConfiguration& clientConfiguration);
 
      MailManagerClientConfiguration m_clientConfiguration;
      std::shared_ptr<MailManagerEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace MailManager
} // namespace Aws