@aws-sdk/client-ec2 3.36.0 → 3.39.0

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

@@ -6,29 +6,11 @@ export interface DescribeVpcAttributeCommandInput extends DescribeVpcAttributeRe
 }
 export interface DescribeVpcAttributeCommandOutput extends DescribeVpcAttributeResult, __MetadataBearer {
 }
-/**
- * <p>Describes the specified attribute of the specified VPC. You can specify only one attribute at a time.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeVpcAttributeCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeVpcAttributeCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeVpcAttributeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeVpcAttributeCommandInput} for command's `input` shape.
- * @see {@link DescribeVpcAttributeCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeVpcAttributeCommand extends $Command<DescribeVpcAttributeCommandInput, DescribeVpcAttributeCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeVpcAttributeCommandInput;
     constructor(input: DescribeVpcAttributeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeVpcAttributeCommandInput, DescribeVpcAttributeCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeVpcClassicLinkCommandInput extends DescribeVpcClassicLi
 }
 export interface DescribeVpcClassicLinkCommandOutput extends DescribeVpcClassicLinkResult, __MetadataBearer {
 }
-/**
- * <p>Describes the ClassicLink status of one or more VPCs.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeVpcClassicLinkCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeVpcClassicLinkCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeVpcClassicLinkCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeVpcClassicLinkCommandInput} for command's `input` shape.
- * @see {@link DescribeVpcClassicLinkCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeVpcClassicLinkCommand extends $Command<DescribeVpcClassicLinkCommandInput, DescribeVpcClassicLinkCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeVpcClassicLinkCommandInput;
     constructor(input: DescribeVpcClassicLinkCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeVpcClassicLinkCommandInput, DescribeVpcClassicLinkCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DescribeVpcClassicLinkDnsSupportCommandInput extends DescribeVp
 }
 export interface DescribeVpcClassicLinkDnsSupportCommandOutput extends DescribeVpcClassicLinkDnsSupportResult, __MetadataBearer {
 }
-/**
- * <p>Describes the ClassicLink DNS support status of one or more VPCs. If enabled, the DNS
- *             hostname of a linked EC2-Classic instance resolves to its private IP address when
- *             addressed from an instance in the VPC to which it's linked. Similarly, the DNS hostname
- *             of an instance in a VPC resolves to its private IP address when addressed from a linked
- *             EC2-Classic instance. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/vpc-classiclink.html">ClassicLink</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, DescribeVpcClassicLinkDnsSupportCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeVpcClassicLinkDnsSupportCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeVpcClassicLinkDnsSupportCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeVpcClassicLinkDnsSupportCommandInput} for command's `input` shape.
- * @see {@link DescribeVpcClassicLinkDnsSupportCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeVpcClassicLinkDnsSupportCommand extends $Command<DescribeVpcClassicLinkDnsSupportCommandInput, DescribeVpcClassicLinkDnsSupportCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeVpcClassicLinkDnsSupportCommandInput;
     constructor(input: DescribeVpcClassicLinkDnsSupportCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeVpcClassicLinkDnsSupportCommandInput, DescribeVpcClassicLinkDnsSupportCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeVpcEndpointConnectionNotificationsCommandInput extends
 }
 export interface DescribeVpcEndpointConnectionNotificationsCommandOutput extends DescribeVpcEndpointConnectionNotificationsResult, __MetadataBearer {
 }
-/**
- * <p>Describes the connection notifications for VPC endpoints and VPC endpoint
- *             services.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeVpcEndpointConnectionNotificationsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeVpcEndpointConnectionNotificationsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeVpcEndpointConnectionNotificationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeVpcEndpointConnectionNotificationsCommandInput} for command's `input` shape.
- * @see {@link DescribeVpcEndpointConnectionNotificationsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeVpcEndpointConnectionNotificationsCommand extends $Command<DescribeVpcEndpointConnectionNotificationsCommandInput, DescribeVpcEndpointConnectionNotificationsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeVpcEndpointConnectionNotificationsCommandInput;
     constructor(input: DescribeVpcEndpointConnectionNotificationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeVpcEndpointConnectionNotificationsCommandInput, DescribeVpcEndpointConnectionNotificationsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeVpcEndpointConnectionsCommandInput extends DescribeVpcE
 }
 export interface DescribeVpcEndpointConnectionsCommandOutput extends DescribeVpcEndpointConnectionsResult, __MetadataBearer {
 }
-/**
- * <p>Describes the VPC endpoint connections to your VPC endpoint services, including any
- *             endpoints that are pending your acceptance.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeVpcEndpointConnectionsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeVpcEndpointConnectionsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeVpcEndpointConnectionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeVpcEndpointConnectionsCommandInput} for command's `input` shape.
- * @see {@link DescribeVpcEndpointConnectionsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeVpcEndpointConnectionsCommand extends $Command<DescribeVpcEndpointConnectionsCommandInput, DescribeVpcEndpointConnectionsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeVpcEndpointConnectionsCommandInput;
     constructor(input: DescribeVpcEndpointConnectionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeVpcEndpointConnectionsCommandInput, DescribeVpcEndpointConnectionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeVpcEndpointServiceConfigurationsCommandInput extends De
 }
 export interface DescribeVpcEndpointServiceConfigurationsCommandOutput extends DescribeVpcEndpointServiceConfigurationsResult, __MetadataBearer {
 }
-/**
- * <p>Describes the VPC endpoint service configurations in your account (your services).</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeVpcEndpointServiceConfigurationsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeVpcEndpointServiceConfigurationsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeVpcEndpointServiceConfigurationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeVpcEndpointServiceConfigurationsCommandInput} for command's `input` shape.
- * @see {@link DescribeVpcEndpointServiceConfigurationsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeVpcEndpointServiceConfigurationsCommand extends $Command<DescribeVpcEndpointServiceConfigurationsCommandInput, DescribeVpcEndpointServiceConfigurationsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeVpcEndpointServiceConfigurationsCommandInput;
     constructor(input: DescribeVpcEndpointServiceConfigurationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeVpcEndpointServiceConfigurationsCommandInput, DescribeVpcEndpointServiceConfigurationsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeVpcEndpointServicePermissionsCommandInput extends Descr
 }
 export interface DescribeVpcEndpointServicePermissionsCommandOutput extends DescribeVpcEndpointServicePermissionsResult, __MetadataBearer {
 }
-/**
- * <p>Describes the principals (service consumers) that are permitted to discover your VPC
- *             endpoint service.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeVpcEndpointServicePermissionsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeVpcEndpointServicePermissionsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeVpcEndpointServicePermissionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeVpcEndpointServicePermissionsCommandInput} for command's `input` shape.
- * @see {@link DescribeVpcEndpointServicePermissionsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeVpcEndpointServicePermissionsCommand extends $Command<DescribeVpcEndpointServicePermissionsCommandInput, DescribeVpcEndpointServicePermissionsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeVpcEndpointServicePermissionsCommandInput;
     constructor(input: DescribeVpcEndpointServicePermissionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeVpcEndpointServicePermissionsCommandInput, DescribeVpcEndpointServicePermissionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,36 +6,11 @@ export interface DescribeVpcEndpointServicesCommandInput extends DescribeVpcEndp
 }
 export interface DescribeVpcEndpointServicesCommandOutput extends DescribeVpcEndpointServicesResult, __MetadataBearer {
 }
-/**
- * <p>Describes available services to which you can create a VPC endpoint.</p>
- *         <p>When the service provider and the consumer have different accounts in multiple
- *             Availability Zones, and the consumer views the VPC endpoint service information, the
- *             response only includes the common Availability Zones. For example, when the service
- *             provider account uses <code>us-east-1a</code> and <code>us-east-1c</code> and the
- *             consumer uses <code>us-east-1a</code> and <code>us-east-1b</code>, the response includes
- *             the VPC endpoint services in the common Availability Zone,
- *             <code>us-east-1a</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeVpcEndpointServicesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeVpcEndpointServicesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeVpcEndpointServicesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeVpcEndpointServicesCommandInput} for command's `input` shape.
- * @see {@link DescribeVpcEndpointServicesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeVpcEndpointServicesCommand extends $Command<DescribeVpcEndpointServicesCommandInput, DescribeVpcEndpointServicesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeVpcEndpointServicesCommandInput;
     constructor(input: DescribeVpcEndpointServicesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeVpcEndpointServicesCommandInput, DescribeVpcEndpointServicesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeVpcEndpointsCommandInput extends DescribeVpcEndpointsRe
 }
 export interface DescribeVpcEndpointsCommandOutput extends DescribeVpcEndpointsResult, __MetadataBearer {
 }
-/**
- * <p>Describes one or more of your VPC endpoints.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeVpcEndpointsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeVpcEndpointsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeVpcEndpointsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeVpcEndpointsCommandInput} for command's `input` shape.
- * @see {@link DescribeVpcEndpointsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeVpcEndpointsCommand extends $Command<DescribeVpcEndpointsCommandInput, DescribeVpcEndpointsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeVpcEndpointsCommandInput;
     constructor(input: DescribeVpcEndpointsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeVpcEndpointsCommandInput, DescribeVpcEndpointsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeVpcPeeringConnectionsCommandInput extends DescribeVpcPe
 }
 export interface DescribeVpcPeeringConnectionsCommandOutput extends DescribeVpcPeeringConnectionsResult, __MetadataBearer {
 }
-/**
- * <p>Describes one or more of your VPC peering connections.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeVpcPeeringConnectionsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeVpcPeeringConnectionsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeVpcPeeringConnectionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeVpcPeeringConnectionsCommandInput} for command's `input` shape.
- * @see {@link DescribeVpcPeeringConnectionsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeVpcPeeringConnectionsCommand extends $Command<DescribeVpcPeeringConnectionsCommandInput, DescribeVpcPeeringConnectionsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeVpcPeeringConnectionsCommandInput;
     constructor(input: DescribeVpcPeeringConnectionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeVpcPeeringConnectionsCommandInput, DescribeVpcPeeringConnectionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeVpcsCommandInput extends DescribeVpcsRequest {
 }
 export interface DescribeVpcsCommandOutput extends DescribeVpcsResult, __MetadataBearer {
 }
-/**
- * <p>Describes one or more of your VPCs.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeVpcsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeVpcsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeVpcsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeVpcsCommandInput} for command's `input` shape.
- * @see {@link DescribeVpcsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeVpcsCommand extends $Command<DescribeVpcsCommandInput, DescribeVpcsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeVpcsCommandInput;
     constructor(input: DescribeVpcsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeVpcsCommandInput, DescribeVpcsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DescribeVpnConnectionsCommandInput extends DescribeVpnConnectio
 }
 export interface DescribeVpnConnectionsCommandOutput extends DescribeVpnConnectionsResult, __MetadataBearer {
 }
-/**
- * <p>Describes one or more of your VPN connections.</p>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html">Amazon Web Services Site-to-Site VPN</a> in the <i>Amazon Web Services Site-to-Site VPN
- *                 User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeVpnConnectionsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeVpnConnectionsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeVpnConnectionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeVpnConnectionsCommandInput} for command's `input` shape.
- * @see {@link DescribeVpnConnectionsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeVpnConnectionsCommand extends $Command<DescribeVpnConnectionsCommandInput, DescribeVpnConnectionsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeVpnConnectionsCommandInput;
     constructor(input: DescribeVpnConnectionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeVpnConnectionsCommandInput, DescribeVpnConnectionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DescribeVpnGatewaysCommandInput extends DescribeVpnGatewaysRequ
 }
 export interface DescribeVpnGatewaysCommandOutput extends DescribeVpnGatewaysResult, __MetadataBearer {
 }
-/**
- * <p>Describes one or more of your virtual private gateways.</p>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html">Amazon Web Services Site-to-Site VPN</a> in the <i>Amazon Web Services Site-to-Site VPN
- *                 User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeVpnGatewaysCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeVpnGatewaysCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeVpnGatewaysCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeVpnGatewaysCommandInput} for command's `input` shape.
- * @see {@link DescribeVpnGatewaysCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeVpnGatewaysCommand extends $Command<DescribeVpnGatewaysCommandInput, DescribeVpnGatewaysCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeVpnGatewaysCommandInput;
     constructor(input: DescribeVpnGatewaysCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeVpnGatewaysCommandInput, DescribeVpnGatewaysCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DetachClassicLinkVpcCommandInput extends DetachClassicLinkVpcRe
 }
 export interface DetachClassicLinkVpcCommandOutput extends DetachClassicLinkVpcResult, __MetadataBearer {
 }
-/**
- * <p>Unlinks (detaches) a linked EC2-Classic instance from a VPC. After the instance has been unlinked, the VPC security groups are no longer associated with it. An instance is automatically unlinked from a VPC when it's stopped.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DetachClassicLinkVpcCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DetachClassicLinkVpcCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DetachClassicLinkVpcCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DetachClassicLinkVpcCommandInput} for command's `input` shape.
- * @see {@link DetachClassicLinkVpcCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DetachClassicLinkVpcCommand extends $Command<DetachClassicLinkVpcCommandInput, DetachClassicLinkVpcCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DetachClassicLinkVpcCommandInput;
     constructor(input: DetachClassicLinkVpcCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetachClassicLinkVpcCommandInput, DetachClassicLinkVpcCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DetachInternetGatewayCommandInput extends DetachInternetGateway
 }
 export interface DetachInternetGatewayCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Detaches an internet gateway from a VPC, disabling connectivity between the internet
- * 			and the VPC. The VPC must not contain any running instances with Elastic IP addresses or
- * 			public IPv4 addresses.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DetachInternetGatewayCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DetachInternetGatewayCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DetachInternetGatewayCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DetachInternetGatewayCommandInput} for command's `input` shape.
- * @see {@link DetachInternetGatewayCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DetachInternetGatewayCommand extends $Command<DetachInternetGatewayCommandInput, DetachInternetGatewayCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DetachInternetGatewayCommandInput;
     constructor(input: DetachInternetGatewayCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetachInternetGatewayCommandInput, DetachInternetGatewayCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -7,39 +7,11 @@ export interface DetachVolumeCommandInput extends DetachVolumeRequest {
 }
 export interface DetachVolumeCommandOutput extends VolumeAttachment, __MetadataBearer {
 }
-/**
- * <p>Detaches an EBS volume from an instance. Make sure to unmount any file systems on the
- *       device within your operating system before detaching the volume. Failure to do so can result
- *       in the volume becoming stuck in the <code>busy</code> state while detaching. If this happens,
- *       detachment can be delayed indefinitely until you unmount the volume, force detachment, reboot
- *       the instance, or all three. If an EBS volume is the root device of an instance, it can't be
- *       detached while the instance is running. To detach the root volume, stop the instance
- *       first.</p>
- *          <p>When a volume with an Amazon Web Services Marketplace product code is detached from an instance, the
- *       product code is no longer associated with the instance.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-detaching-volume.html">Detach an Amazon EBS volume</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, DetachVolumeCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DetachVolumeCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DetachVolumeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DetachVolumeCommandInput} for command's `input` shape.
- * @see {@link DetachVolumeCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DetachVolumeCommand extends $Command<DetachVolumeCommandInput, DetachVolumeCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DetachVolumeCommandInput;
     constructor(input: DetachVolumeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetachVolumeCommandInput, DetachVolumeCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface DetachVpnGatewayCommandInput extends DetachVpnGatewayRequest {
 }
 export interface DetachVpnGatewayCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Detaches a virtual private gateway from a VPC. You do this if you're planning to turn
- *             off the VPC and not use it anymore. You can confirm a virtual private gateway has been
- *             completely detached from a VPC by describing the virtual private gateway (any
- *             attachments to the virtual private gateway are also described).</p>
- *         <p>You must wait for the attachment's state to switch to <code>detached</code> before you
- *             can delete the VPC or attach a different VPC to the virtual private gateway.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DetachVpnGatewayCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DetachVpnGatewayCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DetachVpnGatewayCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DetachVpnGatewayCommandInput} for command's `input` shape.
- * @see {@link DetachVpnGatewayCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DetachVpnGatewayCommand extends $Command<DetachVpnGatewayCommandInput, DetachVpnGatewayCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DetachVpnGatewayCommandInput;
     constructor(input: DetachVpnGatewayCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetachVpnGatewayCommandInput, DetachVpnGatewayCommandOutput>;
     private serialize;
     private deserialize;