@aws-sdk/client-ec2 3.36.0 → 3.39.0

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

@@ -1,34 +1,16 @@
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
-import { DescribeTrafficMirrorSessionsRequest, DescribeTrafficMirrorSessionsResult } from "../models/models_3";
+import { DescribeTrafficMirrorSessionsRequest, DescribeTrafficMirrorSessionsResult } from "../models/models_4";
 export interface DescribeTrafficMirrorSessionsCommandInput extends DescribeTrafficMirrorSessionsRequest {
 }
 export interface DescribeTrafficMirrorSessionsCommandOutput extends DescribeTrafficMirrorSessionsResult, __MetadataBearer {
 }
-/**
- * <p>Describes one or more Traffic Mirror sessions. By default, all Traffic Mirror sessions are described. Alternatively, you can filter the results.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeTrafficMirrorSessionsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeTrafficMirrorSessionsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeTrafficMirrorSessionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeTrafficMirrorSessionsCommandInput} for command's `input` shape.
- * @see {@link DescribeTrafficMirrorSessionsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeTrafficMirrorSessionsCommand extends $Command<DescribeTrafficMirrorSessionsCommandInput, DescribeTrafficMirrorSessionsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeTrafficMirrorSessionsCommandInput;
     constructor(input: DescribeTrafficMirrorSessionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTrafficMirrorSessionsCommandInput, DescribeTrafficMirrorSessionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,34 +1,16 @@
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
-import { DescribeTrafficMirrorTargetsRequest, DescribeTrafficMirrorTargetsResult } from "../models/models_3";
+import { DescribeTrafficMirrorTargetsRequest, DescribeTrafficMirrorTargetsResult } from "../models/models_4";
 export interface DescribeTrafficMirrorTargetsCommandInput extends DescribeTrafficMirrorTargetsRequest {
 }
 export interface DescribeTrafficMirrorTargetsCommandOutput extends DescribeTrafficMirrorTargetsResult, __MetadataBearer {
 }
-/**
- * <p>Information about one or more Traffic Mirror targets.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeTrafficMirrorTargetsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeTrafficMirrorTargetsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeTrafficMirrorTargetsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeTrafficMirrorTargetsCommandInput} for command's `input` shape.
- * @see {@link DescribeTrafficMirrorTargetsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeTrafficMirrorTargetsCommand extends $Command<DescribeTrafficMirrorTargetsCommandInput, DescribeTrafficMirrorTargetsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeTrafficMirrorTargetsCommandInput;
     constructor(input: DescribeTrafficMirrorTargetsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTrafficMirrorTargetsCommandInput, DescribeTrafficMirrorTargetsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,35 +1,16 @@
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
-import { DescribeTransitGatewayAttachmentsRequest, DescribeTransitGatewayAttachmentsResult } from "../models/models_3";
+import { DescribeTransitGatewayAttachmentsRequest, DescribeTransitGatewayAttachmentsResult } from "../models/models_4";
 export interface DescribeTransitGatewayAttachmentsCommandInput extends DescribeTransitGatewayAttachmentsRequest {
 }
 export interface DescribeTransitGatewayAttachmentsCommandOutput extends DescribeTransitGatewayAttachmentsResult, __MetadataBearer {
 }
-/**
- * <p>Describes one or more attachments between resources and transit gateways. By default, all attachments are described.
- *          Alternatively, you can filter the results by attachment ID, attachment state, resource ID, or resource owner.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeTransitGatewayAttachmentsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeTransitGatewayAttachmentsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeTransitGatewayAttachmentsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeTransitGatewayAttachmentsCommandInput} for command's `input` shape.
- * @see {@link DescribeTransitGatewayAttachmentsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeTransitGatewayAttachmentsCommand extends $Command<DescribeTransitGatewayAttachmentsCommandInput, DescribeTransitGatewayAttachmentsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeTransitGatewayAttachmentsCommandInput;
     constructor(input: DescribeTransitGatewayAttachmentsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTransitGatewayAttachmentsCommandInput, DescribeTransitGatewayAttachmentsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,34 +1,16 @@
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
-import { DescribeTransitGatewayConnectPeersRequest, DescribeTransitGatewayConnectPeersResult } from "../models/models_3";
+import { DescribeTransitGatewayConnectPeersRequest, DescribeTransitGatewayConnectPeersResult } from "../models/models_4";
 export interface DescribeTransitGatewayConnectPeersCommandInput extends DescribeTransitGatewayConnectPeersRequest {
 }
 export interface DescribeTransitGatewayConnectPeersCommandOutput extends DescribeTransitGatewayConnectPeersResult, __MetadataBearer {
 }
-/**
- * <p>Describes one or more Connect peers.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeTransitGatewayConnectPeersCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeTransitGatewayConnectPeersCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeTransitGatewayConnectPeersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeTransitGatewayConnectPeersCommandInput} for command's `input` shape.
- * @see {@link DescribeTransitGatewayConnectPeersCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeTransitGatewayConnectPeersCommand extends $Command<DescribeTransitGatewayConnectPeersCommandInput, DescribeTransitGatewayConnectPeersCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeTransitGatewayConnectPeersCommandInput;
     constructor(input: DescribeTransitGatewayConnectPeersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTransitGatewayConnectPeersCommandInput, DescribeTransitGatewayConnectPeersCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,34 +1,16 @@
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
-import { DescribeTransitGatewayConnectsRequest, DescribeTransitGatewayConnectsResult } from "../models/models_3";
+import { DescribeTransitGatewayConnectsRequest, DescribeTransitGatewayConnectsResult } from "../models/models_4";
 export interface DescribeTransitGatewayConnectsCommandInput extends DescribeTransitGatewayConnectsRequest {
 }
 export interface DescribeTransitGatewayConnectsCommandOutput extends DescribeTransitGatewayConnectsResult, __MetadataBearer {
 }
-/**
- * <p>Describes one or more Connect attachments.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeTransitGatewayConnectsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeTransitGatewayConnectsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeTransitGatewayConnectsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeTransitGatewayConnectsCommandInput} for command's `input` shape.
- * @see {@link DescribeTransitGatewayConnectsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeTransitGatewayConnectsCommand extends $Command<DescribeTransitGatewayConnectsCommandInput, DescribeTransitGatewayConnectsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeTransitGatewayConnectsCommandInput;
     constructor(input: DescribeTransitGatewayConnectsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTransitGatewayConnectsCommandInput, DescribeTransitGatewayConnectsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,34 +1,16 @@
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
-import { DescribeTransitGatewayMulticastDomainsRequest, DescribeTransitGatewayMulticastDomainsResult } from "../models/models_3";
+import { DescribeTransitGatewayMulticastDomainsRequest, DescribeTransitGatewayMulticastDomainsResult } from "../models/models_4";
 export interface DescribeTransitGatewayMulticastDomainsCommandInput extends DescribeTransitGatewayMulticastDomainsRequest {
 }
 export interface DescribeTransitGatewayMulticastDomainsCommandOutput extends DescribeTransitGatewayMulticastDomainsResult, __MetadataBearer {
 }
-/**
- * <p>Describes one or more transit gateway multicast domains.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeTransitGatewayMulticastDomainsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeTransitGatewayMulticastDomainsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeTransitGatewayMulticastDomainsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeTransitGatewayMulticastDomainsCommandInput} for command's `input` shape.
- * @see {@link DescribeTransitGatewayMulticastDomainsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeTransitGatewayMulticastDomainsCommand extends $Command<DescribeTransitGatewayMulticastDomainsCommandInput, DescribeTransitGatewayMulticastDomainsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeTransitGatewayMulticastDomainsCommandInput;
     constructor(input: DescribeTransitGatewayMulticastDomainsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTransitGatewayMulticastDomainsCommandInput, DescribeTransitGatewayMulticastDomainsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,34 +1,16 @@
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
-import { DescribeTransitGatewayPeeringAttachmentsRequest, DescribeTransitGatewayPeeringAttachmentsResult } from "../models/models_3";
+import { DescribeTransitGatewayPeeringAttachmentsRequest, DescribeTransitGatewayPeeringAttachmentsResult } from "../models/models_4";
 export interface DescribeTransitGatewayPeeringAttachmentsCommandInput extends DescribeTransitGatewayPeeringAttachmentsRequest {
 }
 export interface DescribeTransitGatewayPeeringAttachmentsCommandOutput extends DescribeTransitGatewayPeeringAttachmentsResult, __MetadataBearer {
 }
-/**
- * <p>Describes your transit gateway peering attachments.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeTransitGatewayPeeringAttachmentsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeTransitGatewayPeeringAttachmentsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeTransitGatewayPeeringAttachmentsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeTransitGatewayPeeringAttachmentsCommandInput} for command's `input` shape.
- * @see {@link DescribeTransitGatewayPeeringAttachmentsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeTransitGatewayPeeringAttachmentsCommand extends $Command<DescribeTransitGatewayPeeringAttachmentsCommandInput, DescribeTransitGatewayPeeringAttachmentsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeTransitGatewayPeeringAttachmentsCommandInput;
     constructor(input: DescribeTransitGatewayPeeringAttachmentsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTransitGatewayPeeringAttachmentsCommandInput, DescribeTransitGatewayPeeringAttachmentsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,35 +1,16 @@
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
-import { DescribeTransitGatewayRouteTablesRequest, DescribeTransitGatewayRouteTablesResult } from "../models/models_3";
+import { DescribeTransitGatewayRouteTablesRequest, DescribeTransitGatewayRouteTablesResult } from "../models/models_4";
 export interface DescribeTransitGatewayRouteTablesCommandInput extends DescribeTransitGatewayRouteTablesRequest {
 }
 export interface DescribeTransitGatewayRouteTablesCommandOutput extends DescribeTransitGatewayRouteTablesResult, __MetadataBearer {
 }
-/**
- * <p>Describes one or more transit gateway route tables. By default, all transit gateway route tables are described.
- *          Alternatively, you can filter the results.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeTransitGatewayRouteTablesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeTransitGatewayRouteTablesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeTransitGatewayRouteTablesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeTransitGatewayRouteTablesCommandInput} for command's `input` shape.
- * @see {@link DescribeTransitGatewayRouteTablesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeTransitGatewayRouteTablesCommand extends $Command<DescribeTransitGatewayRouteTablesCommandInput, DescribeTransitGatewayRouteTablesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeTransitGatewayRouteTablesCommandInput;
     constructor(input: DescribeTransitGatewayRouteTablesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTransitGatewayRouteTablesCommandInput, DescribeTransitGatewayRouteTablesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,35 +1,16 @@
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
-import { DescribeTransitGatewayVpcAttachmentsRequest, DescribeTransitGatewayVpcAttachmentsResult } from "../models/models_3";
+import { DescribeTransitGatewayVpcAttachmentsRequest, DescribeTransitGatewayVpcAttachmentsResult } from "../models/models_4";
 export interface DescribeTransitGatewayVpcAttachmentsCommandInput extends DescribeTransitGatewayVpcAttachmentsRequest {
 }
 export interface DescribeTransitGatewayVpcAttachmentsCommandOutput extends DescribeTransitGatewayVpcAttachmentsResult, __MetadataBearer {
 }
-/**
- * <p>Describes one or more VPC attachments. By default, all VPC attachments are described.
- *          Alternatively, you can filter the results.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeTransitGatewayVpcAttachmentsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeTransitGatewayVpcAttachmentsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeTransitGatewayVpcAttachmentsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeTransitGatewayVpcAttachmentsCommandInput} for command's `input` shape.
- * @see {@link DescribeTransitGatewayVpcAttachmentsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeTransitGatewayVpcAttachmentsCommand extends $Command<DescribeTransitGatewayVpcAttachmentsCommandInput, DescribeTransitGatewayVpcAttachmentsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeTransitGatewayVpcAttachmentsCommandInput;
     constructor(input: DescribeTransitGatewayVpcAttachmentsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTransitGatewayVpcAttachmentsCommandInput, DescribeTransitGatewayVpcAttachmentsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,35 +1,16 @@
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
-import { DescribeTransitGatewaysRequest, DescribeTransitGatewaysResult } from "../models/models_3";
+import { DescribeTransitGatewaysRequest, DescribeTransitGatewaysResult } from "../models/models_4";
 export interface DescribeTransitGatewaysCommandInput extends DescribeTransitGatewaysRequest {
 }
 export interface DescribeTransitGatewaysCommandOutput extends DescribeTransitGatewaysResult, __MetadataBearer {
 }
-/**
- * <p>Describes one or more transit gateways. By default, all transit gateways are described. Alternatively, you can
- *          filter the results.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeTransitGatewaysCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeTransitGatewaysCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeTransitGatewaysCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeTransitGatewaysCommandInput} for command's `input` shape.
- * @see {@link DescribeTransitGatewaysCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeTransitGatewaysCommand extends $Command<DescribeTransitGatewaysCommandInput, DescribeTransitGatewaysCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeTransitGatewaysCommandInput;
     constructor(input: DescribeTransitGatewaysCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTransitGatewaysCommandInput, DescribeTransitGatewaysCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,38 +1,16 @@
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
-import { DescribeTrunkInterfaceAssociationsRequest, DescribeTrunkInterfaceAssociationsResult } from "../models/models_3";
+import { DescribeTrunkInterfaceAssociationsRequest, DescribeTrunkInterfaceAssociationsResult } from "../models/models_4";
 export interface DescribeTrunkInterfaceAssociationsCommandInput extends DescribeTrunkInterfaceAssociationsRequest {
 }
 export interface DescribeTrunkInterfaceAssociationsCommandOutput extends DescribeTrunkInterfaceAssociationsResult, __MetadataBearer {
 }
-/**
- * <note>
- *             <p>This API action is currently in <b>limited preview only</b>.
- *                 If you are interested in using this feature, contact your account manager.</p>
- *         </note>
- *         <p>Describes one or more network interface trunk associations.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeTrunkInterfaceAssociationsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeTrunkInterfaceAssociationsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeTrunkInterfaceAssociationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeTrunkInterfaceAssociationsCommandInput} for command's `input` shape.
- * @see {@link DescribeTrunkInterfaceAssociationsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeTrunkInterfaceAssociationsCommand extends $Command<DescribeTrunkInterfaceAssociationsCommandInput, DescribeTrunkInterfaceAssociationsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeTrunkInterfaceAssociationsCommandInput;
     constructor(input: DescribeTrunkInterfaceAssociationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTrunkInterfaceAssociationsCommandInput, DescribeTrunkInterfaceAssociationsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,36 +1,16 @@
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
-import { DescribeVolumeAttributeRequest, DescribeVolumeAttributeResult } from "../models/models_3";
+import { DescribeVolumeAttributeRequest, DescribeVolumeAttributeResult } from "../models/models_4";
 export interface DescribeVolumeAttributeCommandInput extends DescribeVolumeAttributeRequest {
 }
 export interface DescribeVolumeAttributeCommandOutput extends DescribeVolumeAttributeResult, __MetadataBearer {
 }
-/**
- * <p>Describes the specified attribute of the specified volume. You can specify only one
- *       attribute at a time.</p>
- *          <p>For more information about EBS volumes, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumes.html">Amazon EBS volumes</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, DescribeVolumeAttributeCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeVolumeAttributeCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeVolumeAttributeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeVolumeAttributeCommandInput} for command's `input` shape.
- * @see {@link DescribeVolumeAttributeCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeVolumeAttributeCommand extends $Command<DescribeVolumeAttributeCommandInput, DescribeVolumeAttributeCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeVolumeAttributeCommandInput;
     constructor(input: DescribeVolumeAttributeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeVolumeAttributeCommandInput, DescribeVolumeAttributeCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,62 +6,11 @@ export interface DescribeVolumeStatusCommandInput extends DescribeVolumeStatusRe
 }
 export interface DescribeVolumeStatusCommandOutput extends DescribeVolumeStatusResult, __MetadataBearer {
 }
-/**
- * <p>Describes the status of the specified volumes. Volume status provides the result of the
- *       checks performed on your volumes to determine events that can impair the performance of your
- *       volumes. The performance of a volume can be affected if an issue occurs on the volume's
- *       underlying host. If the volume's underlying host experiences a power outage or system issue,
- *       after the system is restored, there could be data inconsistencies on the volume. Volume events
- *       notify you if this occurs. Volume actions notify you if any action needs to be taken in
- *       response to the event.</p>
- *          <p>The <code>DescribeVolumeStatus</code> operation provides the following information about
- *       the specified volumes:</p>
- *          <p>
- *             <i>Status</i>: Reflects the current status of the volume. The possible
- *       values are <code>ok</code>, <code>impaired</code> , <code>warning</code>, or
- *         <code>insufficient-data</code>. If all checks pass, the overall status of the volume is
- *         <code>ok</code>. If the check fails, the overall status is <code>impaired</code>. If the
- *       status is <code>insufficient-data</code>, then the checks might still be taking place on your
- *       volume at the time. We recommend that you retry the request. For more information about volume
- *       status, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-volume-status.html">Monitor the status of your volumes</a> in the
- *       <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
- *          <p>
- *             <i>Events</i>: Reflect the cause of a volume status and might require you to
- *       take action. For example, if your volume returns an <code>impaired</code> status, then the
- *       volume event might be <code>potential-data-inconsistency</code>. This means that your volume
- *       has been affected by an issue with the underlying host, has all I/O operations disabled, and
- *       might have inconsistent data.</p>
- *          <p>
- *             <i>Actions</i>: Reflect the actions you might have to take in response to an
- *       event. For example, if the status of the volume is <code>impaired</code> and the volume event
- *       shows <code>potential-data-inconsistency</code>, then the action shows
- *         <code>enable-volume-io</code>. This means that you may want to enable the I/O operations for
- *       the volume by calling the <a>EnableVolumeIO</a> action and then check the volume
- *       for data consistency.</p>
- *          <p>Volume status is based on the volume status checks, and does not reflect the volume state.
- *       Therefore, volume status does not indicate volumes in the <code>error</code> state (for
- *       example, when a volume is incapable of accepting I/O.)</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeVolumeStatusCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeVolumeStatusCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeVolumeStatusCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeVolumeStatusCommandInput} for command's `input` shape.
- * @see {@link DescribeVolumeStatusCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeVolumeStatusCommand extends $Command<DescribeVolumeStatusCommandInput, DescribeVolumeStatusCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeVolumeStatusCommandInput;
     constructor(input: DescribeVolumeStatusCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeVolumeStatusCommandInput, DescribeVolumeStatusCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,36 +6,11 @@ export interface DescribeVolumesCommandInput extends DescribeVolumesRequest {
 }
 export interface DescribeVolumesCommandOutput extends DescribeVolumesResult, __MetadataBearer {
 }
-/**
- * <p>Describes the specified EBS volumes or all of your EBS volumes.</p>
- *          <p>If you are describing a long list of volumes, we recommend that you paginate the output to make the list
- *       more manageable. The <code>MaxResults</code> parameter sets the maximum number of results
- *       returned in a single page. If the list of results exceeds your <code>MaxResults</code> value,
- *       then that number of results is returned along with a <code>NextToken</code> value that can be
- *       passed to a subsequent <code>DescribeVolumes</code> request to retrieve the remaining
- *       results.</p>
- *          <p>For more information about EBS volumes, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumes.html">Amazon EBS volumes</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, DescribeVolumesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeVolumesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeVolumesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeVolumesCommandInput} for command's `input` shape.
- * @see {@link DescribeVolumesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeVolumesCommand extends $Command<DescribeVolumesCommandInput, DescribeVolumesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeVolumesCommandInput;
     constructor(input: DescribeVolumesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeVolumesCommandInput, DescribeVolumesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface DescribeVolumesModificationsCommandInput extends DescribeVolume
 }
 export interface DescribeVolumesModificationsCommandOutput extends DescribeVolumesModificationsResult, __MetadataBearer {
 }
-/**
- * <p>Describes the most recent volume modification request for the specified EBS volumes.</p>
- *          <p>If a volume has never been modified, some information in the output will be null.
- *       If a volume has been modified more than once, the output includes only the most
- *       recent modification request.</p>
- *          <p>You can also use CloudWatch Events to check the status of a modification to an EBS
- *       volume. For information about CloudWatch Events, see the <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/">Amazon CloudWatch Events User Guide</a>. For more information, see
- *         <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-volume-modifications.html">Monitor the progress of volume modifications</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, DescribeVolumesModificationsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeVolumesModificationsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeVolumesModificationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeVolumesModificationsCommandInput} for command's `input` shape.
- * @see {@link DescribeVolumesModificationsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeVolumesModificationsCommand extends $Command<DescribeVolumesModificationsCommandInput, DescribeVolumesModificationsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeVolumesModificationsCommandInput;
     constructor(input: DescribeVolumesModificationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeVolumesModificationsCommandInput, DescribeVolumesModificationsCommandOutput>;
     private serialize;
     private deserialize;