FMSClient.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/fms/FMSPaginationBase.h>
#include <aws/fms/FMSServiceClientModel.h>
#include <aws/fms/FMS_EXPORTS.h>
 
namespace Aws {
namespace FMS {
class AWS_FMS_API FMSClient : public Aws::Client::AWSJsonClient,
                              public Aws::Client::ClientWithAsyncTemplateMethods<FMSClient>,
                              public FMSPaginationBase<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual 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