/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include namespace Aws { namespace Shield { /** * Shield Advanced

This is the Shield Advanced API * Reference. This guide is for developers who need detailed information about * the Shield Advanced API actions, data types, and errors. For detailed * information about WAF and Shield Advanced features and an overview of how to use * the WAF and Shield Advanced APIs, see the WAF and Shield * Developer Guide.

*/ class AWS_SHIELD_API ShieldClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef ShieldClientConfiguration ClientConfigurationType; typedef ShieldEndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ ShieldClient(const Aws::Shield::ShieldClientConfiguration& clientConfiguration = Aws::Shield::ShieldClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ ShieldClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::Shield::ShieldClientConfiguration& clientConfiguration = Aws::Shield::ShieldClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ ShieldClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::Shield::ShieldClientConfiguration& clientConfiguration = Aws::Shield::ShieldClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ ShieldClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ ShieldClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ ShieldClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~ShieldClient(); /** *

Authorizes the Shield Response Team (SRT) to access the specified Amazon S3 * bucket containing log data such as Application Load Balancer access logs, * CloudFront logs, or logs from third party sources. You can associate up to 10 * Amazon S3 buckets with your subscription.

To use the services of the SRT * and make an AssociateDRTLogBucket request, you must be subscribed * to the Business * Support plan or the Enterprise * Support plan.

See Also:

AWS * API Reference

*/ virtual Model::AssociateDRTLogBucketOutcome AssociateDRTLogBucket(const Model::AssociateDRTLogBucketRequest& request) const; /** * A Callable wrapper for AssociateDRTLogBucket that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateDRTLogBucketOutcomeCallable AssociateDRTLogBucketCallable(const AssociateDRTLogBucketRequestT& request) const { return SubmitCallable(&ShieldClient::AssociateDRTLogBucket, request); } /** * An Async wrapper for AssociateDRTLogBucket that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateDRTLogBucketAsync(const AssociateDRTLogBucketRequestT& request, const AssociateDRTLogBucketResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::AssociateDRTLogBucket, request, handler, context); } /** *

Authorizes the Shield Response Team (SRT) using the specified role, to access * your Amazon Web Services account to assist with DDoS attack mitigation during * potential attacks. This enables the SRT to inspect your WAF configuration and * create or update WAF rules and web ACLs.

You can associate only one * RoleArn with your subscription. If you submit an * AssociateDRTRole request for an account that already has an * associated role, the new RoleArn will replace the existing * RoleArn.

Prior to making the AssociateDRTRole * request, you must attach the AWSShieldDRTAccessPolicy managed * policy to the role that you'll specify in the request. You can access this * policy in the IAM console at AWSShieldDRTAccessPolicy. * For more information see Adding * and removing IAM identity permissions. The role must also trust the service * principal drt.shield.amazonaws.com. For more information, see IAM * JSON policy elements: Principal.

The SRT will have access only to * your WAF and Shield resources. By submitting this request, you authorize the SRT * to inspect your WAF and Shield configuration and create and update WAF rules and * web ACLs on your behalf. The SRT takes these actions only if explicitly * authorized by you.

You must have the iam:PassRole permission * to make an AssociateDRTRole request. For more information, see Granting * a user permissions to pass a role to an Amazon Web Services service.

*

To use the services of the SRT and make an AssociateDRTRole * request, you must be subscribed to the Business Support * plan or the Enterprise * Support plan.

See Also:

AWS * API Reference

*/ virtual Model::AssociateDRTRoleOutcome AssociateDRTRole(const Model::AssociateDRTRoleRequest& request) const; /** * A Callable wrapper for AssociateDRTRole that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateDRTRoleOutcomeCallable AssociateDRTRoleCallable(const AssociateDRTRoleRequestT& request) const { return SubmitCallable(&ShieldClient::AssociateDRTRole, request); } /** * An Async wrapper for AssociateDRTRole that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateDRTRoleAsync(const AssociateDRTRoleRequestT& request, const AssociateDRTRoleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::AssociateDRTRole, request, handler, context); } /** *

Adds health-based detection to the Shield Advanced protection for a resource. * Shield Advanced health-based detection uses the health of your Amazon Web * Services resource to improve responsiveness and accuracy in attack detection and * response.

You define the health check in Route 53 and then associate it * with your Shield Advanced protection. For more information, see Shield * Advanced Health-Based Detection in the WAF Developer Guide. *

See Also:

AWS * API Reference

*/ virtual Model::AssociateHealthCheckOutcome AssociateHealthCheck(const Model::AssociateHealthCheckRequest& request) const; /** * A Callable wrapper for AssociateHealthCheck that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateHealthCheckOutcomeCallable AssociateHealthCheckCallable(const AssociateHealthCheckRequestT& request) const { return SubmitCallable(&ShieldClient::AssociateHealthCheck, request); } /** * An Async wrapper for AssociateHealthCheck that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateHealthCheckAsync(const AssociateHealthCheckRequestT& request, const AssociateHealthCheckResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::AssociateHealthCheck, request, handler, context); } /** *

Initializes proactive engagement and sets the list of contacts for the Shield * Response Team (SRT) to use. You must provide at least one phone number in the * emergency contact list.

After you have initialized proactive engagement * using this call, to disable or enable proactive engagement, use the calls * DisableProactiveEngagement and * EnableProactiveEngagement.

This call defines the * list of email addresses and phone numbers that the SRT can use to contact you * for escalations to the SRT and to initiate proactive customer support.

*

The contacts that you provide in the request replace any contacts that were * already defined. If you already have contacts defined and want to use them, * retrieve the list using DescribeEmergencyContactSettings and then * provide it to this call.

See Also:

AWS * API Reference

*/ virtual Model::AssociateProactiveEngagementDetailsOutcome AssociateProactiveEngagementDetails(const Model::AssociateProactiveEngagementDetailsRequest& request) const; /** * A Callable wrapper for AssociateProactiveEngagementDetails that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateProactiveEngagementDetailsOutcomeCallable AssociateProactiveEngagementDetailsCallable(const AssociateProactiveEngagementDetailsRequestT& request) const { return SubmitCallable(&ShieldClient::AssociateProactiveEngagementDetails, request); } /** * An Async wrapper for AssociateProactiveEngagementDetails that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateProactiveEngagementDetailsAsync(const AssociateProactiveEngagementDetailsRequestT& request, const AssociateProactiveEngagementDetailsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::AssociateProactiveEngagementDetails, request, handler, context); } /** *

Enables Shield Advanced for a specific Amazon Web Services resource. The * resource can be an Amazon CloudFront distribution, Amazon Route 53 hosted zone, * Global Accelerator standard accelerator, Elastic IP Address, Application Load * Balancer, or a Classic Load Balancer. You can protect Amazon EC2 instances and * Network Load Balancers by association with protected Amazon EC2 Elastic IP * addresses.

You can add protection to only a single resource with each * CreateProtection request. You can add protection to multiple * resources at once through the Shield Advanced console at https://console.aws.amazon.com/wafv2/shieldv2#/. * For more information see Getting * Started with Shield Advanced and Adding * Shield Advanced protection to Amazon Web Services resources.

See * Also:

AWS * API Reference

*/ virtual Model::CreateProtectionOutcome CreateProtection(const Model::CreateProtectionRequest& request) const; /** * A Callable wrapper for CreateProtection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateProtectionOutcomeCallable CreateProtectionCallable(const CreateProtectionRequestT& request) const { return SubmitCallable(&ShieldClient::CreateProtection, request); } /** * An Async wrapper for CreateProtection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateProtectionAsync(const CreateProtectionRequestT& request, const CreateProtectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::CreateProtection, request, handler, context); } /** *

Creates a grouping of protected resources so they can be handled as a * collective. This resource grouping improves the accuracy of detection and * reduces false positives.

See Also:

AWS * API Reference

*/ virtual Model::CreateProtectionGroupOutcome CreateProtectionGroup(const Model::CreateProtectionGroupRequest& request) const; /** * A Callable wrapper for CreateProtectionGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateProtectionGroupOutcomeCallable CreateProtectionGroupCallable(const CreateProtectionGroupRequestT& request) const { return SubmitCallable(&ShieldClient::CreateProtectionGroup, request); } /** * An Async wrapper for CreateProtectionGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateProtectionGroupAsync(const CreateProtectionGroupRequestT& request, const CreateProtectionGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::CreateProtectionGroup, request, handler, context); } /** *

Activates Shield Advanced for an account.

For accounts that are * members of an Organizations organization, Shield Advanced subscriptions are * billed against the organization's payer account, regardless of whether the payer * account itself is subscribed.

When you initially create a * subscription, your subscription is set to be automatically renewed at the end of * the existing subscription period. You can change this by submitting an * UpdateSubscription request.

See Also:

AWS * API Reference

*/ virtual Model::CreateSubscriptionOutcome CreateSubscription(const Model::CreateSubscriptionRequest& request) const; /** * A Callable wrapper for CreateSubscription that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateSubscriptionOutcomeCallable CreateSubscriptionCallable(const CreateSubscriptionRequestT& request) const { return SubmitCallable(&ShieldClient::CreateSubscription, request); } /** * An Async wrapper for CreateSubscription that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateSubscriptionAsync(const CreateSubscriptionRequestT& request, const CreateSubscriptionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::CreateSubscription, request, handler, context); } /** *

Deletes an Shield Advanced Protection.

See Also:

AWS * API Reference

*/ virtual Model::DeleteProtectionOutcome DeleteProtection(const Model::DeleteProtectionRequest& request) const; /** * A Callable wrapper for DeleteProtection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteProtectionOutcomeCallable DeleteProtectionCallable(const DeleteProtectionRequestT& request) const { return SubmitCallable(&ShieldClient::DeleteProtection, request); } /** * An Async wrapper for DeleteProtection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteProtectionAsync(const DeleteProtectionRequestT& request, const DeleteProtectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::DeleteProtection, request, handler, context); } /** *

Removes the specified protection group.

See Also:

AWS * API Reference

*/ virtual Model::DeleteProtectionGroupOutcome DeleteProtectionGroup(const Model::DeleteProtectionGroupRequest& request) const; /** * A Callable wrapper for DeleteProtectionGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteProtectionGroupOutcomeCallable DeleteProtectionGroupCallable(const DeleteProtectionGroupRequestT& request) const { return SubmitCallable(&ShieldClient::DeleteProtectionGroup, request); } /** * An Async wrapper for DeleteProtectionGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteProtectionGroupAsync(const DeleteProtectionGroupRequestT& request, const DeleteProtectionGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::DeleteProtectionGroup, request, handler, context); } /** *

Describes the details of a DDoS attack.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAttackOutcome DescribeAttack(const Model::DescribeAttackRequest& request) const; /** * A Callable wrapper for DescribeAttack that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAttackOutcomeCallable DescribeAttackCallable(const DescribeAttackRequestT& request) const { return SubmitCallable(&ShieldClient::DescribeAttack, request); } /** * An Async wrapper for DescribeAttack that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAttackAsync(const DescribeAttackRequestT& request, const DescribeAttackResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::DescribeAttack, request, handler, context); } /** *

Provides information about the number and type of attacks Shield has detected * in the last year for all resources that belong to your account, regardless of * whether you've defined Shield protections for them. This operation is available * to Shield customers as well as to Shield Advanced customers.

The * operation returns data for the time range of midnight UTC, one year ago, to * midnight UTC, today. For example, if the current time is 2020-10-26 * 15:39:32 PDT, equal to 2020-10-26 22:39:32 UTC, then the * time range for the attack data returned is from 2019-10-26 00:00:00 * UTC to 2020-10-26 00:00:00 UTC.

The time range * indicates the period covered by the attack statistics data items.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeAttackStatisticsOutcome DescribeAttackStatistics(const Model::DescribeAttackStatisticsRequest& request) const; /** * A Callable wrapper for DescribeAttackStatistics that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAttackStatisticsOutcomeCallable DescribeAttackStatisticsCallable(const DescribeAttackStatisticsRequestT& request) const { return SubmitCallable(&ShieldClient::DescribeAttackStatistics, request); } /** * An Async wrapper for DescribeAttackStatistics that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAttackStatisticsAsync(const DescribeAttackStatisticsRequestT& request, const DescribeAttackStatisticsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::DescribeAttackStatistics, request, handler, context); } /** *

Returns the current role and list of Amazon S3 log buckets used by the Shield * Response Team (SRT) to access your Amazon Web Services account while assisting * with attack mitigation.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDRTAccessOutcome DescribeDRTAccess(const Model::DescribeDRTAccessRequest& request) const; /** * A Callable wrapper for DescribeDRTAccess that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDRTAccessOutcomeCallable DescribeDRTAccessCallable(const DescribeDRTAccessRequestT& request) const { return SubmitCallable(&ShieldClient::DescribeDRTAccess, request); } /** * An Async wrapper for DescribeDRTAccess that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDRTAccessAsync(const DescribeDRTAccessRequestT& request, const DescribeDRTAccessResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::DescribeDRTAccess, request, handler, context); } /** *

A list of email addresses and phone numbers that the Shield Response Team * (SRT) can use to contact you if you have proactive engagement enabled, for * escalations to the SRT and to initiate proactive customer support.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeEmergencyContactSettingsOutcome DescribeEmergencyContactSettings(const Model::DescribeEmergencyContactSettingsRequest& request) const; /** * A Callable wrapper for DescribeEmergencyContactSettings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeEmergencyContactSettingsOutcomeCallable DescribeEmergencyContactSettingsCallable(const DescribeEmergencyContactSettingsRequestT& request) const { return SubmitCallable(&ShieldClient::DescribeEmergencyContactSettings, request); } /** * An Async wrapper for DescribeEmergencyContactSettings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeEmergencyContactSettingsAsync(const DescribeEmergencyContactSettingsRequestT& request, const DescribeEmergencyContactSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::DescribeEmergencyContactSettings, request, handler, context); } /** *

Lists the details of a Protection object.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeProtectionOutcome DescribeProtection(const Model::DescribeProtectionRequest& request) const; /** * A Callable wrapper for DescribeProtection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeProtectionOutcomeCallable DescribeProtectionCallable(const DescribeProtectionRequestT& request) const { return SubmitCallable(&ShieldClient::DescribeProtection, request); } /** * An Async wrapper for DescribeProtection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeProtectionAsync(const DescribeProtectionRequestT& request, const DescribeProtectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::DescribeProtection, request, handler, context); } /** *

Returns the specification for the specified protection group.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeProtectionGroupOutcome DescribeProtectionGroup(const Model::DescribeProtectionGroupRequest& request) const; /** * A Callable wrapper for DescribeProtectionGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeProtectionGroupOutcomeCallable DescribeProtectionGroupCallable(const DescribeProtectionGroupRequestT& request) const { return SubmitCallable(&ShieldClient::DescribeProtectionGroup, request); } /** * An Async wrapper for DescribeProtectionGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeProtectionGroupAsync(const DescribeProtectionGroupRequestT& request, const DescribeProtectionGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::DescribeProtectionGroup, request, handler, context); } /** *

Provides details about the Shield Advanced subscription for an * account.

See Also:

AWS * API Reference

*/ virtual Model::DescribeSubscriptionOutcome DescribeSubscription(const Model::DescribeSubscriptionRequest& request) const; /** * A Callable wrapper for DescribeSubscription that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeSubscriptionOutcomeCallable DescribeSubscriptionCallable(const DescribeSubscriptionRequestT& request) const { return SubmitCallable(&ShieldClient::DescribeSubscription, request); } /** * An Async wrapper for DescribeSubscription that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeSubscriptionAsync(const DescribeSubscriptionRequestT& request, const DescribeSubscriptionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::DescribeSubscription, request, handler, context); } /** *

Disable the Shield Advanced automatic application layer DDoS mitigation * feature for the protected resource. This stops Shield Advanced from creating, * verifying, and applying WAF rules for attacks that it detects for the resource. *

See Also:

AWS * API Reference

*/ virtual Model::DisableApplicationLayerAutomaticResponseOutcome DisableApplicationLayerAutomaticResponse(const Model::DisableApplicationLayerAutomaticResponseRequest& request) const; /** * A Callable wrapper for DisableApplicationLayerAutomaticResponse that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisableApplicationLayerAutomaticResponseOutcomeCallable DisableApplicationLayerAutomaticResponseCallable(const DisableApplicationLayerAutomaticResponseRequestT& request) const { return SubmitCallable(&ShieldClient::DisableApplicationLayerAutomaticResponse, request); } /** * An Async wrapper for DisableApplicationLayerAutomaticResponse that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisableApplicationLayerAutomaticResponseAsync(const DisableApplicationLayerAutomaticResponseRequestT& request, const DisableApplicationLayerAutomaticResponseResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::DisableApplicationLayerAutomaticResponse, request, handler, context); } /** *

Removes authorization from the Shield Response Team (SRT) to notify contacts * about escalations to the SRT and to initiate proactive customer * support.

See Also:

AWS * API Reference

*/ virtual Model::DisableProactiveEngagementOutcome DisableProactiveEngagement(const Model::DisableProactiveEngagementRequest& request) const; /** * A Callable wrapper for DisableProactiveEngagement that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisableProactiveEngagementOutcomeCallable DisableProactiveEngagementCallable(const DisableProactiveEngagementRequestT& request) const { return SubmitCallable(&ShieldClient::DisableProactiveEngagement, request); } /** * An Async wrapper for DisableProactiveEngagement that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisableProactiveEngagementAsync(const DisableProactiveEngagementRequestT& request, const DisableProactiveEngagementResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::DisableProactiveEngagement, request, handler, context); } /** *

Removes the Shield Response Team's (SRT) access to the specified Amazon S3 * bucket containing the logs that you shared previously.

See Also:

* AWS * API Reference

*/ virtual Model::DisassociateDRTLogBucketOutcome DisassociateDRTLogBucket(const Model::DisassociateDRTLogBucketRequest& request) const; /** * A Callable wrapper for DisassociateDRTLogBucket that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateDRTLogBucketOutcomeCallable DisassociateDRTLogBucketCallable(const DisassociateDRTLogBucketRequestT& request) const { return SubmitCallable(&ShieldClient::DisassociateDRTLogBucket, request); } /** * An Async wrapper for DisassociateDRTLogBucket that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateDRTLogBucketAsync(const DisassociateDRTLogBucketRequestT& request, const DisassociateDRTLogBucketResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::DisassociateDRTLogBucket, request, handler, context); } /** *

Removes the Shield Response Team's (SRT) access to your Amazon Web Services * account.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateDRTRoleOutcome DisassociateDRTRole(const Model::DisassociateDRTRoleRequest& request) const; /** * A Callable wrapper for DisassociateDRTRole that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateDRTRoleOutcomeCallable DisassociateDRTRoleCallable(const DisassociateDRTRoleRequestT& request) const { return SubmitCallable(&ShieldClient::DisassociateDRTRole, request); } /** * An Async wrapper for DisassociateDRTRole that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateDRTRoleAsync(const DisassociateDRTRoleRequestT& request, const DisassociateDRTRoleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::DisassociateDRTRole, request, handler, context); } /** *

Removes health-based detection from the Shield Advanced protection for a * resource. Shield Advanced health-based detection uses the health of your Amazon * Web Services resource to improve responsiveness and accuracy in attack detection * and response.

You define the health check in Route 53 and then associate * or disassociate it with your Shield Advanced protection. For more information, * see Shield * Advanced Health-Based Detection in the WAF Developer Guide. *

See Also:

AWS * API Reference

*/ virtual Model::DisassociateHealthCheckOutcome DisassociateHealthCheck(const Model::DisassociateHealthCheckRequest& request) const; /** * A Callable wrapper for DisassociateHealthCheck that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateHealthCheckOutcomeCallable DisassociateHealthCheckCallable(const DisassociateHealthCheckRequestT& request) const { return SubmitCallable(&ShieldClient::DisassociateHealthCheck, request); } /** * An Async wrapper for DisassociateHealthCheck that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateHealthCheckAsync(const DisassociateHealthCheckRequestT& request, const DisassociateHealthCheckResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::DisassociateHealthCheck, request, handler, context); } /** *

Enable the Shield Advanced automatic application layer DDoS mitigation for * the protected resource.

This feature is available for Amazon * CloudFront distributions and Application Load Balancers only.

*

This causes Shield Advanced to create, verify, and apply WAF rules for DDoS * attacks that it detects for the resource. Shield Advanced applies the rules in a * Shield rule group inside the web ACL that you've associated with the resource. * For information about how automatic mitigation works and the requirements for * using it, see Shield * Advanced automatic application layer DDoS mitigation.

Don't * use this action to make changes to automatic mitigation settings when it's * already enabled for a resource. Instead, use * UpdateApplicationLayerAutomaticResponse.

To use this * feature, you must associate a web ACL with the protected resource. The web ACL * must be created using the latest version of WAF (v2). You can associate the web * ACL through the Shield Advanced console at https://console.aws.amazon.com/wafv2/shieldv2#/. * For more information, see Getting * Started with Shield Advanced. You can also associate the web ACL to the * resource through the WAF console or the WAF API, but you must manage Shield * Advanced automatic mitigation through Shield Advanced. For information about * WAF, see WAF * Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::EnableApplicationLayerAutomaticResponseOutcome EnableApplicationLayerAutomaticResponse(const Model::EnableApplicationLayerAutomaticResponseRequest& request) const; /** * A Callable wrapper for EnableApplicationLayerAutomaticResponse that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableApplicationLayerAutomaticResponseOutcomeCallable EnableApplicationLayerAutomaticResponseCallable(const EnableApplicationLayerAutomaticResponseRequestT& request) const { return SubmitCallable(&ShieldClient::EnableApplicationLayerAutomaticResponse, request); } /** * An Async wrapper for EnableApplicationLayerAutomaticResponse that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableApplicationLayerAutomaticResponseAsync(const EnableApplicationLayerAutomaticResponseRequestT& request, const EnableApplicationLayerAutomaticResponseResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::EnableApplicationLayerAutomaticResponse, request, handler, context); } /** *

Authorizes the Shield Response Team (SRT) to use email and phone to notify * contacts about escalations to the SRT and to initiate proactive customer * support.

See Also:

AWS * API Reference

*/ virtual Model::EnableProactiveEngagementOutcome EnableProactiveEngagement(const Model::EnableProactiveEngagementRequest& request) const; /** * A Callable wrapper for EnableProactiveEngagement that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableProactiveEngagementOutcomeCallable EnableProactiveEngagementCallable(const EnableProactiveEngagementRequestT& request) const { return SubmitCallable(&ShieldClient::EnableProactiveEngagement, request); } /** * An Async wrapper for EnableProactiveEngagement that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableProactiveEngagementAsync(const EnableProactiveEngagementRequestT& request, const EnableProactiveEngagementResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::EnableProactiveEngagement, request, handler, context); } /** *

Returns the SubscriptionState, either Active or * Inactive.

See Also:

AWS * API Reference

*/ virtual Model::GetSubscriptionStateOutcome GetSubscriptionState(const Model::GetSubscriptionStateRequest& request) const; /** * A Callable wrapper for GetSubscriptionState that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetSubscriptionStateOutcomeCallable GetSubscriptionStateCallable(const GetSubscriptionStateRequestT& request) const { return SubmitCallable(&ShieldClient::GetSubscriptionState, request); } /** * An Async wrapper for GetSubscriptionState that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetSubscriptionStateAsync(const GetSubscriptionStateRequestT& request, const GetSubscriptionStateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::GetSubscriptionState, request, handler, context); } /** *

Returns all ongoing DDoS attacks or all DDoS attacks during a specified time * period.

See Also:

AWS * API Reference

*/ virtual Model::ListAttacksOutcome ListAttacks(const Model::ListAttacksRequest& request) const; /** * A Callable wrapper for ListAttacks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAttacksOutcomeCallable ListAttacksCallable(const ListAttacksRequestT& request) const { return SubmitCallable(&ShieldClient::ListAttacks, request); } /** * An Async wrapper for ListAttacks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAttacksAsync(const ListAttacksRequestT& request, const ListAttacksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::ListAttacks, request, handler, context); } /** *

Retrieves ProtectionGroup objects for the account. You can retrieve * all protection groups or you can provide filtering criteria and retrieve just * the subset of protection groups that match the criteria.

See * Also:

AWS * API Reference

*/ virtual Model::ListProtectionGroupsOutcome ListProtectionGroups(const Model::ListProtectionGroupsRequest& request) const; /** * A Callable wrapper for ListProtectionGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListProtectionGroupsOutcomeCallable ListProtectionGroupsCallable(const ListProtectionGroupsRequestT& request) const { return SubmitCallable(&ShieldClient::ListProtectionGroups, request); } /** * An Async wrapper for ListProtectionGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListProtectionGroupsAsync(const ListProtectionGroupsRequestT& request, const ListProtectionGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::ListProtectionGroups, request, handler, context); } /** *

Retrieves Protection objects for the account. You can retrieve all * protections or you can provide filtering criteria and retrieve just the subset * of protections that match the criteria.

See Also:

AWS * API Reference

*/ virtual Model::ListProtectionsOutcome ListProtections(const Model::ListProtectionsRequest& request) const; /** * A Callable wrapper for ListProtections that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListProtectionsOutcomeCallable ListProtectionsCallable(const ListProtectionsRequestT& request) const { return SubmitCallable(&ShieldClient::ListProtections, request); } /** * An Async wrapper for ListProtections that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListProtectionsAsync(const ListProtectionsRequestT& request, const ListProtectionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::ListProtections, request, handler, context); } /** *

Retrieves the resources that are included in the protection group. *

See Also:

AWS * API Reference

*/ virtual Model::ListResourcesInProtectionGroupOutcome ListResourcesInProtectionGroup(const Model::ListResourcesInProtectionGroupRequest& request) const; /** * A Callable wrapper for ListResourcesInProtectionGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListResourcesInProtectionGroupOutcomeCallable ListResourcesInProtectionGroupCallable(const ListResourcesInProtectionGroupRequestT& request) const { return SubmitCallable(&ShieldClient::ListResourcesInProtectionGroup, request); } /** * An Async wrapper for ListResourcesInProtectionGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListResourcesInProtectionGroupAsync(const ListResourcesInProtectionGroupRequestT& request, const ListResourcesInProtectionGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::ListResourcesInProtectionGroup, request, handler, context); } /** *

Gets information about Amazon Web Services tags for a specified Amazon * Resource Name (ARN) in Shield.

See Also:

AWS * API Reference

*/ virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const; /** * A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const { return SubmitCallable(&ShieldClient::ListTagsForResource, request); } /** * An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::ListTagsForResource, request, handler, context); } /** *

Adds or updates tags for a resource in Shield.

See Also:

AWS * API Reference

*/ virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const; /** * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const { return SubmitCallable(&ShieldClient::TagResource, request); } /** * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::TagResource, request, handler, context); } /** *

Removes tags from a resource in Shield.

See Also:

AWS * API Reference

*/ virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const; /** * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const { return SubmitCallable(&ShieldClient::UntagResource, request); } /** * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::UntagResource, request, handler, context); } /** *

Updates an existing Shield Advanced automatic application layer DDoS * mitigation configuration for the specified resource.

See Also:

* AWS * API Reference

*/ virtual Model::UpdateApplicationLayerAutomaticResponseOutcome UpdateApplicationLayerAutomaticResponse(const Model::UpdateApplicationLayerAutomaticResponseRequest& request) const; /** * A Callable wrapper for UpdateApplicationLayerAutomaticResponse that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateApplicationLayerAutomaticResponseOutcomeCallable UpdateApplicationLayerAutomaticResponseCallable(const UpdateApplicationLayerAutomaticResponseRequestT& request) const { return SubmitCallable(&ShieldClient::UpdateApplicationLayerAutomaticResponse, request); } /** * An Async wrapper for UpdateApplicationLayerAutomaticResponse that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateApplicationLayerAutomaticResponseAsync(const UpdateApplicationLayerAutomaticResponseRequestT& request, const UpdateApplicationLayerAutomaticResponseResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::UpdateApplicationLayerAutomaticResponse, request, handler, context); } /** *

Updates the details of the list of email addresses and phone numbers that the * Shield Response Team (SRT) can use to contact you if you have proactive * engagement enabled, for escalations to the SRT and to initiate proactive * customer support.

See Also:

AWS * API Reference

*/ virtual Model::UpdateEmergencyContactSettingsOutcome UpdateEmergencyContactSettings(const Model::UpdateEmergencyContactSettingsRequest& request) const; /** * A Callable wrapper for UpdateEmergencyContactSettings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateEmergencyContactSettingsOutcomeCallable UpdateEmergencyContactSettingsCallable(const UpdateEmergencyContactSettingsRequestT& request) const { return SubmitCallable(&ShieldClient::UpdateEmergencyContactSettings, request); } /** * An Async wrapper for UpdateEmergencyContactSettings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateEmergencyContactSettingsAsync(const UpdateEmergencyContactSettingsRequestT& request, const UpdateEmergencyContactSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::UpdateEmergencyContactSettings, request, handler, context); } /** *

Updates an existing protection group. A protection group is a grouping of * protected resources so they can be handled as a collective. This resource * grouping improves the accuracy of detection and reduces false positives. *

See Also:

AWS * API Reference

*/ virtual Model::UpdateProtectionGroupOutcome UpdateProtectionGroup(const Model::UpdateProtectionGroupRequest& request) const; /** * A Callable wrapper for UpdateProtectionGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateProtectionGroupOutcomeCallable UpdateProtectionGroupCallable(const UpdateProtectionGroupRequestT& request) const { return SubmitCallable(&ShieldClient::UpdateProtectionGroup, request); } /** * An Async wrapper for UpdateProtectionGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateProtectionGroupAsync(const UpdateProtectionGroupRequestT& request, const UpdateProtectionGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::UpdateProtectionGroup, request, handler, context); } /** *

Updates the details of an existing subscription. Only enter values for * parameters you want to change. Empty parameters are not updated.

*

For accounts that are members of an Organizations organization, Shield * Advanced subscriptions are billed against the organization's payer account, * regardless of whether the payer account itself is subscribed.

*

See Also:

AWS * API Reference

*/ virtual Model::UpdateSubscriptionOutcome UpdateSubscription(const Model::UpdateSubscriptionRequest& request) const; /** * A Callable wrapper for UpdateSubscription that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateSubscriptionOutcomeCallable UpdateSubscriptionCallable(const UpdateSubscriptionRequestT& request) const { return SubmitCallable(&ShieldClient::UpdateSubscription, request); } /** * An Async wrapper for UpdateSubscription that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateSubscriptionAsync(const UpdateSubscriptionRequestT& request, const UpdateSubscriptionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ShieldClient::UpdateSubscription, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const ShieldClientConfiguration& clientConfiguration); ShieldClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace Shield } // namespace Aws