NetworkFirewallClient.h

 
#pragma once
#include <aws/network-firewall/NetworkFirewall_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/network-firewall/NetworkFirewallServiceClientModel.h>
 
namespace Aws
{
namespace NetworkFirewall
{
  class AWS_NETWORKFIREWALL_API NetworkFirewallClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<NetworkFirewallClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef NetworkFirewallClientConfiguration ClientConfigurationType;
      typedef NetworkFirewallEndpointProvider EndpointProviderType;
 
        NetworkFirewallClient(const Aws::NetworkFirewall::NetworkFirewallClientConfiguration& clientConfiguration = Aws::NetworkFirewall::NetworkFirewallClientConfiguration(),
                              std::shared_ptr<NetworkFirewallEndpointProviderBase> endpointProvider = nullptr);
 
        NetworkFirewallClient(const Aws::Auth::AWSCredentials& credentials,
                              std::shared_ptr<NetworkFirewallEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::NetworkFirewall::NetworkFirewallClientConfiguration& clientConfiguration = Aws::NetworkFirewall::NetworkFirewallClientConfiguration());
 
        NetworkFirewallClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              std::shared_ptr<NetworkFirewallEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::NetworkFirewall::NetworkFirewallClientConfiguration& clientConfiguration = Aws::NetworkFirewall::NetworkFirewallClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        NetworkFirewallClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        NetworkFirewallClient(const Aws::Auth::AWSCredentials& credentials,
                              const Aws::Client::ClientConfiguration& clientConfiguration);
 
        NetworkFirewallClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~NetworkFirewallClient();
 
        virtual Model::AssociateFirewallPolicyOutcome AssociateFirewallPolicy(const Model::AssociateFirewallPolicyRequest& request) const;
 
        template<typename AssociateFirewallPolicyRequestT = Model::AssociateFirewallPolicyRequest>
        Model::AssociateFirewallPolicyOutcomeCallable AssociateFirewallPolicyCallable(const AssociateFirewallPolicyRequestT& request) const
        {
            return SubmitCallable(&NetworkFirewallClient::AssociateFirewallPolicy, request);
        }
 
        template<typename AssociateFirewallPolicyRequestT = Model::AssociateFirewallPolicyRequest>
        void AssociateFirewallPolicyAsync(const AssociateFirewallPolicyRequestT& request, const AssociateFirewallPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkFirewallClient::AssociateFirewallPolicy, request, handler, context);
        }
 
        virtual Model::AssociateSubnetsOutcome AssociateSubnets(const Model::AssociateSubnetsRequest& request) const;
 
        template<typename AssociateSubnetsRequestT = Model::AssociateSubnetsRequest>
        Model::AssociateSubnetsOutcomeCallable AssociateSubnetsCallable(const AssociateSubnetsRequestT& request) const
        {
            return SubmitCallable(&NetworkFirewallClient::AssociateSubnets, request);
        }
 
        template<typename AssociateSubnetsRequestT = Model::AssociateSubnetsRequest>
        void AssociateSubnetsAsync(const AssociateSubnetsRequestT& request, const AssociateSubnetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkFirewallClient::AssociateSubnets, request, handler, context);
        }
 
        virtual Model::CreateFirewallOutcome CreateFirewall(const Model::CreateFirewallRequest& request) const;
 
        template<typename CreateFirewallRequestT = Model::CreateFirewallRequest>
        Model::CreateFirewallOutcomeCallable CreateFirewallCallable(const CreateFirewallRequestT& request) const
        {
            return SubmitCallable(&NetworkFirewallClient::CreateFirewall, request);
        }
 
        template<typename CreateFirewallRequestT = Model::CreateFirewallRequest>
        void CreateFirewallAsync(const CreateFirewallRequestT& request, const CreateFirewallResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkFirewallClient::CreateFirewall, request, handler, context);
        }
 
        virtual Model::CreateFirewallPolicyOutcome CreateFirewallPolicy(const Model::CreateFirewallPolicyRequest& request) const;
 
        template<typename CreateFirewallPolicyRequestT = Model::CreateFirewallPolicyRequest>
        Model::CreateFirewallPolicyOutcomeCallable CreateFirewallPolicyCallable(const CreateFirewallPolicyRequestT& request) const
        {
            return SubmitCallable(&NetworkFirewallClient::CreateFirewallPolicy, request);
        }
 
        template<typename CreateFirewallPolicyRequestT = Model::CreateFirewallPolicyRequest>
        void CreateFirewallPolicyAsync(const CreateFirewallPolicyRequestT& request, const CreateFirewallPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkFirewallClient::CreateFirewallPolicy, request, handler, context);
        }
 
        virtual Model::CreateRuleGroupOutcome CreateRuleGroup(const Model::CreateRuleGroupRequest& request) const;
 
        template<typename CreateRuleGroupRequestT = Model::CreateRuleGroupRequest>
        Model::CreateRuleGroupOutcomeCallable CreateRuleGroupCallable(const CreateRuleGroupRequestT& request) const
        {
            return SubmitCallable(&NetworkFirewallClient::CreateRuleGroup, request);
        }
 
        template<typename CreateRuleGroupRequestT = Model::CreateRuleGroupRequest>
        void CreateRuleGroupAsync(const CreateRuleGroupRequestT& request, const CreateRuleGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkFirewallClient::CreateRuleGroup, request, handler, context);
        }
 
        virtual Model::CreateTLSInspectionConfigurationOutcome CreateTLSInspectionConfiguration(const Model::CreateTLSInspectionConfigurationRequest& request) const;
 
        template<typename CreateTLSInspectionConfigurationRequestT = Model::CreateTLSInspectionConfigurationRequest>
        Model::CreateTLSInspectionConfigurationOutcomeCallable CreateTLSInspectionConfigurationCallable(const CreateTLSInspectionConfigurationRequestT& request) const
        {
            return SubmitCallable(&NetworkFirewallClient::CreateTLSInspectionConfiguration, request);
        }
 
        template<typename CreateTLSInspectionConfigurationRequestT = Model::CreateTLSInspectionConfigurationRequest>
        void CreateTLSInspectionConfigurationAsync(const CreateTLSInspectionConfigurationRequestT& request, const CreateTLSInspectionConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkFirewallClient::CreateTLSInspectionConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteFirewallOutcome DeleteFirewall(const Model::DeleteFirewallRequest& request = {}) const;
 
        template<typename DeleteFirewallRequestT = Model::DeleteFirewallRequest>
        Model::DeleteFirewallOutcomeCallable DeleteFirewallCallable(const DeleteFirewallRequestT& request = {}) const
        {
            return SubmitCallable(&NetworkFirewallClient::DeleteFirewall, request);
        }
 
        template<typename DeleteFirewallRequestT = Model::DeleteFirewallRequest>
        void DeleteFirewallAsync(const DeleteFirewallResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteFirewallRequestT& request = {}) const
        {
            return SubmitAsync(&NetworkFirewallClient::DeleteFirewall, request, handler, context);
        }
 
        virtual Model::DeleteFirewallPolicyOutcome DeleteFirewallPolicy(const Model::DeleteFirewallPolicyRequest& request = {}) const;
 
        template<typename DeleteFirewallPolicyRequestT = Model::DeleteFirewallPolicyRequest>
        Model::DeleteFirewallPolicyOutcomeCallable DeleteFirewallPolicyCallable(const DeleteFirewallPolicyRequestT& request = {}) const
        {
            return SubmitCallable(&NetworkFirewallClient::DeleteFirewallPolicy, request);
        }
 
        template<typename DeleteFirewallPolicyRequestT = Model::DeleteFirewallPolicyRequest>
        void DeleteFirewallPolicyAsync(const DeleteFirewallPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteFirewallPolicyRequestT& request = {}) const
        {
            return SubmitAsync(&NetworkFirewallClient::DeleteFirewallPolicy, request, handler, context);
        }
 
        virtual Model::DeleteResourcePolicyOutcome DeleteResourcePolicy(const Model::DeleteResourcePolicyRequest& request) const;
 
        template<typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
        Model::DeleteResourcePolicyOutcomeCallable DeleteResourcePolicyCallable(const DeleteResourcePolicyRequestT& request) const
        {
            return SubmitCallable(&NetworkFirewallClient::DeleteResourcePolicy, request);
        }
 
        template<typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
        void DeleteResourcePolicyAsync(const DeleteResourcePolicyRequestT& request, const DeleteResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkFirewallClient::DeleteResourcePolicy, request, handler, context);
        }
 
        virtual Model::DeleteRuleGroupOutcome DeleteRuleGroup(const Model::DeleteRuleGroupRequest& request = {}) const;
 
        template<typename DeleteRuleGroupRequestT = Model::DeleteRuleGroupRequest>
        Model::DeleteRuleGroupOutcomeCallable DeleteRuleGroupCallable(const DeleteRuleGroupRequestT& request = {}) const
        {
            return SubmitCallable(&NetworkFirewallClient::DeleteRuleGroup, request);
        }
 
        template<typename DeleteRuleGroupRequestT = Model::DeleteRuleGroupRequest>
        void DeleteRuleGroupAsync(const DeleteRuleGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteRuleGroupRequestT& request = {}) const
        {
            return SubmitAsync(&NetworkFirewallClient::DeleteRuleGroup, request, handler, context);
        }
 
        virtual Model::DeleteTLSInspectionConfigurationOutcome DeleteTLSInspectionConfiguration(const Model::DeleteTLSInspectionConfigurationRequest& request = {}) const;
 
        template<typename DeleteTLSInspectionConfigurationRequestT = Model::DeleteTLSInspectionConfigurationRequest>
        Model::DeleteTLSInspectionConfigurationOutcomeCallable DeleteTLSInspectionConfigurationCallable(const DeleteTLSInspectionConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&NetworkFirewallClient::DeleteTLSInspectionConfiguration, request);
        }
 
        template<typename DeleteTLSInspectionConfigurationRequestT = Model::DeleteTLSInspectionConfigurationRequest>
        void DeleteTLSInspectionConfigurationAsync(const DeleteTLSInspectionConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteTLSInspectionConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&NetworkFirewallClient::DeleteTLSInspectionConfiguration, request, handler, context);
        }
 
        virtual Model::DescribeFirewallOutcome DescribeFirewall(const Model::DescribeFirewallRequest& request = {}) const;
 
        template<typename DescribeFirewallRequestT = Model::DescribeFirewallRequest>
        Model::DescribeFirewallOutcomeCallable DescribeFirewallCallable(const DescribeFirewallRequestT& request = {}) const
        {
            return SubmitCallable(&NetworkFirewallClient::DescribeFirewall, request);
        }
 
        template<typename DescribeFirewallRequestT = Model::DescribeFirewallRequest>
        void DescribeFirewallAsync(const DescribeFirewallResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeFirewallRequestT& request = {}) const
        {
            return SubmitAsync(&NetworkFirewallClient::DescribeFirewall, request, handler, context);
        }
 
        virtual Model::DescribeFirewallPolicyOutcome DescribeFirewallPolicy(const Model::DescribeFirewallPolicyRequest& request = {}) const;
 
        template<typename DescribeFirewallPolicyRequestT = Model::DescribeFirewallPolicyRequest>
        Model::DescribeFirewallPolicyOutcomeCallable DescribeFirewallPolicyCallable(const DescribeFirewallPolicyRequestT& request = {}) const
        {
            return SubmitCallable(&NetworkFirewallClient::DescribeFirewallPolicy, request);
        }
 
        template<typename DescribeFirewallPolicyRequestT = Model::DescribeFirewallPolicyRequest>
        void DescribeFirewallPolicyAsync(const DescribeFirewallPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeFirewallPolicyRequestT& request = {}) const
        {
            return SubmitAsync(&NetworkFirewallClient::DescribeFirewallPolicy, request, handler, context);
        }
 
        virtual Model::DescribeLoggingConfigurationOutcome DescribeLoggingConfiguration(const Model::DescribeLoggingConfigurationRequest& request = {}) const;
 
        template<typename DescribeLoggingConfigurationRequestT = Model::DescribeLoggingConfigurationRequest>
        Model::DescribeLoggingConfigurationOutcomeCallable DescribeLoggingConfigurationCallable(const DescribeLoggingConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&NetworkFirewallClient::DescribeLoggingConfiguration, request);
        }
 
        template<typename DescribeLoggingConfigurationRequestT = Model::DescribeLoggingConfigurationRequest>
        void DescribeLoggingConfigurationAsync(const DescribeLoggingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeLoggingConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&NetworkFirewallClient::DescribeLoggingConfiguration, request, handler, context);
        }
 
        virtual Model::DescribeResourcePolicyOutcome DescribeResourcePolicy(const Model::DescribeResourcePolicyRequest& request) const;
 
        template<typename DescribeResourcePolicyRequestT = Model::DescribeResourcePolicyRequest>
        Model::DescribeResourcePolicyOutcomeCallable DescribeResourcePolicyCallable(const DescribeResourcePolicyRequestT& request) const
        {
            return SubmitCallable(&NetworkFirewallClient::DescribeResourcePolicy, request);
        }
 
        template<typename DescribeResourcePolicyRequestT = Model::DescribeResourcePolicyRequest>
        void DescribeResourcePolicyAsync(const DescribeResourcePolicyRequestT& request, const DescribeResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkFirewallClient::DescribeResourcePolicy, request, handler, context);
        }
 
        virtual Model::DescribeRuleGroupOutcome DescribeRuleGroup(const Model::DescribeRuleGroupRequest& request = {}) const;
 
        template<typename DescribeRuleGroupRequestT = Model::DescribeRuleGroupRequest>
        Model::DescribeRuleGroupOutcomeCallable DescribeRuleGroupCallable(const DescribeRuleGroupRequestT& request = {}) const
        {
            return SubmitCallable(&NetworkFirewallClient::DescribeRuleGroup, request);
        }
 
        template<typename DescribeRuleGroupRequestT = Model::DescribeRuleGroupRequest>
        void DescribeRuleGroupAsync(const DescribeRuleGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeRuleGroupRequestT& request = {}) const
        {
            return SubmitAsync(&NetworkFirewallClient::DescribeRuleGroup, request, handler, context);
        }
 
        virtual Model::DescribeRuleGroupMetadataOutcome DescribeRuleGroupMetadata(const Model::DescribeRuleGroupMetadataRequest& request = {}) const;
 
        template<typename DescribeRuleGroupMetadataRequestT = Model::DescribeRuleGroupMetadataRequest>
        Model::DescribeRuleGroupMetadataOutcomeCallable DescribeRuleGroupMetadataCallable(const DescribeRuleGroupMetadataRequestT& request = {}) const
        {
            return SubmitCallable(&NetworkFirewallClient::DescribeRuleGroupMetadata, request);
        }
 
        template<typename DescribeRuleGroupMetadataRequestT = Model::DescribeRuleGroupMetadataRequest>
        void DescribeRuleGroupMetadataAsync(const DescribeRuleGroupMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeRuleGroupMetadataRequestT& request = {}) const
        {
            return SubmitAsync(&NetworkFirewallClient::DescribeRuleGroupMetadata, request, handler, context);
        }
 
        virtual Model::DescribeTLSInspectionConfigurationOutcome DescribeTLSInspectionConfiguration(const Model::DescribeTLSInspectionConfigurationRequest& request = {}) const;
 
        template<typename DescribeTLSInspectionConfigurationRequestT = Model::DescribeTLSInspectionConfigurationRequest>
        Model::DescribeTLSInspectionConfigurationOutcomeCallable DescribeTLSInspectionConfigurationCallable(const DescribeTLSInspectionConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&NetworkFirewallClient::DescribeTLSInspectionConfiguration, request);
        }
 
        template<typename DescribeTLSInspectionConfigurationRequestT = Model::DescribeTLSInspectionConfigurationRequest>
        void DescribeTLSInspectionConfigurationAsync(const DescribeTLSInspectionConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeTLSInspectionConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&NetworkFirewallClient::DescribeTLSInspectionConfiguration, request, handler, context);
        }
 
        virtual Model::DisassociateSubnetsOutcome DisassociateSubnets(const Model::DisassociateSubnetsRequest& request) const;
 
        template<typename DisassociateSubnetsRequestT = Model::DisassociateSubnetsRequest>
        Model::DisassociateSubnetsOutcomeCallable DisassociateSubnetsCallable(const DisassociateSubnetsRequestT& request) const
        {
            return SubmitCallable(&NetworkFirewallClient::DisassociateSubnets, request);
        }
 
        template<typename DisassociateSubnetsRequestT = Model::DisassociateSubnetsRequest>
        void DisassociateSubnetsAsync(const DisassociateSubnetsRequestT& request, const DisassociateSubnetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkFirewallClient::DisassociateSubnets, request, handler, context);
        }
 
        virtual Model::ListFirewallPoliciesOutcome ListFirewallPolicies(const Model::ListFirewallPoliciesRequest& request = {}) const;
 
        template<typename ListFirewallPoliciesRequestT = Model::ListFirewallPoliciesRequest>
        Model::ListFirewallPoliciesOutcomeCallable ListFirewallPoliciesCallable(const ListFirewallPoliciesRequestT& request = {}) const
        {
            return SubmitCallable(&NetworkFirewallClient::ListFirewallPolicies, request);
        }
 
        template<typename ListFirewallPoliciesRequestT = Model::ListFirewallPoliciesRequest>
        void ListFirewallPoliciesAsync(const ListFirewallPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListFirewallPoliciesRequestT& request = {}) const
        {
            return SubmitAsync(&NetworkFirewallClient::ListFirewallPolicies, request, handler, context);
        }
 
        virtual Model::ListFirewallsOutcome ListFirewalls(const Model::ListFirewallsRequest& request = {}) const;
 
        template<typename ListFirewallsRequestT = Model::ListFirewallsRequest>
        Model::ListFirewallsOutcomeCallable ListFirewallsCallable(const ListFirewallsRequestT& request = {}) const
        {
            return SubmitCallable(&NetworkFirewallClient::ListFirewalls, request);
        }
 
        template<typename ListFirewallsRequestT = Model::ListFirewallsRequest>
        void ListFirewallsAsync(const ListFirewallsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListFirewallsRequestT& request = {}) const
        {
            return SubmitAsync(&NetworkFirewallClient::ListFirewalls, request, handler, context);
        }
 
        virtual Model::ListRuleGroupsOutcome ListRuleGroups(const Model::ListRuleGroupsRequest& request = {}) const;
 
        template<typename ListRuleGroupsRequestT = Model::ListRuleGroupsRequest>
        Model::ListRuleGroupsOutcomeCallable ListRuleGroupsCallable(const ListRuleGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&NetworkFirewallClient::ListRuleGroups, request);
        }
 
        template<typename ListRuleGroupsRequestT = Model::ListRuleGroupsRequest>
        void ListRuleGroupsAsync(const ListRuleGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListRuleGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&NetworkFirewallClient::ListRuleGroups, request, handler, context);
        }
 
        virtual Model::ListTLSInspectionConfigurationsOutcome ListTLSInspectionConfigurations(const Model::ListTLSInspectionConfigurationsRequest& request = {}) const;
 
        template<typename ListTLSInspectionConfigurationsRequestT = Model::ListTLSInspectionConfigurationsRequest>
        Model::ListTLSInspectionConfigurationsOutcomeCallable ListTLSInspectionConfigurationsCallable(const ListTLSInspectionConfigurationsRequestT& request = {}) const
        {
            return SubmitCallable(&NetworkFirewallClient::ListTLSInspectionConfigurations, request);
        }
 
        template<typename ListTLSInspectionConfigurationsRequestT = Model::ListTLSInspectionConfigurationsRequest>
        void ListTLSInspectionConfigurationsAsync(const ListTLSInspectionConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTLSInspectionConfigurationsRequestT& request = {}) const
        {
            return SubmitAsync(&NetworkFirewallClient::ListTLSInspectionConfigurations, 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(&NetworkFirewallClient::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(&NetworkFirewallClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::PutResourcePolicyOutcome PutResourcePolicy(const Model::PutResourcePolicyRequest& request) const;
 
        template<typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
        Model::PutResourcePolicyOutcomeCallable PutResourcePolicyCallable(const PutResourcePolicyRequestT& request) const
        {
            return SubmitCallable(&NetworkFirewallClient::PutResourcePolicy, request);
        }
 
        template<typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
        void PutResourcePolicyAsync(const PutResourcePolicyRequestT& request, const PutResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkFirewallClient::PutResourcePolicy, 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(&NetworkFirewallClient::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(&NetworkFirewallClient::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(&NetworkFirewallClient::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(&NetworkFirewallClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateFirewallDeleteProtectionOutcome UpdateFirewallDeleteProtection(const Model::UpdateFirewallDeleteProtectionRequest& request) const;
 
        template<typename UpdateFirewallDeleteProtectionRequestT = Model::UpdateFirewallDeleteProtectionRequest>
        Model::UpdateFirewallDeleteProtectionOutcomeCallable UpdateFirewallDeleteProtectionCallable(const UpdateFirewallDeleteProtectionRequestT& request) const
        {
            return SubmitCallable(&NetworkFirewallClient::UpdateFirewallDeleteProtection, request);
        }
 
        template<typename UpdateFirewallDeleteProtectionRequestT = Model::UpdateFirewallDeleteProtectionRequest>
        void UpdateFirewallDeleteProtectionAsync(const UpdateFirewallDeleteProtectionRequestT& request, const UpdateFirewallDeleteProtectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkFirewallClient::UpdateFirewallDeleteProtection, request, handler, context);
        }
 
        virtual Model::UpdateFirewallDescriptionOutcome UpdateFirewallDescription(const Model::UpdateFirewallDescriptionRequest& request = {}) const;
 
        template<typename UpdateFirewallDescriptionRequestT = Model::UpdateFirewallDescriptionRequest>
        Model::UpdateFirewallDescriptionOutcomeCallable UpdateFirewallDescriptionCallable(const UpdateFirewallDescriptionRequestT& request = {}) const
        {
            return SubmitCallable(&NetworkFirewallClient::UpdateFirewallDescription, request);
        }
 
        template<typename UpdateFirewallDescriptionRequestT = Model::UpdateFirewallDescriptionRequest>
        void UpdateFirewallDescriptionAsync(const UpdateFirewallDescriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateFirewallDescriptionRequestT& request = {}) const
        {
            return SubmitAsync(&NetworkFirewallClient::UpdateFirewallDescription, request, handler, context);
        }
 
        virtual Model::UpdateFirewallEncryptionConfigurationOutcome UpdateFirewallEncryptionConfiguration(const Model::UpdateFirewallEncryptionConfigurationRequest& request = {}) const;
 
        template<typename UpdateFirewallEncryptionConfigurationRequestT = Model::UpdateFirewallEncryptionConfigurationRequest>
        Model::UpdateFirewallEncryptionConfigurationOutcomeCallable UpdateFirewallEncryptionConfigurationCallable(const UpdateFirewallEncryptionConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&NetworkFirewallClient::UpdateFirewallEncryptionConfiguration, request);
        }
 
        template<typename UpdateFirewallEncryptionConfigurationRequestT = Model::UpdateFirewallEncryptionConfigurationRequest>
        void UpdateFirewallEncryptionConfigurationAsync(const UpdateFirewallEncryptionConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateFirewallEncryptionConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&NetworkFirewallClient::UpdateFirewallEncryptionConfiguration, request, handler, context);
        }
 
        virtual Model::UpdateFirewallPolicyOutcome UpdateFirewallPolicy(const Model::UpdateFirewallPolicyRequest& request) const;
 
        template<typename UpdateFirewallPolicyRequestT = Model::UpdateFirewallPolicyRequest>
        Model::UpdateFirewallPolicyOutcomeCallable UpdateFirewallPolicyCallable(const UpdateFirewallPolicyRequestT& request) const
        {
            return SubmitCallable(&NetworkFirewallClient::UpdateFirewallPolicy, request);
        }
 
        template<typename UpdateFirewallPolicyRequestT = Model::UpdateFirewallPolicyRequest>
        void UpdateFirewallPolicyAsync(const UpdateFirewallPolicyRequestT& request, const UpdateFirewallPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkFirewallClient::UpdateFirewallPolicy, request, handler, context);
        }
 
        virtual Model::UpdateFirewallPolicyChangeProtectionOutcome UpdateFirewallPolicyChangeProtection(const Model::UpdateFirewallPolicyChangeProtectionRequest& request) const;
 
        template<typename UpdateFirewallPolicyChangeProtectionRequestT = Model::UpdateFirewallPolicyChangeProtectionRequest>
        Model::UpdateFirewallPolicyChangeProtectionOutcomeCallable UpdateFirewallPolicyChangeProtectionCallable(const UpdateFirewallPolicyChangeProtectionRequestT& request) const
        {
            return SubmitCallable(&NetworkFirewallClient::UpdateFirewallPolicyChangeProtection, request);
        }
 
        template<typename UpdateFirewallPolicyChangeProtectionRequestT = Model::UpdateFirewallPolicyChangeProtectionRequest>
        void UpdateFirewallPolicyChangeProtectionAsync(const UpdateFirewallPolicyChangeProtectionRequestT& request, const UpdateFirewallPolicyChangeProtectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkFirewallClient::UpdateFirewallPolicyChangeProtection, request, handler, context);
        }
 
        virtual Model::UpdateLoggingConfigurationOutcome UpdateLoggingConfiguration(const Model::UpdateLoggingConfigurationRequest& request = {}) const;
 
        template<typename UpdateLoggingConfigurationRequestT = Model::UpdateLoggingConfigurationRequest>
        Model::UpdateLoggingConfigurationOutcomeCallable UpdateLoggingConfigurationCallable(const UpdateLoggingConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&NetworkFirewallClient::UpdateLoggingConfiguration, request);
        }
 
        template<typename UpdateLoggingConfigurationRequestT = Model::UpdateLoggingConfigurationRequest>
        void UpdateLoggingConfigurationAsync(const UpdateLoggingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateLoggingConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&NetworkFirewallClient::UpdateLoggingConfiguration, request, handler, context);
        }
 
        virtual Model::UpdateRuleGroupOutcome UpdateRuleGroup(const Model::UpdateRuleGroupRequest& request) const;
 
        template<typename UpdateRuleGroupRequestT = Model::UpdateRuleGroupRequest>
        Model::UpdateRuleGroupOutcomeCallable UpdateRuleGroupCallable(const UpdateRuleGroupRequestT& request) const
        {
            return SubmitCallable(&NetworkFirewallClient::UpdateRuleGroup, request);
        }
 
        template<typename UpdateRuleGroupRequestT = Model::UpdateRuleGroupRequest>
        void UpdateRuleGroupAsync(const UpdateRuleGroupRequestT& request, const UpdateRuleGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkFirewallClient::UpdateRuleGroup, request, handler, context);
        }
 
        virtual Model::UpdateSubnetChangeProtectionOutcome UpdateSubnetChangeProtection(const Model::UpdateSubnetChangeProtectionRequest& request) const;
 
        template<typename UpdateSubnetChangeProtectionRequestT = Model::UpdateSubnetChangeProtectionRequest>
        Model::UpdateSubnetChangeProtectionOutcomeCallable UpdateSubnetChangeProtectionCallable(const UpdateSubnetChangeProtectionRequestT& request) const
        {
            return SubmitCallable(&NetworkFirewallClient::UpdateSubnetChangeProtection, request);
        }
 
        template<typename UpdateSubnetChangeProtectionRequestT = Model::UpdateSubnetChangeProtectionRequest>
        void UpdateSubnetChangeProtectionAsync(const UpdateSubnetChangeProtectionRequestT& request, const UpdateSubnetChangeProtectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkFirewallClient::UpdateSubnetChangeProtection, request, handler, context);
        }
 
        virtual Model::UpdateTLSInspectionConfigurationOutcome UpdateTLSInspectionConfiguration(const Model::UpdateTLSInspectionConfigurationRequest& request) const;
 
        template<typename UpdateTLSInspectionConfigurationRequestT = Model::UpdateTLSInspectionConfigurationRequest>
        Model::UpdateTLSInspectionConfigurationOutcomeCallable UpdateTLSInspectionConfigurationCallable(const UpdateTLSInspectionConfigurationRequestT& request) const
        {
            return SubmitCallable(&NetworkFirewallClient::UpdateTLSInspectionConfiguration, request);
        }
 
        template<typename UpdateTLSInspectionConfigurationRequestT = Model::UpdateTLSInspectionConfigurationRequest>
        void UpdateTLSInspectionConfigurationAsync(const UpdateTLSInspectionConfigurationRequestT& request, const UpdateTLSInspectionConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&NetworkFirewallClient::UpdateTLSInspectionConfiguration, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<NetworkFirewallEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<NetworkFirewallClient>;
      void init(const NetworkFirewallClientConfiguration& clientConfiguration);
 
      NetworkFirewallClientConfiguration m_clientConfiguration;
      std::shared_ptr<NetworkFirewallEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace NetworkFirewall
} // namespace Aws