@aws-sdk/client-ec2 3.36.0 → 3.39.0

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

@@ -6,38 +6,11 @@ export interface CreateSnapshotsCommandInput extends CreateSnapshotsRequest {
 }
 export interface CreateSnapshotsCommandOutput extends CreateSnapshotsResult, __MetadataBearer {
 }
-/**
- * <p>Creates crash-consistent snapshots of multiple EBS volumes and stores the data in S3.
- *     Volumes are chosen by specifying an instance. Any attached volumes will produce one snapshot
- *     each that is crash-consistent across the instance. Boot volumes can be excluded by changing the
- *     parameters. </p>
- *
- *          <p>You can create multi-volume snapshots of instances in a Region and instances on an
- *   	Outpost. If you create snapshots from an instance in a Region, the snapshots must be stored
- *   	in the same Region as the instance. If you create snapshots from an instance on an Outpost,
- *   	the snapshots can be stored on the same Outpost as the instance, or in the Region for that
- *   	Outpost.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateSnapshotsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateSnapshotsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateSnapshotsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateSnapshotsCommandInput} for command's `input` shape.
- * @see {@link CreateSnapshotsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateSnapshotsCommand extends $Command<CreateSnapshotsCommandInput, CreateSnapshotsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateSnapshotsCommandInput;
     constructor(input: CreateSnapshotsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSnapshotsCommandInput, CreateSnapshotsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface CreateSpotDatafeedSubscriptionCommandInput extends CreateSpotDa
 }
 export interface CreateSpotDatafeedSubscriptionCommandOutput extends CreateSpotDatafeedSubscriptionResult, __MetadataBearer {
 }
-/**
- * <p>Creates a data feed for Spot Instances, enabling you to view Spot Instance usage logs.
- * 				You can create one data feed per Amazon Web Services account. For more information, see
- *         <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-data-feeds.html">Spot Instance data feed</a>
- *         in the <i>Amazon EC2 User Guide for Linux Instances</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateSpotDatafeedSubscriptionCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateSpotDatafeedSubscriptionCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateSpotDatafeedSubscriptionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateSpotDatafeedSubscriptionCommandInput} for command's `input` shape.
- * @see {@link CreateSpotDatafeedSubscriptionCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateSpotDatafeedSubscriptionCommand extends $Command<CreateSpotDatafeedSubscriptionCommandInput, CreateSpotDatafeedSubscriptionCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateSpotDatafeedSubscriptionCommandInput;
     constructor(input: CreateSpotDatafeedSubscriptionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSpotDatafeedSubscriptionCommandInput, CreateSpotDatafeedSubscriptionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface CreateStoreImageTaskCommandInput extends CreateStoreImageTaskRe
 }
 export interface CreateStoreImageTaskCommandOutput extends CreateStoreImageTaskResult, __MetadataBearer {
 }
-/**
- * <p>Stores an AMI as a single object in an Amazon S3 bucket.</p>
- *          <p>To use this API, you must have the required permissions. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-store-restore.html#ami-s3-permissions">Permissions for storing and restoring AMIs using Amazon S3</a> in the
- *         <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-store-restore.html">Store and restore an AMI using
- *     	Amazon S3</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateStoreImageTaskCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateStoreImageTaskCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateStoreImageTaskCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateStoreImageTaskCommandInput} for command's `input` shape.
- * @see {@link CreateStoreImageTaskCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateStoreImageTaskCommand extends $Command<CreateStoreImageTaskCommandInput, CreateStoreImageTaskCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateStoreImageTaskCommandInput;
     constructor(input: CreateStoreImageTaskCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateStoreImageTaskCommandInput, CreateStoreImageTaskCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface CreateSubnetCidrReservationCommandInput extends CreateSubnetCid
 }
 export interface CreateSubnetCidrReservationCommandOutput extends CreateSubnetCidrReservationResult, __MetadataBearer {
 }
-/**
- * <p>Creates a subnet CIDR reservation. For information about subnet CIDR reservations, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/subnet-cidr-reservation.html">Subnet CIDR reservations</a> in the <i>Amazon Virtual Private Cloud User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateSubnetCidrReservationCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateSubnetCidrReservationCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateSubnetCidrReservationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateSubnetCidrReservationCommandInput} for command's `input` shape.
- * @see {@link CreateSubnetCidrReservationCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateSubnetCidrReservationCommand extends $Command<CreateSubnetCidrReservationCommandInput, CreateSubnetCidrReservationCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateSubnetCidrReservationCommandInput;
     constructor(input: CreateSubnetCidrReservationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSubnetCidrReservationCommandInput, CreateSubnetCidrReservationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,46 +6,11 @@ export interface CreateSubnetCommandInput extends CreateSubnetRequest {
 }
 export interface CreateSubnetCommandOutput extends CreateSubnetResult, __MetadataBearer {
 }
-/**
- * <p>Creates a subnet in a specified VPC.</p>
- *         <p>You must specify an IPv4 CIDR block for the subnet. After you create a subnet, you
- *             can't change its CIDR block. The allowed block size is between a /16 netmask (65,536 IP
- *             addresses) and /28 netmask (16 IP addresses). The CIDR block must not overlap with the
- *             CIDR block of an existing subnet in the VPC.</p>
- *         <p>If you've associated an IPv6 CIDR block with your VPC, you can create a subnet with an
- *             IPv6 CIDR block that uses a /64 prefix length. </p>
- *         <important>
- *             <p>Amazon Web Services reserves both the first four and the last IPv4 address in each subnet's CIDR
- *                 block. They're not available for use.</p>
- *         </important>
- *         <p>If you add more than one subnet to a VPC, they're set up in a star topology with a
- *             logical router in the middle.</p>
- *         <p>When you stop an instance in a subnet, it retains its private IPv4 address. It's
- *             therefore possible to have a subnet with no running instances (they're all stopped), but
- *             no remaining IP addresses available.</p>
- *         <p>For more information about subnets, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html">Your VPC and subnets</a> in the
- *                 <i>Amazon Virtual Private Cloud User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateSubnetCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateSubnetCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateSubnetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateSubnetCommandInput} for command's `input` shape.
- * @see {@link CreateSubnetCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateSubnetCommand extends $Command<CreateSubnetCommandInput, CreateSubnetCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateSubnetCommandInput;
     constructor(input: CreateSubnetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSubnetCommandInput, CreateSubnetCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,38 +6,11 @@ export interface CreateTagsCommandInput extends CreateTagsRequest {
 }
 export interface CreateTagsCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Adds or overwrites only the specified tags for the specified Amazon EC2 resource or
- *          resources. When you specify an existing tag key, the value is overwritten with
- *          the new value. Each resource can have a maximum of 50 tags. Each tag consists of a key and
- *          optional value. Tag keys must be unique per resource.</p>
- *
- *          <p>For more information about tags, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html">Tagging Your Resources</a> in the
- *             <i>Amazon Elastic Compute Cloud User Guide</i>. For more information about
- *          creating IAM policies that control users' access to resources based on tags, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-supported-iam-actions-resources.html">Supported
- *             Resource-Level Permissions for Amazon EC2 API Actions</a> in the <i>Amazon
- *             Elastic Compute Cloud User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateTagsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateTagsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateTagsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateTagsCommandInput} for command's `input` shape.
- * @see {@link CreateTagsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateTagsCommand extends $Command<CreateTagsCommandInput, CreateTagsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateTagsCommandInput;
     constructor(input: CreateTagsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTagsCommandInput, CreateTagsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface CreateTrafficMirrorFilterCommandInput extends CreateTrafficMirr
 }
 export interface CreateTrafficMirrorFilterCommandOutput extends CreateTrafficMirrorFilterResult, __MetadataBearer {
 }
-/**
- * <p>Creates a Traffic Mirror filter.</p>
- *          <p>A Traffic Mirror filter is a set of rules that defines the traffic to mirror.</p>
- *          <p>By default, no traffic is mirrored. To mirror traffic, use <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateTrafficMirrorFilterRule.htm">CreateTrafficMirrorFilterRule</a> to add Traffic Mirror rules to the filter. The rules you
- *          add define what traffic gets mirrored. You can also use <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyTrafficMirrorFilterNetworkServices.html">ModifyTrafficMirrorFilterNetworkServices</a> to mirror supported network services.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateTrafficMirrorFilterCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateTrafficMirrorFilterCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateTrafficMirrorFilterCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateTrafficMirrorFilterCommandInput} for command's `input` shape.
- * @see {@link CreateTrafficMirrorFilterCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateTrafficMirrorFilterCommand extends $Command<CreateTrafficMirrorFilterCommandInput, CreateTrafficMirrorFilterCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateTrafficMirrorFilterCommandInput;
     constructor(input: CreateTrafficMirrorFilterCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTrafficMirrorFilterCommandInput, CreateTrafficMirrorFilterCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface CreateTrafficMirrorFilterRuleCommandInput extends CreateTraffic
 }
 export interface CreateTrafficMirrorFilterRuleCommandOutput extends CreateTrafficMirrorFilterRuleResult, __MetadataBearer {
 }
-/**
- * <p>Creates a Traffic Mirror filter rule. </p>
- *          <p>A Traffic Mirror rule defines the Traffic Mirror source traffic to mirror.</p>
- *          <p>You need the Traffic Mirror filter ID when you create the rule.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateTrafficMirrorFilterRuleCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateTrafficMirrorFilterRuleCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateTrafficMirrorFilterRuleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateTrafficMirrorFilterRuleCommandInput} for command's `input` shape.
- * @see {@link CreateTrafficMirrorFilterRuleCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateTrafficMirrorFilterRuleCommand extends $Command<CreateTrafficMirrorFilterRuleCommandInput, CreateTrafficMirrorFilterRuleCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateTrafficMirrorFilterRuleCommandInput;
     constructor(input: CreateTrafficMirrorFilterRuleCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTrafficMirrorFilterRuleCommandInput, CreateTrafficMirrorFilterRuleCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface CreateTrafficMirrorSessionCommandInput extends CreateTrafficMir
 }
 export interface CreateTrafficMirrorSessionCommandOutput extends CreateTrafficMirrorSessionResult, __MetadataBearer {
 }
-/**
- * <p>Creates a Traffic Mirror session.</p>
- *          <p>A Traffic Mirror session actively copies packets from a Traffic Mirror source to a Traffic Mirror target. Create a filter, and then assign it
- *          to the session to define a subset of the traffic to mirror, for example all TCP
- *          traffic.</p>
- *          <p>The Traffic Mirror source and the Traffic Mirror target (monitoring appliances) can be in the same VPC, or in a different VPC connected via VPC peering or a transit gateway. </p>
- *          <p>By default, no traffic is mirrored. Use <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateTrafficMirrorFilter.htm">CreateTrafficMirrorFilter</a> to
- *          create filter rules that specify the traffic to mirror.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateTrafficMirrorSessionCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateTrafficMirrorSessionCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateTrafficMirrorSessionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateTrafficMirrorSessionCommandInput} for command's `input` shape.
- * @see {@link CreateTrafficMirrorSessionCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateTrafficMirrorSessionCommand extends $Command<CreateTrafficMirrorSessionCommandInput, CreateTrafficMirrorSessionCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateTrafficMirrorSessionCommandInput;
     constructor(input: CreateTrafficMirrorSessionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTrafficMirrorSessionCommandInput, CreateTrafficMirrorSessionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface CreateTrafficMirrorTargetCommandInput extends CreateTrafficMirr
 }
 export interface CreateTrafficMirrorTargetCommandOutput extends CreateTrafficMirrorTargetResult, __MetadataBearer {
 }
-/**
- * <p>Creates a target for your Traffic Mirror session.</p>
- *          <p>A Traffic Mirror target is the destination for mirrored traffic. The Traffic Mirror source and
- *          the Traffic Mirror target (monitoring appliances) can be in the same VPC, or in
- *          different VPCs connected via VPC peering or a transit gateway.</p>
- *          <p>A Traffic Mirror target can be a network interface, or a Network Load Balancer.</p>
- *          <p>To use the target in a Traffic Mirror session, use  <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateTrafficMirrorSession.htm">CreateTrafficMirrorSession</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateTrafficMirrorTargetCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateTrafficMirrorTargetCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateTrafficMirrorTargetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateTrafficMirrorTargetCommandInput} for command's `input` shape.
- * @see {@link CreateTrafficMirrorTargetCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateTrafficMirrorTargetCommand extends $Command<CreateTrafficMirrorTargetCommandInput, CreateTrafficMirrorTargetCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateTrafficMirrorTargetCommandInput;
     constructor(input: CreateTrafficMirrorTargetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTrafficMirrorTargetCommandInput, CreateTrafficMirrorTargetCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,41 +6,11 @@ export interface CreateTransitGatewayCommandInput extends CreateTransitGatewayRe
 }
 export interface CreateTransitGatewayCommandOutput extends CreateTransitGatewayResult, __MetadataBearer {
 }
-/**
- * <p>Creates a transit gateway.</p>
- *          <p>You can use a transit gateway to interconnect your virtual private clouds (VPC) and on-premises networks.
- *           After the transit gateway enters the <code>available</code> state, you can attach your VPCs and VPN
- *           connections to the transit gateway.</p>
- *          <p>To attach your VPCs, use <a>CreateTransitGatewayVpcAttachment</a>.</p>
- *          <p>To attach a VPN connection, use <a>CreateCustomerGateway</a> to create a customer
- *          gateway and specify the ID of the customer gateway and the ID of the transit gateway in a call to
- *          <a>CreateVpnConnection</a>.</p>
- *          <p>When you create a transit gateway, we create a default transit gateway route table and use it as the default association route table
- *          and the default propagation route table. You can use <a>CreateTransitGatewayRouteTable</a> to create
- *          additional transit gateway route tables. If you disable automatic route propagation, we do not create a default transit gateway route table.
- *          You can use <a>EnableTransitGatewayRouteTablePropagation</a> to propagate routes from a resource
- *          attachment to a transit gateway route table. If you disable automatic associations, you can use <a>AssociateTransitGatewayRouteTable</a> to associate a resource attachment with a transit gateway route table.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateTransitGatewayCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateTransitGatewayCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateTransitGatewayCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateTransitGatewayCommandInput} for command's `input` shape.
- * @see {@link CreateTransitGatewayCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateTransitGatewayCommand extends $Command<CreateTransitGatewayCommandInput, CreateTransitGatewayCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateTransitGatewayCommandInput;
     constructor(input: CreateTransitGatewayCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTransitGatewayCommandInput, CreateTransitGatewayCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface CreateTransitGatewayConnectCommandInput extends CreateTransitGa
 }
 export interface CreateTransitGatewayConnectCommandOutput extends CreateTransitGatewayConnectResult, __MetadataBearer {
 }
-/**
- * <p>Creates a Connect attachment from a specified transit gateway attachment. A Connect attachment is a GRE-based tunnel attachment that you can use to establish a connection between a transit gateway and an appliance.</p>
- *         <p>A Connect attachment uses an existing VPC or Amazon Web Services Direct Connect attachment as the underlying transport mechanism.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateTransitGatewayConnectCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateTransitGatewayConnectCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateTransitGatewayConnectCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateTransitGatewayConnectCommandInput} for command's `input` shape.
- * @see {@link CreateTransitGatewayConnectCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateTransitGatewayConnectCommand extends $Command<CreateTransitGatewayConnectCommandInput, CreateTransitGatewayConnectCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateTransitGatewayConnectCommandInput;
     constructor(input: CreateTransitGatewayConnectCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTransitGatewayConnectCommandInput, CreateTransitGatewayConnectCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface CreateTransitGatewayConnectPeerCommandInput extends CreateTrans
 }
 export interface CreateTransitGatewayConnectPeerCommandOutput extends CreateTransitGatewayConnectPeerResult, __MetadataBearer {
 }
-/**
- * <p>Creates a Connect peer for a specified transit gateway Connect attachment between a
- *             transit gateway and an appliance.</p>
- *         <p>The peer address and transit gateway address must be the same IP address family (IPv4 or IPv6).</p>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/tgw/tgw-connect.html#tgw-connect-peer">Connect peers</a> in the <i>Transit Gateways Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateTransitGatewayConnectPeerCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateTransitGatewayConnectPeerCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateTransitGatewayConnectPeerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateTransitGatewayConnectPeerCommandInput} for command's `input` shape.
- * @see {@link CreateTransitGatewayConnectPeerCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateTransitGatewayConnectPeerCommand extends $Command<CreateTransitGatewayConnectPeerCommandInput, CreateTransitGatewayConnectPeerCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateTransitGatewayConnectPeerCommandInput;
     constructor(input: CreateTransitGatewayConnectPeerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTransitGatewayConnectPeerCommandInput, CreateTransitGatewayConnectPeerCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface CreateTransitGatewayMulticastDomainCommandInput extends CreateT
 }
 export interface CreateTransitGatewayMulticastDomainCommandOutput extends CreateTransitGatewayMulticastDomainResult, __MetadataBearer {
 }
-/**
- * <p>Creates a multicast domain using the specified transit gateway.</p>
- *         <p>The transit gateway  must be in the available state before you create a domain. Use <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeTransitGateways.html">DescribeTransitGateways</a> to see the state of transit gateway.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateTransitGatewayMulticastDomainCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateTransitGatewayMulticastDomainCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateTransitGatewayMulticastDomainCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateTransitGatewayMulticastDomainCommandInput} for command's `input` shape.
- * @see {@link CreateTransitGatewayMulticastDomainCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateTransitGatewayMulticastDomainCommand extends $Command<CreateTransitGatewayMulticastDomainCommandInput, CreateTransitGatewayMulticastDomainCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateTransitGatewayMulticastDomainCommandInput;
     constructor(input: CreateTransitGatewayMulticastDomainCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTransitGatewayMulticastDomainCommandInput, CreateTransitGatewayMulticastDomainCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface CreateTransitGatewayPeeringAttachmentCommandInput extends Creat
 }
 export interface CreateTransitGatewayPeeringAttachmentCommandOutput extends CreateTransitGatewayPeeringAttachmentResult, __MetadataBearer {
 }
-/**
- * <p>Requests a transit gateway peering attachment between the specified transit gateway
- *             (requester) and a peer transit gateway (accepter). The transit gateways must be in
- *             different Regions. The peer transit gateway can be in your account or a different
- *             Amazon Web Services account.</p>
- *         <p>After you create the peering attachment, the owner of the accepter transit gateway
- *             must accept the attachment request.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateTransitGatewayPeeringAttachmentCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateTransitGatewayPeeringAttachmentCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateTransitGatewayPeeringAttachmentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateTransitGatewayPeeringAttachmentCommandInput} for command's `input` shape.
- * @see {@link CreateTransitGatewayPeeringAttachmentCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateTransitGatewayPeeringAttachmentCommand extends $Command<CreateTransitGatewayPeeringAttachmentCommandInput, CreateTransitGatewayPeeringAttachmentCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateTransitGatewayPeeringAttachmentCommandInput;
     constructor(input: CreateTransitGatewayPeeringAttachmentCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTransitGatewayPeeringAttachmentCommandInput, CreateTransitGatewayPeeringAttachmentCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface CreateTransitGatewayPrefixListReferenceCommandInput extends Cre
 }
 export interface CreateTransitGatewayPrefixListReferenceCommandOutput extends CreateTransitGatewayPrefixListReferenceResult, __MetadataBearer {
 }
-/**
- * <p>Creates a reference (route) to a prefix list in a specified transit gateway route table.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateTransitGatewayPrefixListReferenceCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateTransitGatewayPrefixListReferenceCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateTransitGatewayPrefixListReferenceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateTransitGatewayPrefixListReferenceCommandInput} for command's `input` shape.
- * @see {@link CreateTransitGatewayPrefixListReferenceCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateTransitGatewayPrefixListReferenceCommand extends $Command<CreateTransitGatewayPrefixListReferenceCommandInput, CreateTransitGatewayPrefixListReferenceCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateTransitGatewayPrefixListReferenceCommandInput;
     constructor(input: CreateTransitGatewayPrefixListReferenceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTransitGatewayPrefixListReferenceCommandInput, CreateTransitGatewayPrefixListReferenceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface CreateTransitGatewayRouteCommandInput extends CreateTransitGate
 }
 export interface CreateTransitGatewayRouteCommandOutput extends CreateTransitGatewayRouteResult, __MetadataBearer {
 }
-/**
- * <p>Creates a static route for the specified transit gateway route table.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateTransitGatewayRouteCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateTransitGatewayRouteCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateTransitGatewayRouteCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateTransitGatewayRouteCommandInput} for command's `input` shape.
- * @see {@link CreateTransitGatewayRouteCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateTransitGatewayRouteCommand extends $Command<CreateTransitGatewayRouteCommandInput, CreateTransitGatewayRouteCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateTransitGatewayRouteCommandInput;
     constructor(input: CreateTransitGatewayRouteCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTransitGatewayRouteCommandInput, CreateTransitGatewayRouteCommandOutput>;
     private serialize;
     private deserialize;