FMSClient.h

 
#pragma once
#include <aws/fms/FMS_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/fms/FMSServiceClientModel.h>
 
namespace Aws
{
namespace FMS
{
  class AWS_FMS_API FMSClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<FMSClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef FMSClientConfiguration ClientConfigurationType;
      typedef FMSEndpointProvider EndpointProviderType;
 
        FMSClient(const Aws::FMS::FMSClientConfiguration& clientConfiguration = Aws::FMS::FMSClientConfiguration(),
                  std::shared_ptr<FMSEndpointProviderBase> endpointProvider = nullptr);
 
        FMSClient(const Aws::Auth::AWSCredentials& credentials,
                  std::shared_ptr<FMSEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::FMS::FMSClientConfiguration& clientConfiguration = Aws::FMS::FMSClientConfiguration());
 
        FMSClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<FMSEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::FMS::FMSClientConfiguration& clientConfiguration = Aws::FMS::FMSClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        FMSClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        FMSClient(const Aws::Auth::AWSCredentials& credentials,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        FMSClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~FMSClient();
 
        virtual Model::AssociateAdminAccountOutcome AssociateAdminAccount(const Model::AssociateAdminAccountRequest& request) const;
 
        template<typename AssociateAdminAccountRequestT = Model::AssociateAdminAccountRequest>
        Model::AssociateAdminAccountOutcomeCallable AssociateAdminAccountCallable(const AssociateAdminAccountRequestT& request) const
        {
            return SubmitCallable(&FMSClient::AssociateAdminAccount, request);
        }
 
        template<typename AssociateAdminAccountRequestT = Model::AssociateAdminAccountRequest>
        void AssociateAdminAccountAsync(const AssociateAdminAccountRequestT& request, const AssociateAdminAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::AssociateAdminAccount, request, handler, context);
        }
 
        virtual Model::AssociateThirdPartyFirewallOutcome AssociateThirdPartyFirewall(const Model::AssociateThirdPartyFirewallRequest& request) const;
 
        template<typename AssociateThirdPartyFirewallRequestT = Model::AssociateThirdPartyFirewallRequest>
        Model::AssociateThirdPartyFirewallOutcomeCallable AssociateThirdPartyFirewallCallable(const AssociateThirdPartyFirewallRequestT& request) const
        {
            return SubmitCallable(&FMSClient::AssociateThirdPartyFirewall, request);
        }
 
        template<typename AssociateThirdPartyFirewallRequestT = Model::AssociateThirdPartyFirewallRequest>
        void AssociateThirdPartyFirewallAsync(const AssociateThirdPartyFirewallRequestT& request, const AssociateThirdPartyFirewallResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::AssociateThirdPartyFirewall, request, handler, context);
        }
 
        virtual Model::BatchAssociateResourceOutcome BatchAssociateResource(const Model::BatchAssociateResourceRequest& request) const;
 
        template<typename BatchAssociateResourceRequestT = Model::BatchAssociateResourceRequest>
        Model::BatchAssociateResourceOutcomeCallable BatchAssociateResourceCallable(const BatchAssociateResourceRequestT& request) const
        {
            return SubmitCallable(&FMSClient::BatchAssociateResource, request);
        }
 
        template<typename BatchAssociateResourceRequestT = Model::BatchAssociateResourceRequest>
        void BatchAssociateResourceAsync(const BatchAssociateResourceRequestT& request, const BatchAssociateResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::BatchAssociateResource, request, handler, context);
        }
 
        virtual Model::BatchDisassociateResourceOutcome BatchDisassociateResource(const Model::BatchDisassociateResourceRequest& request) const;
 
        template<typename BatchDisassociateResourceRequestT = Model::BatchDisassociateResourceRequest>
        Model::BatchDisassociateResourceOutcomeCallable BatchDisassociateResourceCallable(const BatchDisassociateResourceRequestT& request) const
        {
            return SubmitCallable(&FMSClient::BatchDisassociateResource, request);
        }
 
        template<typename BatchDisassociateResourceRequestT = Model::BatchDisassociateResourceRequest>
        void BatchDisassociateResourceAsync(const BatchDisassociateResourceRequestT& request, const BatchDisassociateResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::BatchDisassociateResource, request, handler, context);
        }
 
        virtual Model::DeleteAppsListOutcome DeleteAppsList(const Model::DeleteAppsListRequest& request) const;
 
        template<typename DeleteAppsListRequestT = Model::DeleteAppsListRequest>
        Model::DeleteAppsListOutcomeCallable DeleteAppsListCallable(const DeleteAppsListRequestT& request) const
        {
            return SubmitCallable(&FMSClient::DeleteAppsList, request);
        }
 
        template<typename DeleteAppsListRequestT = Model::DeleteAppsListRequest>
        void DeleteAppsListAsync(const DeleteAppsListRequestT& request, const DeleteAppsListResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::DeleteAppsList, request, handler, context);
        }
 
        virtual Model::DeleteNotificationChannelOutcome DeleteNotificationChannel(const Model::DeleteNotificationChannelRequest& request = {}) const;
 
        template<typename DeleteNotificationChannelRequestT = Model::DeleteNotificationChannelRequest>
        Model::DeleteNotificationChannelOutcomeCallable DeleteNotificationChannelCallable(const DeleteNotificationChannelRequestT& request = {}) const
        {
            return SubmitCallable(&FMSClient::DeleteNotificationChannel, request);
        }
 
        template<typename DeleteNotificationChannelRequestT = Model::DeleteNotificationChannelRequest>
        void DeleteNotificationChannelAsync(const DeleteNotificationChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteNotificationChannelRequestT& request = {}) const
        {
            return SubmitAsync(&FMSClient::DeleteNotificationChannel, request, handler, context);
        }
 
        virtual Model::DeletePolicyOutcome DeletePolicy(const Model::DeletePolicyRequest& request) const;
 
        template<typename DeletePolicyRequestT = Model::DeletePolicyRequest>
        Model::DeletePolicyOutcomeCallable DeletePolicyCallable(const DeletePolicyRequestT& request) const
        {
            return SubmitCallable(&FMSClient::DeletePolicy, request);
        }
 
        template<typename DeletePolicyRequestT = Model::DeletePolicyRequest>
        void DeletePolicyAsync(const DeletePolicyRequestT& request, const DeletePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::DeletePolicy, request, handler, context);
        }
 
        virtual Model::DeleteProtocolsListOutcome DeleteProtocolsList(const Model::DeleteProtocolsListRequest& request) const;
 
        template<typename DeleteProtocolsListRequestT = Model::DeleteProtocolsListRequest>
        Model::DeleteProtocolsListOutcomeCallable DeleteProtocolsListCallable(const DeleteProtocolsListRequestT& request) const
        {
            return SubmitCallable(&FMSClient::DeleteProtocolsList, request);
        }
 
        template<typename DeleteProtocolsListRequestT = Model::DeleteProtocolsListRequest>
        void DeleteProtocolsListAsync(const DeleteProtocolsListRequestT& request, const DeleteProtocolsListResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::DeleteProtocolsList, request, handler, context);
        }
 
        virtual Model::DeleteResourceSetOutcome DeleteResourceSet(const Model::DeleteResourceSetRequest& request) const;
 
        template<typename DeleteResourceSetRequestT = Model::DeleteResourceSetRequest>
        Model::DeleteResourceSetOutcomeCallable DeleteResourceSetCallable(const DeleteResourceSetRequestT& request) const
        {
            return SubmitCallable(&FMSClient::DeleteResourceSet, request);
        }
 
        template<typename DeleteResourceSetRequestT = Model::DeleteResourceSetRequest>
        void DeleteResourceSetAsync(const DeleteResourceSetRequestT& request, const DeleteResourceSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::DeleteResourceSet, request, handler, context);
        }
 
        virtual Model::DisassociateAdminAccountOutcome DisassociateAdminAccount(const Model::DisassociateAdminAccountRequest& request = {}) const;
 
        template<typename DisassociateAdminAccountRequestT = Model::DisassociateAdminAccountRequest>
        Model::DisassociateAdminAccountOutcomeCallable DisassociateAdminAccountCallable(const DisassociateAdminAccountRequestT& request = {}) const
        {
            return SubmitCallable(&FMSClient::DisassociateAdminAccount, request);
        }
 
        template<typename DisassociateAdminAccountRequestT = Model::DisassociateAdminAccountRequest>
        void DisassociateAdminAccountAsync(const DisassociateAdminAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DisassociateAdminAccountRequestT& request = {}) const
        {
            return SubmitAsync(&FMSClient::DisassociateAdminAccount, request, handler, context);
        }
 
        virtual Model::DisassociateThirdPartyFirewallOutcome DisassociateThirdPartyFirewall(const Model::DisassociateThirdPartyFirewallRequest& request) const;
 
        template<typename DisassociateThirdPartyFirewallRequestT = Model::DisassociateThirdPartyFirewallRequest>
        Model::DisassociateThirdPartyFirewallOutcomeCallable DisassociateThirdPartyFirewallCallable(const DisassociateThirdPartyFirewallRequestT& request) const
        {
            return SubmitCallable(&FMSClient::DisassociateThirdPartyFirewall, request);
        }
 
        template<typename DisassociateThirdPartyFirewallRequestT = Model::DisassociateThirdPartyFirewallRequest>
        void DisassociateThirdPartyFirewallAsync(const DisassociateThirdPartyFirewallRequestT& request, const DisassociateThirdPartyFirewallResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::DisassociateThirdPartyFirewall, request, handler, context);
        }
 
        virtual Model::GetAdminAccountOutcome GetAdminAccount(const Model::GetAdminAccountRequest& request = {}) const;
 
        template<typename GetAdminAccountRequestT = Model::GetAdminAccountRequest>
        Model::GetAdminAccountOutcomeCallable GetAdminAccountCallable(const GetAdminAccountRequestT& request = {}) const
        {
            return SubmitCallable(&FMSClient::GetAdminAccount, request);
        }
 
        template<typename GetAdminAccountRequestT = Model::GetAdminAccountRequest>
        void GetAdminAccountAsync(const GetAdminAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetAdminAccountRequestT& request = {}) const
        {
            return SubmitAsync(&FMSClient::GetAdminAccount, request, handler, context);
        }
 
        virtual Model::GetAdminScopeOutcome GetAdminScope(const Model::GetAdminScopeRequest& request) const;
 
        template<typename GetAdminScopeRequestT = Model::GetAdminScopeRequest>
        Model::GetAdminScopeOutcomeCallable GetAdminScopeCallable(const GetAdminScopeRequestT& request) const
        {
            return SubmitCallable(&FMSClient::GetAdminScope, request);
        }
 
        template<typename GetAdminScopeRequestT = Model::GetAdminScopeRequest>
        void GetAdminScopeAsync(const GetAdminScopeRequestT& request, const GetAdminScopeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::GetAdminScope, request, handler, context);
        }
 
        virtual Model::GetAppsListOutcome GetAppsList(const Model::GetAppsListRequest& request) const;
 
        template<typename GetAppsListRequestT = Model::GetAppsListRequest>
        Model::GetAppsListOutcomeCallable GetAppsListCallable(const GetAppsListRequestT& request) const
        {
            return SubmitCallable(&FMSClient::GetAppsList, request);
        }
 
        template<typename GetAppsListRequestT = Model::GetAppsListRequest>
        void GetAppsListAsync(const GetAppsListRequestT& request, const GetAppsListResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::GetAppsList, request, handler, context);
        }
 
        virtual Model::GetComplianceDetailOutcome GetComplianceDetail(const Model::GetComplianceDetailRequest& request) const;
 
        template<typename GetComplianceDetailRequestT = Model::GetComplianceDetailRequest>
        Model::GetComplianceDetailOutcomeCallable GetComplianceDetailCallable(const GetComplianceDetailRequestT& request) const
        {
            return SubmitCallable(&FMSClient::GetComplianceDetail, request);
        }
 
        template<typename GetComplianceDetailRequestT = Model::GetComplianceDetailRequest>
        void GetComplianceDetailAsync(const GetComplianceDetailRequestT& request, const GetComplianceDetailResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::GetComplianceDetail, request, handler, context);
        }
 
        virtual Model::GetNotificationChannelOutcome GetNotificationChannel(const Model::GetNotificationChannelRequest& request = {}) const;
 
        template<typename GetNotificationChannelRequestT = Model::GetNotificationChannelRequest>
        Model::GetNotificationChannelOutcomeCallable GetNotificationChannelCallable(const GetNotificationChannelRequestT& request = {}) const
        {
            return SubmitCallable(&FMSClient::GetNotificationChannel, request);
        }
 
        template<typename GetNotificationChannelRequestT = Model::GetNotificationChannelRequest>
        void GetNotificationChannelAsync(const GetNotificationChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetNotificationChannelRequestT& request = {}) const
        {
            return SubmitAsync(&FMSClient::GetNotificationChannel, request, handler, context);
        }
 
        virtual Model::GetPolicyOutcome GetPolicy(const Model::GetPolicyRequest& request) const;
 
        template<typename GetPolicyRequestT = Model::GetPolicyRequest>
        Model::GetPolicyOutcomeCallable GetPolicyCallable(const GetPolicyRequestT& request) const
        {
            return SubmitCallable(&FMSClient::GetPolicy, request);
        }
 
        template<typename GetPolicyRequestT = Model::GetPolicyRequest>
        void GetPolicyAsync(const GetPolicyRequestT& request, const GetPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::GetPolicy, request, handler, context);
        }
 
        virtual Model::GetProtectionStatusOutcome GetProtectionStatus(const Model::GetProtectionStatusRequest& request) const;
 
        template<typename GetProtectionStatusRequestT = Model::GetProtectionStatusRequest>
        Model::GetProtectionStatusOutcomeCallable GetProtectionStatusCallable(const GetProtectionStatusRequestT& request) const
        {
            return SubmitCallable(&FMSClient::GetProtectionStatus, request);
        }
 
        template<typename GetProtectionStatusRequestT = Model::GetProtectionStatusRequest>
        void GetProtectionStatusAsync(const GetProtectionStatusRequestT& request, const GetProtectionStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::GetProtectionStatus, request, handler, context);
        }
 
        virtual Model::GetProtocolsListOutcome GetProtocolsList(const Model::GetProtocolsListRequest& request) const;
 
        template<typename GetProtocolsListRequestT = Model::GetProtocolsListRequest>
        Model::GetProtocolsListOutcomeCallable GetProtocolsListCallable(const GetProtocolsListRequestT& request) const
        {
            return SubmitCallable(&FMSClient::GetProtocolsList, request);
        }
 
        template<typename GetProtocolsListRequestT = Model::GetProtocolsListRequest>
        void GetProtocolsListAsync(const GetProtocolsListRequestT& request, const GetProtocolsListResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::GetProtocolsList, request, handler, context);
        }
 
        virtual Model::GetResourceSetOutcome GetResourceSet(const Model::GetResourceSetRequest& request) const;
 
        template<typename GetResourceSetRequestT = Model::GetResourceSetRequest>
        Model::GetResourceSetOutcomeCallable GetResourceSetCallable(const GetResourceSetRequestT& request) const
        {
            return SubmitCallable(&FMSClient::GetResourceSet, request);
        }
 
        template<typename GetResourceSetRequestT = Model::GetResourceSetRequest>
        void GetResourceSetAsync(const GetResourceSetRequestT& request, const GetResourceSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::GetResourceSet, request, handler, context);
        }
 
        virtual Model::GetThirdPartyFirewallAssociationStatusOutcome GetThirdPartyFirewallAssociationStatus(const Model::GetThirdPartyFirewallAssociationStatusRequest& request) const;
 
        template<typename GetThirdPartyFirewallAssociationStatusRequestT = Model::GetThirdPartyFirewallAssociationStatusRequest>
        Model::GetThirdPartyFirewallAssociationStatusOutcomeCallable GetThirdPartyFirewallAssociationStatusCallable(const GetThirdPartyFirewallAssociationStatusRequestT& request) const
        {
            return SubmitCallable(&FMSClient::GetThirdPartyFirewallAssociationStatus, request);
        }
 
        template<typename GetThirdPartyFirewallAssociationStatusRequestT = Model::GetThirdPartyFirewallAssociationStatusRequest>
        void GetThirdPartyFirewallAssociationStatusAsync(const GetThirdPartyFirewallAssociationStatusRequestT& request, const GetThirdPartyFirewallAssociationStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::GetThirdPartyFirewallAssociationStatus, request, handler, context);
        }
 
        virtual Model::GetViolationDetailsOutcome GetViolationDetails(const Model::GetViolationDetailsRequest& request) const;
 
        template<typename GetViolationDetailsRequestT = Model::GetViolationDetailsRequest>
        Model::GetViolationDetailsOutcomeCallable GetViolationDetailsCallable(const GetViolationDetailsRequestT& request) const
        {
            return SubmitCallable(&FMSClient::GetViolationDetails, request);
        }
 
        template<typename GetViolationDetailsRequestT = Model::GetViolationDetailsRequest>
        void GetViolationDetailsAsync(const GetViolationDetailsRequestT& request, const GetViolationDetailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::GetViolationDetails, request, handler, context);
        }
 
        virtual Model::ListAdminAccountsForOrganizationOutcome ListAdminAccountsForOrganization(const Model::ListAdminAccountsForOrganizationRequest& request = {}) const;
 
        template<typename ListAdminAccountsForOrganizationRequestT = Model::ListAdminAccountsForOrganizationRequest>
        Model::ListAdminAccountsForOrganizationOutcomeCallable ListAdminAccountsForOrganizationCallable(const ListAdminAccountsForOrganizationRequestT& request = {}) const
        {
            return SubmitCallable(&FMSClient::ListAdminAccountsForOrganization, request);
        }
 
        template<typename ListAdminAccountsForOrganizationRequestT = Model::ListAdminAccountsForOrganizationRequest>
        void ListAdminAccountsForOrganizationAsync(const ListAdminAccountsForOrganizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAdminAccountsForOrganizationRequestT& request = {}) const
        {
            return SubmitAsync(&FMSClient::ListAdminAccountsForOrganization, request, handler, context);
        }
 
        virtual Model::ListAdminsManagingAccountOutcome ListAdminsManagingAccount(const Model::ListAdminsManagingAccountRequest& request = {}) const;
 
        template<typename ListAdminsManagingAccountRequestT = Model::ListAdminsManagingAccountRequest>
        Model::ListAdminsManagingAccountOutcomeCallable ListAdminsManagingAccountCallable(const ListAdminsManagingAccountRequestT& request = {}) const
        {
            return SubmitCallable(&FMSClient::ListAdminsManagingAccount, request);
        }
 
        template<typename ListAdminsManagingAccountRequestT = Model::ListAdminsManagingAccountRequest>
        void ListAdminsManagingAccountAsync(const ListAdminsManagingAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAdminsManagingAccountRequestT& request = {}) const
        {
            return SubmitAsync(&FMSClient::ListAdminsManagingAccount, request, handler, context);
        }
 
        virtual Model::ListAppsListsOutcome ListAppsLists(const Model::ListAppsListsRequest& request) const;
 
        template<typename ListAppsListsRequestT = Model::ListAppsListsRequest>
        Model::ListAppsListsOutcomeCallable ListAppsListsCallable(const ListAppsListsRequestT& request) const
        {
            return SubmitCallable(&FMSClient::ListAppsLists, request);
        }
 
        template<typename ListAppsListsRequestT = Model::ListAppsListsRequest>
        void ListAppsListsAsync(const ListAppsListsRequestT& request, const ListAppsListsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::ListAppsLists, request, handler, context);
        }
 
        virtual Model::ListComplianceStatusOutcome ListComplianceStatus(const Model::ListComplianceStatusRequest& request) const;
 
        template<typename ListComplianceStatusRequestT = Model::ListComplianceStatusRequest>
        Model::ListComplianceStatusOutcomeCallable ListComplianceStatusCallable(const ListComplianceStatusRequestT& request) const
        {
            return SubmitCallable(&FMSClient::ListComplianceStatus, request);
        }
 
        template<typename ListComplianceStatusRequestT = Model::ListComplianceStatusRequest>
        void ListComplianceStatusAsync(const ListComplianceStatusRequestT& request, const ListComplianceStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::ListComplianceStatus, request, handler, context);
        }
 
        virtual Model::ListDiscoveredResourcesOutcome ListDiscoveredResources(const Model::ListDiscoveredResourcesRequest& request) const;
 
        template<typename ListDiscoveredResourcesRequestT = Model::ListDiscoveredResourcesRequest>
        Model::ListDiscoveredResourcesOutcomeCallable ListDiscoveredResourcesCallable(const ListDiscoveredResourcesRequestT& request) const
        {
            return SubmitCallable(&FMSClient::ListDiscoveredResources, request);
        }
 
        template<typename ListDiscoveredResourcesRequestT = Model::ListDiscoveredResourcesRequest>
        void ListDiscoveredResourcesAsync(const ListDiscoveredResourcesRequestT& request, const ListDiscoveredResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::ListDiscoveredResources, request, handler, context);
        }
 
        virtual Model::ListMemberAccountsOutcome ListMemberAccounts(const Model::ListMemberAccountsRequest& request = {}) const;
 
        template<typename ListMemberAccountsRequestT = Model::ListMemberAccountsRequest>
        Model::ListMemberAccountsOutcomeCallable ListMemberAccountsCallable(const ListMemberAccountsRequestT& request = {}) const
        {
            return SubmitCallable(&FMSClient::ListMemberAccounts, request);
        }
 
        template<typename ListMemberAccountsRequestT = Model::ListMemberAccountsRequest>
        void ListMemberAccountsAsync(const ListMemberAccountsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListMemberAccountsRequestT& request = {}) const
        {
            return SubmitAsync(&FMSClient::ListMemberAccounts, request, handler, context);
        }
 
        virtual Model::ListPoliciesOutcome ListPolicies(const Model::ListPoliciesRequest& request = {}) const;
 
        template<typename ListPoliciesRequestT = Model::ListPoliciesRequest>
        Model::ListPoliciesOutcomeCallable ListPoliciesCallable(const ListPoliciesRequestT& request = {}) const
        {
            return SubmitCallable(&FMSClient::ListPolicies, request);
        }
 
        template<typename ListPoliciesRequestT = Model::ListPoliciesRequest>
        void ListPoliciesAsync(const ListPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPoliciesRequestT& request = {}) const
        {
            return SubmitAsync(&FMSClient::ListPolicies, request, handler, context);
        }
 
        virtual Model::ListProtocolsListsOutcome ListProtocolsLists(const Model::ListProtocolsListsRequest& request) const;
 
        template<typename ListProtocolsListsRequestT = Model::ListProtocolsListsRequest>
        Model::ListProtocolsListsOutcomeCallable ListProtocolsListsCallable(const ListProtocolsListsRequestT& request) const
        {
            return SubmitCallable(&FMSClient::ListProtocolsLists, request);
        }
 
        template<typename ListProtocolsListsRequestT = Model::ListProtocolsListsRequest>
        void ListProtocolsListsAsync(const ListProtocolsListsRequestT& request, const ListProtocolsListsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::ListProtocolsLists, request, handler, context);
        }
 
        virtual Model::ListResourceSetResourcesOutcome ListResourceSetResources(const Model::ListResourceSetResourcesRequest& request) const;
 
        template<typename ListResourceSetResourcesRequestT = Model::ListResourceSetResourcesRequest>
        Model::ListResourceSetResourcesOutcomeCallable ListResourceSetResourcesCallable(const ListResourceSetResourcesRequestT& request) const
        {
            return SubmitCallable(&FMSClient::ListResourceSetResources, request);
        }
 
        template<typename ListResourceSetResourcesRequestT = Model::ListResourceSetResourcesRequest>
        void ListResourceSetResourcesAsync(const ListResourceSetResourcesRequestT& request, const ListResourceSetResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::ListResourceSetResources, request, handler, context);
        }
 
        virtual Model::ListResourceSetsOutcome ListResourceSets(const Model::ListResourceSetsRequest& request = {}) const;
 
        template<typename ListResourceSetsRequestT = Model::ListResourceSetsRequest>
        Model::ListResourceSetsOutcomeCallable ListResourceSetsCallable(const ListResourceSetsRequestT& request = {}) const
        {
            return SubmitCallable(&FMSClient::ListResourceSets, request);
        }
 
        template<typename ListResourceSetsRequestT = Model::ListResourceSetsRequest>
        void ListResourceSetsAsync(const ListResourceSetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListResourceSetsRequestT& request = {}) const
        {
            return SubmitAsync(&FMSClient::ListResourceSets, 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(&FMSClient::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(&FMSClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListThirdPartyFirewallFirewallPoliciesOutcome ListThirdPartyFirewallFirewallPolicies(const Model::ListThirdPartyFirewallFirewallPoliciesRequest& request) const;
 
        template<typename ListThirdPartyFirewallFirewallPoliciesRequestT = Model::ListThirdPartyFirewallFirewallPoliciesRequest>
        Model::ListThirdPartyFirewallFirewallPoliciesOutcomeCallable ListThirdPartyFirewallFirewallPoliciesCallable(const ListThirdPartyFirewallFirewallPoliciesRequestT& request) const
        {
            return SubmitCallable(&FMSClient::ListThirdPartyFirewallFirewallPolicies, request);
        }
 
        template<typename ListThirdPartyFirewallFirewallPoliciesRequestT = Model::ListThirdPartyFirewallFirewallPoliciesRequest>
        void ListThirdPartyFirewallFirewallPoliciesAsync(const ListThirdPartyFirewallFirewallPoliciesRequestT& request, const ListThirdPartyFirewallFirewallPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::ListThirdPartyFirewallFirewallPolicies, request, handler, context);
        }
 
        virtual Model::PutAdminAccountOutcome PutAdminAccount(const Model::PutAdminAccountRequest& request) const;
 
        template<typename PutAdminAccountRequestT = Model::PutAdminAccountRequest>
        Model::PutAdminAccountOutcomeCallable PutAdminAccountCallable(const PutAdminAccountRequestT& request) const
        {
            return SubmitCallable(&FMSClient::PutAdminAccount, request);
        }
 
        template<typename PutAdminAccountRequestT = Model::PutAdminAccountRequest>
        void PutAdminAccountAsync(const PutAdminAccountRequestT& request, const PutAdminAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::PutAdminAccount, request, handler, context);
        }
 
        virtual Model::PutAppsListOutcome PutAppsList(const Model::PutAppsListRequest& request) const;
 
        template<typename PutAppsListRequestT = Model::PutAppsListRequest>
        Model::PutAppsListOutcomeCallable PutAppsListCallable(const PutAppsListRequestT& request) const
        {
            return SubmitCallable(&FMSClient::PutAppsList, request);
        }
 
        template<typename PutAppsListRequestT = Model::PutAppsListRequest>
        void PutAppsListAsync(const PutAppsListRequestT& request, const PutAppsListResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::PutAppsList, request, handler, context);
        }
 
        virtual Model::PutNotificationChannelOutcome PutNotificationChannel(const Model::PutNotificationChannelRequest& request) const;
 
        template<typename PutNotificationChannelRequestT = Model::PutNotificationChannelRequest>
        Model::PutNotificationChannelOutcomeCallable PutNotificationChannelCallable(const PutNotificationChannelRequestT& request) const
        {
            return SubmitCallable(&FMSClient::PutNotificationChannel, request);
        }
 
        template<typename PutNotificationChannelRequestT = Model::PutNotificationChannelRequest>
        void PutNotificationChannelAsync(const PutNotificationChannelRequestT& request, const PutNotificationChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::PutNotificationChannel, request, handler, context);
        }
 
        virtual Model::PutPolicyOutcome PutPolicy(const Model::PutPolicyRequest& request) const;
 
        template<typename PutPolicyRequestT = Model::PutPolicyRequest>
        Model::PutPolicyOutcomeCallable PutPolicyCallable(const PutPolicyRequestT& request) const
        {
            return SubmitCallable(&FMSClient::PutPolicy, request);
        }
 
        template<typename PutPolicyRequestT = Model::PutPolicyRequest>
        void PutPolicyAsync(const PutPolicyRequestT& request, const PutPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::PutPolicy, request, handler, context);
        }
 
        virtual Model::PutProtocolsListOutcome PutProtocolsList(const Model::PutProtocolsListRequest& request) const;
 
        template<typename PutProtocolsListRequestT = Model::PutProtocolsListRequest>
        Model::PutProtocolsListOutcomeCallable PutProtocolsListCallable(const PutProtocolsListRequestT& request) const
        {
            return SubmitCallable(&FMSClient::PutProtocolsList, request);
        }
 
        template<typename PutProtocolsListRequestT = Model::PutProtocolsListRequest>
        void PutProtocolsListAsync(const PutProtocolsListRequestT& request, const PutProtocolsListResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::PutProtocolsList, request, handler, context);
        }
 
        virtual Model::PutResourceSetOutcome PutResourceSet(const Model::PutResourceSetRequest& request) const;
 
        template<typename PutResourceSetRequestT = Model::PutResourceSetRequest>
        Model::PutResourceSetOutcomeCallable PutResourceSetCallable(const PutResourceSetRequestT& request) const
        {
            return SubmitCallable(&FMSClient::PutResourceSet, request);
        }
 
        template<typename PutResourceSetRequestT = Model::PutResourceSetRequest>
        void PutResourceSetAsync(const PutResourceSetRequestT& request, const PutResourceSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FMSClient::PutResourceSet, 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(&FMSClient::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(&FMSClient::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(&FMSClient::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(&FMSClient::UntagResource, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<FMSEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<FMSClient>;
      void init(const FMSClientConfiguration& clientConfiguration);
 
      FMSClientConfiguration m_clientConfiguration;
      std::shared_ptr<FMSEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace FMS
} // namespace Aws