ShieldClient.h

 
#pragma once
#include <aws/shield/Shield_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/shield/ShieldServiceClientModel.h>
 
namespace Aws
{
namespace Shield
{
  class AWS_SHIELD_API ShieldClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<ShieldClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef ShieldClientConfiguration ClientConfigurationType;
      typedef ShieldEndpointProvider EndpointProviderType;
 
        ShieldClient(const Aws::Shield::ShieldClientConfiguration& clientConfiguration = Aws::Shield::ShieldClientConfiguration(),
                     std::shared_ptr<ShieldEndpointProviderBase> endpointProvider = nullptr);
 
        ShieldClient(const Aws::Auth::AWSCredentials& credentials,
                     std::shared_ptr<ShieldEndpointProviderBase> endpointProvider = nullptr,
                     const Aws::Shield::ShieldClientConfiguration& clientConfiguration = Aws::Shield::ShieldClientConfiguration());
 
        ShieldClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     std::shared_ptr<ShieldEndpointProviderBase> endpointProvider = nullptr,
                     const Aws::Shield::ShieldClientConfiguration& clientConfiguration = Aws::Shield::ShieldClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        ShieldClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ShieldClient(const Aws::Auth::AWSCredentials& credentials,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ShieldClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~ShieldClient();
 
        virtual Model::AssociateDRTLogBucketOutcome AssociateDRTLogBucket(const Model::AssociateDRTLogBucketRequest& request) const;
 
        template<typename AssociateDRTLogBucketRequestT = Model::AssociateDRTLogBucketRequest>
        Model::AssociateDRTLogBucketOutcomeCallable AssociateDRTLogBucketCallable(const AssociateDRTLogBucketRequestT& request) const
        {
            return SubmitCallable(&ShieldClient::AssociateDRTLogBucket, request);
        }
 
        template<typename AssociateDRTLogBucketRequestT = Model::AssociateDRTLogBucketRequest>
        void AssociateDRTLogBucketAsync(const AssociateDRTLogBucketRequestT& request, const AssociateDRTLogBucketResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ShieldClient::AssociateDRTLogBucket, request, handler, context);
        }
 
        virtual Model::AssociateDRTRoleOutcome AssociateDRTRole(const Model::AssociateDRTRoleRequest& request) const;
 
        template<typename AssociateDRTRoleRequestT = Model::AssociateDRTRoleRequest>
        Model::AssociateDRTRoleOutcomeCallable AssociateDRTRoleCallable(const AssociateDRTRoleRequestT& request) const
        {
            return SubmitCallable(&ShieldClient::AssociateDRTRole, request);
        }
 
        template<typename AssociateDRTRoleRequestT = Model::AssociateDRTRoleRequest>
        void AssociateDRTRoleAsync(const AssociateDRTRoleRequestT& request, const AssociateDRTRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ShieldClient::AssociateDRTRole, request, handler, context);
        }
 
        virtual Model::AssociateHealthCheckOutcome AssociateHealthCheck(const Model::AssociateHealthCheckRequest& request) const;
 
        template<typename AssociateHealthCheckRequestT = Model::AssociateHealthCheckRequest>
        Model::AssociateHealthCheckOutcomeCallable AssociateHealthCheckCallable(const AssociateHealthCheckRequestT& request) const
        {
            return SubmitCallable(&ShieldClient::AssociateHealthCheck, request);
        }
 
        template<typename AssociateHealthCheckRequestT = Model::AssociateHealthCheckRequest>
        void AssociateHealthCheckAsync(const AssociateHealthCheckRequestT& request, const AssociateHealthCheckResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ShieldClient::AssociateHealthCheck, request, handler, context);
        }
 
        virtual Model::AssociateProactiveEngagementDetailsOutcome AssociateProactiveEngagementDetails(const Model::AssociateProactiveEngagementDetailsRequest& request) const;
 
        template<typename AssociateProactiveEngagementDetailsRequestT = Model::AssociateProactiveEngagementDetailsRequest>
        Model::AssociateProactiveEngagementDetailsOutcomeCallable AssociateProactiveEngagementDetailsCallable(const AssociateProactiveEngagementDetailsRequestT& request) const
        {
            return SubmitCallable(&ShieldClient::AssociateProactiveEngagementDetails, request);
        }
 
        template<typename AssociateProactiveEngagementDetailsRequestT = Model::AssociateProactiveEngagementDetailsRequest>
        void AssociateProactiveEngagementDetailsAsync(const AssociateProactiveEngagementDetailsRequestT& request, const AssociateProactiveEngagementDetailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ShieldClient::AssociateProactiveEngagementDetails, request, handler, context);
        }
 
        virtual Model::CreateProtectionOutcome CreateProtection(const Model::CreateProtectionRequest& request) const;
 
        template<typename CreateProtectionRequestT = Model::CreateProtectionRequest>
        Model::CreateProtectionOutcomeCallable CreateProtectionCallable(const CreateProtectionRequestT& request) const
        {
            return SubmitCallable(&ShieldClient::CreateProtection, request);
        }
 
        template<typename CreateProtectionRequestT = Model::CreateProtectionRequest>
        void CreateProtectionAsync(const CreateProtectionRequestT& request, const CreateProtectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ShieldClient::CreateProtection, request, handler, context);
        }
 
        virtual Model::CreateProtectionGroupOutcome CreateProtectionGroup(const Model::CreateProtectionGroupRequest& request) const;
 
        template<typename CreateProtectionGroupRequestT = Model::CreateProtectionGroupRequest>
        Model::CreateProtectionGroupOutcomeCallable CreateProtectionGroupCallable(const CreateProtectionGroupRequestT& request) const
        {
            return SubmitCallable(&ShieldClient::CreateProtectionGroup, request);
        }
 
        template<typename CreateProtectionGroupRequestT = Model::CreateProtectionGroupRequest>
        void CreateProtectionGroupAsync(const CreateProtectionGroupRequestT& request, const CreateProtectionGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ShieldClient::CreateProtectionGroup, request, handler, context);
        }
 
        virtual Model::CreateSubscriptionOutcome CreateSubscription(const Model::CreateSubscriptionRequest& request = {}) const;
 
        template<typename CreateSubscriptionRequestT = Model::CreateSubscriptionRequest>
        Model::CreateSubscriptionOutcomeCallable CreateSubscriptionCallable(const CreateSubscriptionRequestT& request = {}) const
        {
            return SubmitCallable(&ShieldClient::CreateSubscription, request);
        }
 
        template<typename CreateSubscriptionRequestT = Model::CreateSubscriptionRequest>
        void CreateSubscriptionAsync(const CreateSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateSubscriptionRequestT& request = {}) const
        {
            return SubmitAsync(&ShieldClient::CreateSubscription, request, handler, context);
        }
 
        virtual Model::DeleteProtectionOutcome DeleteProtection(const Model::DeleteProtectionRequest& request) const;
 
        template<typename DeleteProtectionRequestT = Model::DeleteProtectionRequest>
        Model::DeleteProtectionOutcomeCallable DeleteProtectionCallable(const DeleteProtectionRequestT& request) const
        {
            return SubmitCallable(&ShieldClient::DeleteProtection, request);
        }
 
        template<typename DeleteProtectionRequestT = Model::DeleteProtectionRequest>
        void DeleteProtectionAsync(const DeleteProtectionRequestT& request, const DeleteProtectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ShieldClient::DeleteProtection, request, handler, context);
        }
 
        virtual Model::DeleteProtectionGroupOutcome DeleteProtectionGroup(const Model::DeleteProtectionGroupRequest& request) const;
 
        template<typename DeleteProtectionGroupRequestT = Model::DeleteProtectionGroupRequest>
        Model::DeleteProtectionGroupOutcomeCallable DeleteProtectionGroupCallable(const DeleteProtectionGroupRequestT& request) const
        {
            return SubmitCallable(&ShieldClient::DeleteProtectionGroup, request);
        }
 
        template<typename DeleteProtectionGroupRequestT = Model::DeleteProtectionGroupRequest>
        void DeleteProtectionGroupAsync(const DeleteProtectionGroupRequestT& request, const DeleteProtectionGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ShieldClient::DeleteProtectionGroup, request, handler, context);
        }
 
        virtual Model::DescribeAttackOutcome DescribeAttack(const Model::DescribeAttackRequest& request) const;
 
        template<typename DescribeAttackRequestT = Model::DescribeAttackRequest>
        Model::DescribeAttackOutcomeCallable DescribeAttackCallable(const DescribeAttackRequestT& request) const
        {
            return SubmitCallable(&ShieldClient::DescribeAttack, request);
        }
 
        template<typename DescribeAttackRequestT = Model::DescribeAttackRequest>
        void DescribeAttackAsync(const DescribeAttackRequestT& request, const DescribeAttackResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ShieldClient::DescribeAttack, request, handler, context);
        }
 
        virtual Model::DescribeAttackStatisticsOutcome DescribeAttackStatistics(const Model::DescribeAttackStatisticsRequest& request = {}) const;
 
        template<typename DescribeAttackStatisticsRequestT = Model::DescribeAttackStatisticsRequest>
        Model::DescribeAttackStatisticsOutcomeCallable DescribeAttackStatisticsCallable(const DescribeAttackStatisticsRequestT& request = {}) const
        {
            return SubmitCallable(&ShieldClient::DescribeAttackStatistics, request);
        }
 
        template<typename DescribeAttackStatisticsRequestT = Model::DescribeAttackStatisticsRequest>
        void DescribeAttackStatisticsAsync(const DescribeAttackStatisticsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeAttackStatisticsRequestT& request = {}) const
        {
            return SubmitAsync(&ShieldClient::DescribeAttackStatistics, request, handler, context);
        }
 
        virtual Model::DescribeDRTAccessOutcome DescribeDRTAccess(const Model::DescribeDRTAccessRequest& request = {}) const;
 
        template<typename DescribeDRTAccessRequestT = Model::DescribeDRTAccessRequest>
        Model::DescribeDRTAccessOutcomeCallable DescribeDRTAccessCallable(const DescribeDRTAccessRequestT& request = {}) const
        {
            return SubmitCallable(&ShieldClient::DescribeDRTAccess, request);
        }
 
        template<typename DescribeDRTAccessRequestT = Model::DescribeDRTAccessRequest>
        void DescribeDRTAccessAsync(const DescribeDRTAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeDRTAccessRequestT& request = {}) const
        {
            return SubmitAsync(&ShieldClient::DescribeDRTAccess, request, handler, context);
        }
 
        virtual Model::DescribeEmergencyContactSettingsOutcome DescribeEmergencyContactSettings(const Model::DescribeEmergencyContactSettingsRequest& request = {}) const;
 
        template<typename DescribeEmergencyContactSettingsRequestT = Model::DescribeEmergencyContactSettingsRequest>
        Model::DescribeEmergencyContactSettingsOutcomeCallable DescribeEmergencyContactSettingsCallable(const DescribeEmergencyContactSettingsRequestT& request = {}) const
        {
            return SubmitCallable(&ShieldClient::DescribeEmergencyContactSettings, request);
        }
 
        template<typename DescribeEmergencyContactSettingsRequestT = Model::DescribeEmergencyContactSettingsRequest>
        void DescribeEmergencyContactSettingsAsync(const DescribeEmergencyContactSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeEmergencyContactSettingsRequestT& request = {}) const
        {
            return SubmitAsync(&ShieldClient::DescribeEmergencyContactSettings, request, handler, context);
        }
 
        virtual Model::DescribeProtectionOutcome DescribeProtection(const Model::DescribeProtectionRequest& request = {}) const;
 
        template<typename DescribeProtectionRequestT = Model::DescribeProtectionRequest>
        Model::DescribeProtectionOutcomeCallable DescribeProtectionCallable(const DescribeProtectionRequestT& request = {}) const
        {
            return SubmitCallable(&ShieldClient::DescribeProtection, request);
        }
 
        template<typename DescribeProtectionRequestT = Model::DescribeProtectionRequest>
        void DescribeProtectionAsync(const DescribeProtectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeProtectionRequestT& request = {}) const
        {
            return SubmitAsync(&ShieldClient::DescribeProtection, request, handler, context);
        }
 
        virtual Model::DescribeProtectionGroupOutcome DescribeProtectionGroup(const Model::DescribeProtectionGroupRequest& request) const;
 
        template<typename DescribeProtectionGroupRequestT = Model::DescribeProtectionGroupRequest>
        Model::DescribeProtectionGroupOutcomeCallable DescribeProtectionGroupCallable(const DescribeProtectionGroupRequestT& request) const
        {
            return SubmitCallable(&ShieldClient::DescribeProtectionGroup, request);
        }
 
        template<typename DescribeProtectionGroupRequestT = Model::DescribeProtectionGroupRequest>
        void DescribeProtectionGroupAsync(const DescribeProtectionGroupRequestT& request, const DescribeProtectionGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ShieldClient::DescribeProtectionGroup, request, handler, context);
        }
 
        virtual Model::DescribeSubscriptionOutcome DescribeSubscription(const Model::DescribeSubscriptionRequest& request = {}) const;
 
        template<typename DescribeSubscriptionRequestT = Model::DescribeSubscriptionRequest>
        Model::DescribeSubscriptionOutcomeCallable DescribeSubscriptionCallable(const DescribeSubscriptionRequestT& request = {}) const
        {
            return SubmitCallable(&ShieldClient::DescribeSubscription, request);
        }
 
        template<typename DescribeSubscriptionRequestT = Model::DescribeSubscriptionRequest>
        void DescribeSubscriptionAsync(const DescribeSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeSubscriptionRequestT& request = {}) const
        {
            return SubmitAsync(&ShieldClient::DescribeSubscription, request, handler, context);
        }
 
        virtual Model::DisableApplicationLayerAutomaticResponseOutcome DisableApplicationLayerAutomaticResponse(const Model::DisableApplicationLayerAutomaticResponseRequest& request) const;
 
        template<typename DisableApplicationLayerAutomaticResponseRequestT = Model::DisableApplicationLayerAutomaticResponseRequest>
        Model::DisableApplicationLayerAutomaticResponseOutcomeCallable DisableApplicationLayerAutomaticResponseCallable(const DisableApplicationLayerAutomaticResponseRequestT& request) const
        {
            return SubmitCallable(&ShieldClient::DisableApplicationLayerAutomaticResponse, request);
        }
 
        template<typename DisableApplicationLayerAutomaticResponseRequestT = Model::DisableApplicationLayerAutomaticResponseRequest>
        void DisableApplicationLayerAutomaticResponseAsync(const DisableApplicationLayerAutomaticResponseRequestT& request, const DisableApplicationLayerAutomaticResponseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ShieldClient::DisableApplicationLayerAutomaticResponse, request, handler, context);
        }
 
        virtual Model::DisableProactiveEngagementOutcome DisableProactiveEngagement(const Model::DisableProactiveEngagementRequest& request = {}) const;
 
        template<typename DisableProactiveEngagementRequestT = Model::DisableProactiveEngagementRequest>
        Model::DisableProactiveEngagementOutcomeCallable DisableProactiveEngagementCallable(const DisableProactiveEngagementRequestT& request = {}) const
        {
            return SubmitCallable(&ShieldClient::DisableProactiveEngagement, request);
        }
 
        template<typename DisableProactiveEngagementRequestT = Model::DisableProactiveEngagementRequest>
        void DisableProactiveEngagementAsync(const DisableProactiveEngagementResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DisableProactiveEngagementRequestT& request = {}) const
        {
            return SubmitAsync(&ShieldClient::DisableProactiveEngagement, request, handler, context);
        }
 
        virtual Model::DisassociateDRTLogBucketOutcome DisassociateDRTLogBucket(const Model::DisassociateDRTLogBucketRequest& request) const;
 
        template<typename DisassociateDRTLogBucketRequestT = Model::DisassociateDRTLogBucketRequest>
        Model::DisassociateDRTLogBucketOutcomeCallable DisassociateDRTLogBucketCallable(const DisassociateDRTLogBucketRequestT& request) const
        {
            return SubmitCallable(&ShieldClient::DisassociateDRTLogBucket, request);
        }
 
        template<typename DisassociateDRTLogBucketRequestT = Model::DisassociateDRTLogBucketRequest>
        void DisassociateDRTLogBucketAsync(const DisassociateDRTLogBucketRequestT& request, const DisassociateDRTLogBucketResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ShieldClient::DisassociateDRTLogBucket, request, handler, context);
        }
 
        virtual Model::DisassociateDRTRoleOutcome DisassociateDRTRole(const Model::DisassociateDRTRoleRequest& request = {}) const;
 
        template<typename DisassociateDRTRoleRequestT = Model::DisassociateDRTRoleRequest>
        Model::DisassociateDRTRoleOutcomeCallable DisassociateDRTRoleCallable(const DisassociateDRTRoleRequestT& request = {}) const
        {
            return SubmitCallable(&ShieldClient::DisassociateDRTRole, request);
        }
 
        template<typename DisassociateDRTRoleRequestT = Model::DisassociateDRTRoleRequest>
        void DisassociateDRTRoleAsync(const DisassociateDRTRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DisassociateDRTRoleRequestT& request = {}) const
        {
            return SubmitAsync(&ShieldClient::DisassociateDRTRole, request, handler, context);
        }
 
        virtual Model::DisassociateHealthCheckOutcome DisassociateHealthCheck(const Model::DisassociateHealthCheckRequest& request) const;
 
        template<typename DisassociateHealthCheckRequestT = Model::DisassociateHealthCheckRequest>
        Model::DisassociateHealthCheckOutcomeCallable DisassociateHealthCheckCallable(const DisassociateHealthCheckRequestT& request) const
        {
            return SubmitCallable(&ShieldClient::DisassociateHealthCheck, request);
        }
 
        template<typename DisassociateHealthCheckRequestT = Model::DisassociateHealthCheckRequest>
        void DisassociateHealthCheckAsync(const DisassociateHealthCheckRequestT& request, const DisassociateHealthCheckResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ShieldClient::DisassociateHealthCheck, request, handler, context);
        }
 
        virtual Model::EnableApplicationLayerAutomaticResponseOutcome EnableApplicationLayerAutomaticResponse(const Model::EnableApplicationLayerAutomaticResponseRequest& request) const;
 
        template<typename EnableApplicationLayerAutomaticResponseRequestT = Model::EnableApplicationLayerAutomaticResponseRequest>
        Model::EnableApplicationLayerAutomaticResponseOutcomeCallable EnableApplicationLayerAutomaticResponseCallable(const EnableApplicationLayerAutomaticResponseRequestT& request) const
        {
            return SubmitCallable(&ShieldClient::EnableApplicationLayerAutomaticResponse, request);
        }
 
        template<typename EnableApplicationLayerAutomaticResponseRequestT = Model::EnableApplicationLayerAutomaticResponseRequest>
        void EnableApplicationLayerAutomaticResponseAsync(const EnableApplicationLayerAutomaticResponseRequestT& request, const EnableApplicationLayerAutomaticResponseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ShieldClient::EnableApplicationLayerAutomaticResponse, request, handler, context);
        }
 
        virtual Model::EnableProactiveEngagementOutcome EnableProactiveEngagement(const Model::EnableProactiveEngagementRequest& request = {}) const;
 
        template<typename EnableProactiveEngagementRequestT = Model::EnableProactiveEngagementRequest>
        Model::EnableProactiveEngagementOutcomeCallable EnableProactiveEngagementCallable(const EnableProactiveEngagementRequestT& request = {}) const
        {
            return SubmitCallable(&ShieldClient::EnableProactiveEngagement, request);
        }
 
        template<typename EnableProactiveEngagementRequestT = Model::EnableProactiveEngagementRequest>
        void EnableProactiveEngagementAsync(const EnableProactiveEngagementResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const EnableProactiveEngagementRequestT& request = {}) const
        {
            return SubmitAsync(&ShieldClient::EnableProactiveEngagement, request, handler, context);
        }
 
        virtual Model::GetSubscriptionStateOutcome GetSubscriptionState(const Model::GetSubscriptionStateRequest& request = {}) const;
 
        template<typename GetSubscriptionStateRequestT = Model::GetSubscriptionStateRequest>
        Model::GetSubscriptionStateOutcomeCallable GetSubscriptionStateCallable(const GetSubscriptionStateRequestT& request = {}) const
        {
            return SubmitCallable(&ShieldClient::GetSubscriptionState, request);
        }
 
        template<typename GetSubscriptionStateRequestT = Model::GetSubscriptionStateRequest>
        void GetSubscriptionStateAsync(const GetSubscriptionStateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetSubscriptionStateRequestT& request = {}) const
        {
            return SubmitAsync(&ShieldClient::GetSubscriptionState, request, handler, context);
        }
 
        virtual Model::ListAttacksOutcome ListAttacks(const Model::ListAttacksRequest& request = {}) const;
 
        template<typename ListAttacksRequestT = Model::ListAttacksRequest>
        Model::ListAttacksOutcomeCallable ListAttacksCallable(const ListAttacksRequestT& request = {}) const
        {
            return SubmitCallable(&ShieldClient::ListAttacks, request);
        }
 
        template<typename ListAttacksRequestT = Model::ListAttacksRequest>
        void ListAttacksAsync(const ListAttacksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAttacksRequestT& request = {}) const
        {
            return SubmitAsync(&ShieldClient::ListAttacks, request, handler, context);
        }
 
        virtual Model::ListProtectionGroupsOutcome ListProtectionGroups(const Model::ListProtectionGroupsRequest& request = {}) const;
 
        template<typename ListProtectionGroupsRequestT = Model::ListProtectionGroupsRequest>
        Model::ListProtectionGroupsOutcomeCallable ListProtectionGroupsCallable(const ListProtectionGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&ShieldClient::ListProtectionGroups, request);
        }
 
        template<typename ListProtectionGroupsRequestT = Model::ListProtectionGroupsRequest>
        void ListProtectionGroupsAsync(const ListProtectionGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListProtectionGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&ShieldClient::ListProtectionGroups, request, handler, context);
        }
 
        virtual Model::ListProtectionsOutcome ListProtections(const Model::ListProtectionsRequest& request = {}) const;
 
        template<typename ListProtectionsRequestT = Model::ListProtectionsRequest>
        Model::ListProtectionsOutcomeCallable ListProtectionsCallable(const ListProtectionsRequestT& request = {}) const
        {
            return SubmitCallable(&ShieldClient::ListProtections, request);
        }
 
        template<typename ListProtectionsRequestT = Model::ListProtectionsRequest>
        void ListProtectionsAsync(const ListProtectionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListProtectionsRequestT& request = {}) const
        {
            return SubmitAsync(&ShieldClient::ListProtections, request, handler, context);
        }
 
        virtual Model::ListResourcesInProtectionGroupOutcome ListResourcesInProtectionGroup(const Model::ListResourcesInProtectionGroupRequest& request) const;
 
        template<typename ListResourcesInProtectionGroupRequestT = Model::ListResourcesInProtectionGroupRequest>
        Model::ListResourcesInProtectionGroupOutcomeCallable ListResourcesInProtectionGroupCallable(const ListResourcesInProtectionGroupRequestT& request) const
        {
            return SubmitCallable(&ShieldClient::ListResourcesInProtectionGroup, request);
        }
 
        template<typename ListResourcesInProtectionGroupRequestT = Model::ListResourcesInProtectionGroupRequest>
        void ListResourcesInProtectionGroupAsync(const ListResourcesInProtectionGroupRequestT& request, const ListResourcesInProtectionGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ShieldClient::ListResourcesInProtectionGroup, 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(&ShieldClient::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(&ShieldClient::ListTagsForResource, 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(&ShieldClient::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(&ShieldClient::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(&ShieldClient::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(&ShieldClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateApplicationLayerAutomaticResponseOutcome UpdateApplicationLayerAutomaticResponse(const Model::UpdateApplicationLayerAutomaticResponseRequest& request) const;
 
        template<typename UpdateApplicationLayerAutomaticResponseRequestT = Model::UpdateApplicationLayerAutomaticResponseRequest>
        Model::UpdateApplicationLayerAutomaticResponseOutcomeCallable UpdateApplicationLayerAutomaticResponseCallable(const UpdateApplicationLayerAutomaticResponseRequestT& request) const
        {
            return SubmitCallable(&ShieldClient::UpdateApplicationLayerAutomaticResponse, request);
        }
 
        template<typename UpdateApplicationLayerAutomaticResponseRequestT = Model::UpdateApplicationLayerAutomaticResponseRequest>
        void UpdateApplicationLayerAutomaticResponseAsync(const UpdateApplicationLayerAutomaticResponseRequestT& request, const UpdateApplicationLayerAutomaticResponseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ShieldClient::UpdateApplicationLayerAutomaticResponse, request, handler, context);
        }
 
        virtual Model::UpdateEmergencyContactSettingsOutcome UpdateEmergencyContactSettings(const Model::UpdateEmergencyContactSettingsRequest& request = {}) const;
 
        template<typename UpdateEmergencyContactSettingsRequestT = Model::UpdateEmergencyContactSettingsRequest>
        Model::UpdateEmergencyContactSettingsOutcomeCallable UpdateEmergencyContactSettingsCallable(const UpdateEmergencyContactSettingsRequestT& request = {}) const
        {
            return SubmitCallable(&ShieldClient::UpdateEmergencyContactSettings, request);
        }
 
        template<typename UpdateEmergencyContactSettingsRequestT = Model::UpdateEmergencyContactSettingsRequest>
        void UpdateEmergencyContactSettingsAsync(const UpdateEmergencyContactSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateEmergencyContactSettingsRequestT& request = {}) const
        {
            return SubmitAsync(&ShieldClient::UpdateEmergencyContactSettings, request, handler, context);
        }
 
        virtual Model::UpdateProtectionGroupOutcome UpdateProtectionGroup(const Model::UpdateProtectionGroupRequest& request) const;
 
        template<typename UpdateProtectionGroupRequestT = Model::UpdateProtectionGroupRequest>
        Model::UpdateProtectionGroupOutcomeCallable UpdateProtectionGroupCallable(const UpdateProtectionGroupRequestT& request) const
        {
            return SubmitCallable(&ShieldClient::UpdateProtectionGroup, request);
        }
 
        template<typename UpdateProtectionGroupRequestT = Model::UpdateProtectionGroupRequest>
        void UpdateProtectionGroupAsync(const UpdateProtectionGroupRequestT& request, const UpdateProtectionGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ShieldClient::UpdateProtectionGroup, request, handler, context);
        }
 
        virtual Model::UpdateSubscriptionOutcome UpdateSubscription(const Model::UpdateSubscriptionRequest& request = {}) const;
 
        template<typename UpdateSubscriptionRequestT = Model::UpdateSubscriptionRequest>
        Model::UpdateSubscriptionOutcomeCallable UpdateSubscriptionCallable(const UpdateSubscriptionRequestT& request = {}) const
        {
            return SubmitCallable(&ShieldClient::UpdateSubscription, request);
        }
 
        template<typename UpdateSubscriptionRequestT = Model::UpdateSubscriptionRequest>
        void UpdateSubscriptionAsync(const UpdateSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateSubscriptionRequestT& request = {}) const
        {
            return SubmitAsync(&ShieldClient::UpdateSubscription, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<ShieldEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<ShieldClient>;
      void init(const ShieldClientConfiguration& clientConfiguration);
 
      ShieldClientConfiguration m_clientConfiguration;
      std::shared_ptr<ShieldEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Shield
} // namespace Aws