@aws-sdk/client-shield 3.35.0 → 3.38.0

package/dist-types/ts3.4/commands/AssociateDRTLogBucketCommand.d.ts

@@ -6,30 +6,11 @@ export interface AssociateDRTLogBucketCommandInput extends AssociateDRTLogBucket
 }
 export interface AssociateDRTLogBucketCommandOutput extends AssociateDRTLogBucketResponse, __MetadataBearer {
 }
-/**
- * <p>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.</p>
- * 	        <p>To use the services of the SRT and make an <code>AssociateDRTLogBucket</code> request, you must be subscribed to the <a href="https://aws.amazon.com/premiumsupport/business-support/">Business Support plan</a> or the <a href="https://aws.amazon.com/premiumsupport/enterprise-support/">Enterprise Support plan</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ShieldClient, AssociateDRTLogBucketCommand } from "@aws-sdk/client-shield"; // ES Modules import
- * // const { ShieldClient, AssociateDRTLogBucketCommand } = require("@aws-sdk/client-shield"); // CommonJS import
- * const client = new ShieldClient(config);
- * const command = new AssociateDRTLogBucketCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AssociateDRTLogBucketCommandInput} for command's `input` shape.
- * @see {@link AssociateDRTLogBucketCommandOutput} for command's `response` shape.
- * @see {@link ShieldClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AssociateDRTLogBucketCommand extends $Command<AssociateDRTLogBucketCommandInput, AssociateDRTLogBucketCommandOutput, ShieldClientResolvedConfig> {
     readonly input: AssociateDRTLogBucketCommandInput;
     constructor(input: AssociateDRTLogBucketCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ShieldClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateDRTLogBucketCommandInput, AssociateDRTLogBucketCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/AssociateDRTRoleCommand.d.ts

@@ -6,35 +6,11 @@ export interface AssociateDRTRoleCommandInput extends AssociateDRTRoleRequest {
 }
 export interface AssociateDRTRoleCommandOutput extends AssociateDRTRoleResponse, __MetadataBearer {
 }
-/**
- * <p>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.</p>
- *          <p>You can associate only one <code>RoleArn</code> with your subscription. If you submit an <code>AssociateDRTRole</code> request for an account that already has an associated role, the new <code>RoleArn</code> will replace the existing <code>RoleArn</code>. </p>
- *          <p>Prior to making the <code>AssociateDRTRole</code> request, you must attach the <a href="https://console.aws.amazon.com/iam/home?#/policies/arn:aws:iam::aws:policy/service-role/AWSShieldDRTAccessPolicy">AWSShieldDRTAccessPolicy</a> managed policy to the role you will specify in the request. For more information see <a href=" https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html">Attaching and Detaching IAM Policies</a>. The role must also trust the service principal <code> drt.shield.amazonaws.com</code>. For more information, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html">IAM JSON Policy Elements: Principal</a>.</p>
- *
- *          <p>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.</p>
- *          <p>You must have the <code>iam:PassRole</code> permission to make an <code>AssociateDRTRole</code> request. For more information, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html">Granting a User Permissions to Pass a Role to an Amazon Web Services Service</a>. </p>
- *          <p>To use the services of the SRT and make an <code>AssociateDRTRole</code> request, you must be subscribed to the <a href="https://aws.amazon.com/premiumsupport/business-support/">Business Support plan</a> or the <a href="https://aws.amazon.com/premiumsupport/enterprise-support/">Enterprise Support plan</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ShieldClient, AssociateDRTRoleCommand } from "@aws-sdk/client-shield"; // ES Modules import
- * // const { ShieldClient, AssociateDRTRoleCommand } = require("@aws-sdk/client-shield"); // CommonJS import
- * const client = new ShieldClient(config);
- * const command = new AssociateDRTRoleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AssociateDRTRoleCommandInput} for command's `input` shape.
- * @see {@link AssociateDRTRoleCommandOutput} for command's `response` shape.
- * @see {@link ShieldClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AssociateDRTRoleCommand extends $Command<AssociateDRTRoleCommandInput, AssociateDRTRoleCommandOutput, ShieldClientResolvedConfig> {
     readonly input: AssociateDRTRoleCommandInput;
     constructor(input: AssociateDRTRoleCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ShieldClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateDRTRoleCommandInput, AssociateDRTRoleCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/AssociateHealthCheckCommand.d.ts

@@ -6,30 +6,11 @@ export interface AssociateHealthCheckCommandInput extends AssociateHealthCheckRe
 }
 export interface AssociateHealthCheckCommandOutput extends AssociateHealthCheckResponse, __MetadataBearer {
 }
-/**
- * <p>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 mitigation.  </p>
- *          <p>You define the health check in Route 53 and then associate it with your Shield Advanced protection. For more information, see <a href="https://docs.aws.amazon.com/waf/latest/developerguide/ddos-overview.html#ddos-advanced-health-check-option">Shield Advanced Health-Based Detection</a> in the <i>WAF Developer Guide</i>. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ShieldClient, AssociateHealthCheckCommand } from "@aws-sdk/client-shield"; // ES Modules import
- * // const { ShieldClient, AssociateHealthCheckCommand } = require("@aws-sdk/client-shield"); // CommonJS import
- * const client = new ShieldClient(config);
- * const command = new AssociateHealthCheckCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AssociateHealthCheckCommandInput} for command's `input` shape.
- * @see {@link AssociateHealthCheckCommandOutput} for command's `response` shape.
- * @see {@link ShieldClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AssociateHealthCheckCommand extends $Command<AssociateHealthCheckCommandInput, AssociateHealthCheckCommandOutput, ShieldClientResolvedConfig> {
     readonly input: AssociateHealthCheckCommandInput;
     constructor(input: AssociateHealthCheckCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ShieldClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateHealthCheckCommandInput, AssociateHealthCheckCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/AssociateProactiveEngagementDetailsCommand.d.ts

@@ -6,34 +6,11 @@ export interface AssociateProactiveEngagementDetailsCommandInput extends Associa
 }
 export interface AssociateProactiveEngagementDetailsCommandOutput extends AssociateProactiveEngagementDetailsResponse, __MetadataBearer {
 }
-/**
- * <p>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. </p>
- *          <p>After you have initialized proactive engagement using this call, to disable or enable proactive engagement, use the calls <code>DisableProactiveEngagement</code> and <code>EnableProactiveEngagement</code>.  </p>
- *          <note>
- *             <p>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.</p>
- *             <p>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 <code>DescribeEmergencyContactSettings</code> and then provide it to this call.  </p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ShieldClient, AssociateProactiveEngagementDetailsCommand } from "@aws-sdk/client-shield"; // ES Modules import
- * // const { ShieldClient, AssociateProactiveEngagementDetailsCommand } = require("@aws-sdk/client-shield"); // CommonJS import
- * const client = new ShieldClient(config);
- * const command = new AssociateProactiveEngagementDetailsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AssociateProactiveEngagementDetailsCommandInput} for command's `input` shape.
- * @see {@link AssociateProactiveEngagementDetailsCommandOutput} for command's `response` shape.
- * @see {@link ShieldClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AssociateProactiveEngagementDetailsCommand extends $Command<AssociateProactiveEngagementDetailsCommandInput, AssociateProactiveEngagementDetailsCommandOutput, ShieldClientResolvedConfig> {
     readonly input: AssociateProactiveEngagementDetailsCommandInput;
     constructor(input: AssociateProactiveEngagementDetailsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ShieldClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateProactiveEngagementDetailsCommandInput, AssociateProactiveEngagementDetailsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateProtectionCommand.d.ts

@@ -6,30 +6,11 @@ export interface CreateProtectionCommandInput extends CreateProtectionRequest {
 }
 export interface CreateProtectionCommandOutput extends CreateProtectionResponse, __MetadataBearer {
 }
-/**
- * <p>Enables Shield Advanced for a specific Amazon Web Services resource. The resource can be an Amazon CloudFront distribution, Elastic Load Balancing load balancer, Global Accelerator accelerator, Elastic IP Address, or an Amazon Route 53 hosted zone.</p>
- *          <p>You can add protection to only a single resource with each CreateProtection request. If you want to add protection to multiple resources at once, use the <a href="https://console.aws.amazon.com/waf/">WAF console</a>. For more information see <a href="https://docs.aws.amazon.com/waf/latest/developerguide/getting-started-ddos.html">Getting Started with Shield Advanced</a> and <a href="https://docs.aws.amazon.com/waf/latest/developerguide/configure-new-protection.html">Add Shield Advanced Protection to more Amazon Web Services Resources</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ShieldClient, CreateProtectionCommand } from "@aws-sdk/client-shield"; // ES Modules import
- * // const { ShieldClient, CreateProtectionCommand } = require("@aws-sdk/client-shield"); // CommonJS import
- * const client = new ShieldClient(config);
- * const command = new CreateProtectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateProtectionCommandInput} for command's `input` shape.
- * @see {@link CreateProtectionCommandOutput} for command's `response` shape.
- * @see {@link ShieldClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateProtectionCommand extends $Command<CreateProtectionCommandInput, CreateProtectionCommandOutput, ShieldClientResolvedConfig> {
     readonly input: CreateProtectionCommandInput;
     constructor(input: CreateProtectionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ShieldClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateProtectionCommandInput, CreateProtectionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateProtectionGroupCommand.d.ts

@@ -6,29 +6,11 @@ export interface CreateProtectionGroupCommandInput extends CreateProtectionGroup
 }
 export interface CreateProtectionGroupCommandOutput extends CreateProtectionGroupResponse, __MetadataBearer {
 }
-/**
- * <p>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. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ShieldClient, CreateProtectionGroupCommand } from "@aws-sdk/client-shield"; // ES Modules import
- * // const { ShieldClient, CreateProtectionGroupCommand } = require("@aws-sdk/client-shield"); // CommonJS import
- * const client = new ShieldClient(config);
- * const command = new CreateProtectionGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateProtectionGroupCommandInput} for command's `input` shape.
- * @see {@link CreateProtectionGroupCommandOutput} for command's `response` shape.
- * @see {@link ShieldClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateProtectionGroupCommand extends $Command<CreateProtectionGroupCommandInput, CreateProtectionGroupCommandOutput, ShieldClientResolvedConfig> {
     readonly input: CreateProtectionGroupCommandInput;
     constructor(input: CreateProtectionGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ShieldClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateProtectionGroupCommandInput, CreateProtectionGroupCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateSubscriptionCommand.d.ts

@@ -6,31 +6,11 @@ export interface CreateSubscriptionCommandInput extends CreateSubscriptionReques
 }
 export interface CreateSubscriptionCommandOutput extends CreateSubscriptionResponse, __MetadataBearer {
 }
-/**
- * <p>Activates Shield Advanced for an account.</p>
- *
- *          <p>When you initally 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 <code>UpdateSubscription</code> request. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ShieldClient, CreateSubscriptionCommand } from "@aws-sdk/client-shield"; // ES Modules import
- * // const { ShieldClient, CreateSubscriptionCommand } = require("@aws-sdk/client-shield"); // CommonJS import
- * const client = new ShieldClient(config);
- * const command = new CreateSubscriptionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateSubscriptionCommandInput} for command's `input` shape.
- * @see {@link CreateSubscriptionCommandOutput} for command's `response` shape.
- * @see {@link ShieldClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateSubscriptionCommand extends $Command<CreateSubscriptionCommandInput, CreateSubscriptionCommandOutput, ShieldClientResolvedConfig> {
     readonly input: CreateSubscriptionCommandInput;
     constructor(input: CreateSubscriptionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ShieldClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSubscriptionCommandInput, CreateSubscriptionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteProtectionCommand.d.ts

@@ -6,29 +6,11 @@ export interface DeleteProtectionCommandInput extends DeleteProtectionRequest {
 }
 export interface DeleteProtectionCommandOutput extends DeleteProtectionResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes an Shield Advanced <a>Protection</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ShieldClient, DeleteProtectionCommand } from "@aws-sdk/client-shield"; // ES Modules import
- * // const { ShieldClient, DeleteProtectionCommand } = require("@aws-sdk/client-shield"); // CommonJS import
- * const client = new ShieldClient(config);
- * const command = new DeleteProtectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteProtectionCommandInput} for command's `input` shape.
- * @see {@link DeleteProtectionCommandOutput} for command's `response` shape.
- * @see {@link ShieldClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteProtectionCommand extends $Command<DeleteProtectionCommandInput, DeleteProtectionCommandOutput, ShieldClientResolvedConfig> {
     readonly input: DeleteProtectionCommandInput;
     constructor(input: DeleteProtectionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ShieldClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteProtectionCommandInput, DeleteProtectionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteProtectionGroupCommand.d.ts

@@ -6,29 +6,11 @@ export interface DeleteProtectionGroupCommandInput extends DeleteProtectionGroup
 }
 export interface DeleteProtectionGroupCommandOutput extends DeleteProtectionGroupResponse, __MetadataBearer {
 }
-/**
- * <p>Removes the specified protection group.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ShieldClient, DeleteProtectionGroupCommand } from "@aws-sdk/client-shield"; // ES Modules import
- * // const { ShieldClient, DeleteProtectionGroupCommand } = require("@aws-sdk/client-shield"); // CommonJS import
- * const client = new ShieldClient(config);
- * const command = new DeleteProtectionGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteProtectionGroupCommandInput} for command's `input` shape.
- * @see {@link DeleteProtectionGroupCommandOutput} for command's `response` shape.
- * @see {@link ShieldClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteProtectionGroupCommand extends $Command<DeleteProtectionGroupCommandInput, DeleteProtectionGroupCommandOutput, ShieldClientResolvedConfig> {
     readonly input: DeleteProtectionGroupCommandInput;
     constructor(input: DeleteProtectionGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ShieldClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteProtectionGroupCommandInput, DeleteProtectionGroupCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteSubscriptionCommand.d.ts

@@ -6,31 +6,11 @@ export interface DeleteSubscriptionCommandInput extends DeleteSubscriptionReques
 }
 export interface DeleteSubscriptionCommandOutput extends DeleteSubscriptionResponse, __MetadataBearer {
 }
-/**
- * @deprecated
- *
- * <p>Removes Shield Advanced from an account. Shield Advanced requires a 1-year subscription commitment. You cannot delete a subscription prior to the completion of that commitment. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ShieldClient, DeleteSubscriptionCommand } from "@aws-sdk/client-shield"; // ES Modules import
- * // const { ShieldClient, DeleteSubscriptionCommand } = require("@aws-sdk/client-shield"); // CommonJS import
- * const client = new ShieldClient(config);
- * const command = new DeleteSubscriptionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteSubscriptionCommandInput} for command's `input` shape.
- * @see {@link DeleteSubscriptionCommandOutput} for command's `response` shape.
- * @see {@link ShieldClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteSubscriptionCommand extends $Command<DeleteSubscriptionCommandInput, DeleteSubscriptionCommandOutput, ShieldClientResolvedConfig> {
     readonly input: DeleteSubscriptionCommandInput;
     constructor(input: DeleteSubscriptionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ShieldClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSubscriptionCommandInput, DeleteSubscriptionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeAttackCommand.d.ts

@@ -6,29 +6,11 @@ export interface DescribeAttackCommandInput extends DescribeAttackRequest {
 }
 export interface DescribeAttackCommandOutput extends DescribeAttackResponse, __MetadataBearer {
 }
-/**
- * <p>Describes the details of a DDoS attack. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ShieldClient, DescribeAttackCommand } from "@aws-sdk/client-shield"; // ES Modules import
- * // const { ShieldClient, DescribeAttackCommand } = require("@aws-sdk/client-shield"); // CommonJS import
- * const client = new ShieldClient(config);
- * const command = new DescribeAttackCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeAttackCommandInput} for command's `input` shape.
- * @see {@link DescribeAttackCommandOutput} for command's `response` shape.
- * @see {@link ShieldClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeAttackCommand extends $Command<DescribeAttackCommandInput, DescribeAttackCommandOutput, ShieldClientResolvedConfig> {
     readonly input: DescribeAttackCommandInput;
     constructor(input: DescribeAttackCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ShieldClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAttackCommandInput, DescribeAttackCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeAttackStatisticsCommand.d.ts

@@ -6,31 +6,11 @@ export interface DescribeAttackStatisticsCommandInput extends DescribeAttackStat
 }
 export interface DescribeAttackStatisticsCommandOutput extends DescribeAttackStatisticsResponse, __MetadataBearer {
 }
-/**
- * <p>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.</p>
- *          <p>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 <code>2020-10-26 15:39:32 PDT</code>, equal to <code>2020-10-26 22:39:32 UTC</code>, then the time range for the attack data returned is from <code>2019-10-26 00:00:00 UTC</code> to <code>2020-10-26 00:00:00 UTC</code>. </p>
- *          <p>The time range indicates the period covered by the attack statistics data items.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ShieldClient, DescribeAttackStatisticsCommand } from "@aws-sdk/client-shield"; // ES Modules import
- * // const { ShieldClient, DescribeAttackStatisticsCommand } = require("@aws-sdk/client-shield"); // CommonJS import
- * const client = new ShieldClient(config);
- * const command = new DescribeAttackStatisticsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeAttackStatisticsCommandInput} for command's `input` shape.
- * @see {@link DescribeAttackStatisticsCommandOutput} for command's `response` shape.
- * @see {@link ShieldClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeAttackStatisticsCommand extends $Command<DescribeAttackStatisticsCommandInput, DescribeAttackStatisticsCommandOutput, ShieldClientResolvedConfig> {
     readonly input: DescribeAttackStatisticsCommandInput;
     constructor(input: DescribeAttackStatisticsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ShieldClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAttackStatisticsCommandInput, DescribeAttackStatisticsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeDRTAccessCommand.d.ts

@@ -6,29 +6,11 @@ export interface DescribeDRTAccessCommandInput extends DescribeDRTAccessRequest
 }
 export interface DescribeDRTAccessCommandOutput extends DescribeDRTAccessResponse, __MetadataBearer {
 }
-/**
- * <p>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.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ShieldClient, DescribeDRTAccessCommand } from "@aws-sdk/client-shield"; // ES Modules import
- * // const { ShieldClient, DescribeDRTAccessCommand } = require("@aws-sdk/client-shield"); // CommonJS import
- * const client = new ShieldClient(config);
- * const command = new DescribeDRTAccessCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDRTAccessCommandInput} for command's `input` shape.
- * @see {@link DescribeDRTAccessCommandOutput} for command's `response` shape.
- * @see {@link ShieldClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeDRTAccessCommand extends $Command<DescribeDRTAccessCommandInput, DescribeDRTAccessCommandOutput, ShieldClientResolvedConfig> {
     readonly input: DescribeDRTAccessCommandInput;
     constructor(input: DescribeDRTAccessCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ShieldClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDRTAccessCommandInput, DescribeDRTAccessCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeEmergencyContactSettingsCommand.d.ts

@@ -6,29 +6,11 @@ export interface DescribeEmergencyContactSettingsCommandInput extends DescribeEm
 }
 export interface DescribeEmergencyContactSettingsCommandOutput extends DescribeEmergencyContactSettingsResponse, __MetadataBearer {
 }
-/**
- * <p>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.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ShieldClient, DescribeEmergencyContactSettingsCommand } from "@aws-sdk/client-shield"; // ES Modules import
- * // const { ShieldClient, DescribeEmergencyContactSettingsCommand } = require("@aws-sdk/client-shield"); // CommonJS import
- * const client = new ShieldClient(config);
- * const command = new DescribeEmergencyContactSettingsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeEmergencyContactSettingsCommandInput} for command's `input` shape.
- * @see {@link DescribeEmergencyContactSettingsCommandOutput} for command's `response` shape.
- * @see {@link ShieldClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeEmergencyContactSettingsCommand extends $Command<DescribeEmergencyContactSettingsCommandInput, DescribeEmergencyContactSettingsCommandOutput, ShieldClientResolvedConfig> {
     readonly input: DescribeEmergencyContactSettingsCommandInput;
     constructor(input: DescribeEmergencyContactSettingsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ShieldClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeEmergencyContactSettingsCommandInput, DescribeEmergencyContactSettingsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeProtectionCommand.d.ts

@@ -6,29 +6,11 @@ export interface DescribeProtectionCommandInput extends DescribeProtectionReques
 }
 export interface DescribeProtectionCommandOutput extends DescribeProtectionResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the details of a <a>Protection</a> object.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ShieldClient, DescribeProtectionCommand } from "@aws-sdk/client-shield"; // ES Modules import
- * // const { ShieldClient, DescribeProtectionCommand } = require("@aws-sdk/client-shield"); // CommonJS import
- * const client = new ShieldClient(config);
- * const command = new DescribeProtectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeProtectionCommandInput} for command's `input` shape.
- * @see {@link DescribeProtectionCommandOutput} for command's `response` shape.
- * @see {@link ShieldClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeProtectionCommand extends $Command<DescribeProtectionCommandInput, DescribeProtectionCommandOutput, ShieldClientResolvedConfig> {
     readonly input: DescribeProtectionCommandInput;
     constructor(input: DescribeProtectionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ShieldClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeProtectionCommandInput, DescribeProtectionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeProtectionGroupCommand.d.ts

@@ -6,29 +6,11 @@ export interface DescribeProtectionGroupCommandInput extends DescribeProtectionG
 }
 export interface DescribeProtectionGroupCommandOutput extends DescribeProtectionGroupResponse, __MetadataBearer {
 }
-/**
- * <p>Returns the specification for the specified protection group.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ShieldClient, DescribeProtectionGroupCommand } from "@aws-sdk/client-shield"; // ES Modules import
- * // const { ShieldClient, DescribeProtectionGroupCommand } = require("@aws-sdk/client-shield"); // CommonJS import
- * const client = new ShieldClient(config);
- * const command = new DescribeProtectionGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeProtectionGroupCommandInput} for command's `input` shape.
- * @see {@link DescribeProtectionGroupCommandOutput} for command's `response` shape.
- * @see {@link ShieldClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeProtectionGroupCommand extends $Command<DescribeProtectionGroupCommandInput, DescribeProtectionGroupCommandOutput, ShieldClientResolvedConfig> {
     readonly input: DescribeProtectionGroupCommandInput;
     constructor(input: DescribeProtectionGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ShieldClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeProtectionGroupCommandInput, DescribeProtectionGroupCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeSubscriptionCommand.d.ts

@@ -6,29 +6,11 @@ export interface DescribeSubscriptionCommandInput extends DescribeSubscriptionRe
 }
 export interface DescribeSubscriptionCommandOutput extends DescribeSubscriptionResponse, __MetadataBearer {
 }
-/**
- * <p>Provides details about the Shield Advanced subscription for an account.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ShieldClient, DescribeSubscriptionCommand } from "@aws-sdk/client-shield"; // ES Modules import
- * // const { ShieldClient, DescribeSubscriptionCommand } = require("@aws-sdk/client-shield"); // CommonJS import
- * const client = new ShieldClient(config);
- * const command = new DescribeSubscriptionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeSubscriptionCommandInput} for command's `input` shape.
- * @see {@link DescribeSubscriptionCommandOutput} for command's `response` shape.
- * @see {@link ShieldClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeSubscriptionCommand extends $Command<DescribeSubscriptionCommandInput, DescribeSubscriptionCommandOutput, ShieldClientResolvedConfig> {
     readonly input: DescribeSubscriptionCommandInput;
     constructor(input: DescribeSubscriptionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ShieldClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeSubscriptionCommandInput, DescribeSubscriptionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DisableProactiveEngagementCommand.d.ts

@@ -6,29 +6,11 @@ export interface DisableProactiveEngagementCommandInput extends DisableProactive
 }
 export interface DisableProactiveEngagementCommandOutput extends DisableProactiveEngagementResponse, __MetadataBearer {
 }
-/**
- * <p>Removes authorization from the Shield Response Team (SRT) to notify contacts about escalations to the SRT and to initiate proactive customer support.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ShieldClient, DisableProactiveEngagementCommand } from "@aws-sdk/client-shield"; // ES Modules import
- * // const { ShieldClient, DisableProactiveEngagementCommand } = require("@aws-sdk/client-shield"); // CommonJS import
- * const client = new ShieldClient(config);
- * const command = new DisableProactiveEngagementCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisableProactiveEngagementCommandInput} for command's `input` shape.
- * @see {@link DisableProactiveEngagementCommandOutput} for command's `response` shape.
- * @see {@link ShieldClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisableProactiveEngagementCommand extends $Command<DisableProactiveEngagementCommandInput, DisableProactiveEngagementCommandOutput, ShieldClientResolvedConfig> {
     readonly input: DisableProactiveEngagementCommandInput;
     constructor(input: DisableProactiveEngagementCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ShieldClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisableProactiveEngagementCommandInput, DisableProactiveEngagementCommandOutput>;
     private serialize;
     private deserialize;