ShieldClient.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/shield/ShieldPaginationBase.h>
#include <aws/shield/ShieldServiceClientModel.h>
#include <aws/shield/ShieldWaiter.h>
#include <aws/shield/Shield_EXPORTS.h>
 
namespace Aws {
namespace Shield {
class AWS_SHIELD_API ShieldClient : public Aws::Client::AWSJsonClient,
                                    public Aws::Client::ClientWithAsyncTemplateMethods<ShieldClient>,
                                    public ShieldPaginationBase<ShieldClient>,
                                    public ShieldWaiter<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<ShieldEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ShieldClient>;
  void init(const ShieldClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, ShieldError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  ShieldClientConfiguration m_clientConfiguration;
  std::shared_ptr<ShieldEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Shield
}  // namespace Aws