@aws-sdk/client-ec2 3.36.0 → 3.39.0

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

@@ -6,35 +6,11 @@ export interface DisableEbsEncryptionByDefaultCommandInput extends DisableEbsEnc
 }
 export interface DisableEbsEncryptionByDefaultCommandOutput extends DisableEbsEncryptionByDefaultResult, __MetadataBearer {
 }
-/**
- * <p>Disables EBS encryption by default for your account in the current Region.</p>
- *          <p>After you disable encryption by default, you can still create encrypted volumes by
- *       enabling encryption when you create each volume.</p>
- *          <p>Disabling encryption by default does not change the encryption status of your
- *       existing volumes.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html">Amazon EBS encryption</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, DisableEbsEncryptionByDefaultCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DisableEbsEncryptionByDefaultCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DisableEbsEncryptionByDefaultCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisableEbsEncryptionByDefaultCommandInput} for command's `input` shape.
- * @see {@link DisableEbsEncryptionByDefaultCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisableEbsEncryptionByDefaultCommand extends $Command<DisableEbsEncryptionByDefaultCommandInput, DisableEbsEncryptionByDefaultCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DisableEbsEncryptionByDefaultCommandInput;
     constructor(input: DisableEbsEncryptionByDefaultCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisableEbsEncryptionByDefaultCommandInput, DisableEbsEncryptionByDefaultCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,31 +6,11 @@ export interface DisableImageDeprecationCommandInput extends DisableImageDepreca
 }
 export interface DisableImageDeprecationCommandOutput extends DisableImageDeprecationResult, __MetadataBearer {
 }
-/**
- * <p>Cancels the deprecation of the specified AMI.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-deprecate.html">Deprecate an AMI</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, DisableImageDeprecationCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DisableImageDeprecationCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DisableImageDeprecationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisableImageDeprecationCommandInput} for command's `input` shape.
- * @see {@link DisableImageDeprecationCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisableImageDeprecationCommand extends $Command<DisableImageDeprecationCommandInput, DisableImageDeprecationCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DisableImageDeprecationCommandInput;
     constructor(input: DisableImageDeprecationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisableImageDeprecationCommandInput, DisableImageDeprecationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DisableSerialConsoleAccessCommandInput extends DisableSerialCon
 }
 export interface DisableSerialConsoleAccessCommandOutput extends DisableSerialConsoleAccessResult, __MetadataBearer {
 }
-/**
- * <p>Disables access to the EC2 serial console of all instances for your account. By default,
- * 			access to the EC2 serial console is disabled for your account. For more information, see
- * 				<a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configure-access-to-serial-console.html#serial-console-account-access">Manage account access to the EC2 serial console</a> in the <i>Amazon EC2
- * 				User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DisableSerialConsoleAccessCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DisableSerialConsoleAccessCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DisableSerialConsoleAccessCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisableSerialConsoleAccessCommandInput} for command's `input` shape.
- * @see {@link DisableSerialConsoleAccessCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisableSerialConsoleAccessCommand extends $Command<DisableSerialConsoleAccessCommandInput, DisableSerialConsoleAccessCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DisableSerialConsoleAccessCommandInput;
     constructor(input: DisableSerialConsoleAccessCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisableSerialConsoleAccessCommandInput, DisableSerialConsoleAccessCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,29 +6,11 @@ export interface DisableVpcClassicLinkCommandInput extends DisableVpcClassicLink
 }
 export interface DisableVpcClassicLinkCommandOutput extends DisableVpcClassicLinkResult, __MetadataBearer {
 }
-/**
- * <p>Disables ClassicLink for a VPC. You cannot disable ClassicLink for a VPC that has EC2-Classic instances linked to it.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DisableVpcClassicLinkCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DisableVpcClassicLinkCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DisableVpcClassicLinkCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisableVpcClassicLinkCommandInput} for command's `input` shape.
- * @see {@link DisableVpcClassicLinkCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisableVpcClassicLinkCommand extends $Command<DisableVpcClassicLinkCommandInput, DisableVpcClassicLinkCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DisableVpcClassicLinkCommandInput;
     constructor(input: DisableVpcClassicLinkCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisableVpcClassicLinkCommandInput, DisableVpcClassicLinkCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DisableVpcClassicLinkDnsSupportCommandInput extends DisableVpcC
 }
 export interface DisableVpcClassicLinkDnsSupportCommandOutput extends DisableVpcClassicLinkDnsSupportResult, __MetadataBearer {
 }
-/**
- * <p>Disables ClassicLink DNS support for a VPC. If disabled, DNS hostnames resolve to
- * 			public IP addresses when addressed between a linked EC2-Classic instance and instances
- * 			in the VPC to which it's linked. 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>
- *          <p>You must specify a VPC ID in the request.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DisableVpcClassicLinkDnsSupportCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DisableVpcClassicLinkDnsSupportCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DisableVpcClassicLinkDnsSupportCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisableVpcClassicLinkDnsSupportCommandInput} for command's `input` shape.
- * @see {@link DisableVpcClassicLinkDnsSupportCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisableVpcClassicLinkDnsSupportCommand extends $Command<DisableVpcClassicLinkDnsSupportCommandInput, DisableVpcClassicLinkDnsSupportCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DisableVpcClassicLinkDnsSupportCommandInput;
     constructor(input: DisableVpcClassicLinkDnsSupportCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisableVpcClassicLinkDnsSupportCommandInput, DisableVpcClassicLinkDnsSupportCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DisassociateAddressCommandInput extends DisassociateAddressRequ
 }
 export interface DisassociateAddressCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Disassociates an Elastic IP address from the instance or network interface it's associated with.</p>
- * 			      <p>An Elastic IP address is for use in either the EC2-Classic platform or in a VPC. For more
- * 			information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html">Elastic IP
- * 				Addresses</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
- *          <p>This is an idempotent operation. If you perform the operation more than once, Amazon EC2 doesn't return an error.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DisassociateAddressCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DisassociateAddressCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DisassociateAddressCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisassociateAddressCommandInput} for command's `input` shape.
- * @see {@link DisassociateAddressCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisassociateAddressCommand extends $Command<DisassociateAddressCommandInput, DisassociateAddressCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DisassociateAddressCommandInput;
     constructor(input: DisassociateAddressCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateAddressCommandInput, DisassociateAddressCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,45 +6,11 @@ export interface DisassociateClientVpnTargetNetworkCommandInput extends Disassoc
 }
 export interface DisassociateClientVpnTargetNetworkCommandOutput extends DisassociateClientVpnTargetNetworkResult, __MetadataBearer {
 }
-/**
- * <p>Disassociates a target network from the specified Client VPN endpoint. When you disassociate the
- * 			last target network from a Client VPN, the following happens:</p>
- * 		       <ul>
- *             <li>
- * 				           <p>The route that was automatically added for the VPC is deleted</p>
- * 			         </li>
- *             <li>
- * 				           <p>All active client connections are terminated</p>
- * 			         </li>
- *             <li>
- * 				           <p>New client connections are disallowed</p>
- * 			         </li>
- *             <li>
- * 				           <p>The Client VPN endpoint's status changes to <code>pending-associate</code>
- *                </p>
- * 			         </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DisassociateClientVpnTargetNetworkCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DisassociateClientVpnTargetNetworkCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DisassociateClientVpnTargetNetworkCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisassociateClientVpnTargetNetworkCommandInput} for command's `input` shape.
- * @see {@link DisassociateClientVpnTargetNetworkCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisassociateClientVpnTargetNetworkCommand extends $Command<DisassociateClientVpnTargetNetworkCommandInput, DisassociateClientVpnTargetNetworkCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DisassociateClientVpnTargetNetworkCommandInput;
     constructor(input: DisassociateClientVpnTargetNetworkCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateClientVpnTargetNetworkCommandInput, DisassociateClientVpnTargetNetworkCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DisassociateEnclaveCertificateIamRoleCommandInput extends Disas
 }
 export interface DisassociateEnclaveCertificateIamRoleCommandOutput extends DisassociateEnclaveCertificateIamRoleResult, __MetadataBearer {
 }
-/**
- * <p>Disassociates an IAM role from an Certificate Manager (ACM) certificate. Disassociating an IAM role
- * 			from an ACM certificate removes the Amazon S3 object that contains the certificate, certificate chain, and
- * 			encrypted private key from the Amazon S3 bucket. It also revokes the IAM role's permission to use the
- * 			KMS key used to encrypt the private key. This effectively revokes the role's permission
- * 			to use the certificate.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DisassociateEnclaveCertificateIamRoleCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DisassociateEnclaveCertificateIamRoleCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DisassociateEnclaveCertificateIamRoleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisassociateEnclaveCertificateIamRoleCommandInput} for command's `input` shape.
- * @see {@link DisassociateEnclaveCertificateIamRoleCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisassociateEnclaveCertificateIamRoleCommand extends $Command<DisassociateEnclaveCertificateIamRoleCommandInput, DisassociateEnclaveCertificateIamRoleCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DisassociateEnclaveCertificateIamRoleCommandInput;
     constructor(input: DisassociateEnclaveCertificateIamRoleCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateEnclaveCertificateIamRoleCommandInput, DisassociateEnclaveCertificateIamRoleCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DisassociateIamInstanceProfileCommandInput extends Disassociate
 }
 export interface DisassociateIamInstanceProfileCommandOutput extends DisassociateIamInstanceProfileResult, __MetadataBearer {
 }
-/**
- * <p>Disassociates an IAM instance profile from a running or stopped instance.</p>
- *         <p>Use <a>DescribeIamInstanceProfileAssociations</a> to get the association
- *             ID.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DisassociateIamInstanceProfileCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DisassociateIamInstanceProfileCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DisassociateIamInstanceProfileCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisassociateIamInstanceProfileCommandInput} for command's `input` shape.
- * @see {@link DisassociateIamInstanceProfileCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisassociateIamInstanceProfileCommand extends $Command<DisassociateIamInstanceProfileCommandInput, DisassociateIamInstanceProfileCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DisassociateIamInstanceProfileCommandInput;
     constructor(input: DisassociateIamInstanceProfileCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateIamInstanceProfileCommandInput, DisassociateIamInstanceProfileCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DisassociateInstanceEventWindowCommandInput extends Disassociat
 }
 export interface DisassociateInstanceEventWindowCommandOutput extends DisassociateInstanceEventWindowResult, __MetadataBearer {
 }
-/**
- * <p>Disassociates one or more targets from an event window.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html">Define event windows for scheduled
- *             events</a> in the <i>Amazon EC2 User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DisassociateInstanceEventWindowCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DisassociateInstanceEventWindowCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DisassociateInstanceEventWindowCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisassociateInstanceEventWindowCommandInput} for command's `input` shape.
- * @see {@link DisassociateInstanceEventWindowCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisassociateInstanceEventWindowCommand extends $Command<DisassociateInstanceEventWindowCommandInput, DisassociateInstanceEventWindowCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DisassociateInstanceEventWindowCommandInput;
     constructor(input: DisassociateInstanceEventWindowCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateInstanceEventWindowCommandInput, DisassociateInstanceEventWindowCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DisassociateRouteTableCommandInput extends DisassociateRouteTab
 }
 export interface DisassociateRouteTableCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Disassociates a subnet or gateway from a route table.</p>
- * 		       <p>After you perform this action, the subnet no longer uses the routes in the route table.
- * 				Instead, it uses the routes in the VPC's main route table. For more information
- * 				about route tables, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Route_Tables.html">Route
- * 				tables</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, DisassociateRouteTableCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DisassociateRouteTableCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DisassociateRouteTableCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisassociateRouteTableCommandInput} for command's `input` shape.
- * @see {@link DisassociateRouteTableCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisassociateRouteTableCommand extends $Command<DisassociateRouteTableCommandInput, DisassociateRouteTableCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DisassociateRouteTableCommandInput;
     constructor(input: DisassociateRouteTableCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateRouteTableCommandInput, DisassociateRouteTableCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DisassociateSubnetCidrBlockCommandInput extends DisassociateSub
 }
 export interface DisassociateSubnetCidrBlockCommandOutput extends DisassociateSubnetCidrBlockResult, __MetadataBearer {
 }
-/**
- * <p>Disassociates a CIDR block from a subnet. Currently, you can disassociate an IPv6 CIDR block only. You must detach or delete all gateways and resources that are associated with the CIDR block before you can disassociate it. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DisassociateSubnetCidrBlockCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DisassociateSubnetCidrBlockCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DisassociateSubnetCidrBlockCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisassociateSubnetCidrBlockCommandInput} for command's `input` shape.
- * @see {@link DisassociateSubnetCidrBlockCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisassociateSubnetCidrBlockCommand extends $Command<DisassociateSubnetCidrBlockCommandInput, DisassociateSubnetCidrBlockCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DisassociateSubnetCidrBlockCommandInput;
     constructor(input: DisassociateSubnetCidrBlockCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateSubnetCidrBlockCommandInput, DisassociateSubnetCidrBlockCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,29 +6,11 @@ export interface DisassociateTransitGatewayRouteTableCommandInput extends Disass
 }
 export interface DisassociateTransitGatewayRouteTableCommandOutput extends DisassociateTransitGatewayRouteTableResult, __MetadataBearer {
 }
-/**
- * <p>Disassociates a resource attachment from 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, DisassociateTransitGatewayRouteTableCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DisassociateTransitGatewayRouteTableCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DisassociateTransitGatewayRouteTableCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisassociateTransitGatewayRouteTableCommandInput} for command's `input` shape.
- * @see {@link DisassociateTransitGatewayRouteTableCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisassociateTransitGatewayRouteTableCommand extends $Command<DisassociateTransitGatewayRouteTableCommandInput, DisassociateTransitGatewayRouteTableCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DisassociateTransitGatewayRouteTableCommandInput;
     constructor(input: DisassociateTransitGatewayRouteTableCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateTransitGatewayRouteTableCommandInput, DisassociateTransitGatewayRouteTableCommandOutput>;
     private serialize;
     private deserialize;