@aws-sdk/client-ec2 3.36.0 → 3.39.0

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

@@ -6,57 +6,11 @@ export interface StopInstancesCommandInput extends StopInstancesRequest {
 }
 export interface StopInstancesCommandOutput extends StopInstancesResult, __MetadataBearer {
 }
-/**
- * <p>Stops an Amazon EBS-backed instance.</p>
- *         <p>You can use the Stop action to hibernate an instance if the instance is <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Hibernate.html#enabling-hibernation">enabled for
- *                 hibernation</a> and it meets the <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Hibernate.html#hibernating-prerequisites">hibernation
- *                 prerequisites</a>. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Hibernate.html">Hibernate your instance</a> in the
- *                 <i>Amazon EC2 User Guide</i>.</p>
- *         <p>We don't charge usage for a stopped instance, or data transfer fees; however, your
- *             root partition Amazon EBS volume remains and continues to persist your data, and you are
- *             charged for Amazon EBS volume usage. Every time you start your instance, Amazon EC2
- *             charges a one-minute minimum for instance usage, and thereafter charges per second for
- *             instance usage.</p>
- *         <p>You can't stop or hibernate instance store-backed instances. You can't use the Stop
- *             action to hibernate Spot Instances, but you can specify that Amazon EC2 should hibernate
- *             Spot Instances when they are interrupted. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-interruptions.html#hibernate-spot-instances">Hibernating interrupted Spot Instances</a> in the <i>Amazon EC2 User Guide</i>.</p>
- *         <p>When you stop or hibernate an instance, we shut it down. You can restart your instance
- *             at any time. Before stopping or hibernating an instance, make sure it is in a state from
- *             which it can be restarted. Stopping an instance does not preserve data stored in RAM,
- *             but hibernating an instance does preserve data stored in RAM. If an instance cannot
- *             hibernate successfully, a normal shutdown occurs.</p>
- *         <p>Stopping and hibernating an instance is different to rebooting or terminating it. For
- *             example, when you stop or hibernate an instance, the root device and any other devices
- *             attached to the instance persist. When you terminate an instance, the root device and
- *             any other devices attached during the instance launch are automatically deleted. For
- *             more information about the differences between rebooting, stopping, hibernating, and
- *             terminating instances, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-lifecycle.html">Instance lifecycle</a>
- *             in the <i>Amazon EC2 User Guide</i>.</p>
- *         <p>When you stop an instance, we attempt to shut it down forcibly after a short while. If
- *             your instance appears stuck in the stopping state after a period of time, there may be
- *             an issue with the underlying host computer. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstancesStopping.html">Troubleshooting
- *                 stopping your instance</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, StopInstancesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, StopInstancesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new StopInstancesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StopInstancesCommandInput} for command's `input` shape.
- * @see {@link StopInstancesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StopInstancesCommand extends $Command<StopInstancesCommandInput, StopInstancesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: StopInstancesCommandInput;
     constructor(input: StopInstancesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopInstancesCommandInput, StopInstancesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface TerminateClientVpnConnectionsCommandInput extends TerminateClie
 }
 export interface TerminateClientVpnConnectionsCommandOutput extends TerminateClientVpnConnectionsResult, __MetadataBearer {
 }
-/**
- * <p>Terminates active Client VPN endpoint connections. This action can be used to terminate a specific client connection, or up to five connections established by a specific user.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, TerminateClientVpnConnectionsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, TerminateClientVpnConnectionsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new TerminateClientVpnConnectionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TerminateClientVpnConnectionsCommandInput} for command's `input` shape.
- * @see {@link TerminateClientVpnConnectionsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TerminateClientVpnConnectionsCommand extends $Command<TerminateClientVpnConnectionsCommandInput, TerminateClientVpnConnectionsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: TerminateClientVpnConnectionsCommandInput;
     constructor(input: TerminateClientVpnConnectionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TerminateClientVpnConnectionsCommandInput, TerminateClientVpnConnectionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,90 +6,11 @@ export interface TerminateInstancesCommandInput extends TerminateInstancesReques
 }
 export interface TerminateInstancesCommandOutput extends TerminateInstancesResult, __MetadataBearer {
 }
-/**
- * <p>Shuts down the specified instances. This operation is idempotent; if you terminate an
- *             instance more than once, each call succeeds. </p>
- *
- *         <p>If you specify multiple instances and the request fails (for example, because of a
- *             single incorrect instance ID), none of the instances are terminated.</p>
- *
- *         <p>If you terminate multiple instances across multiple Availability Zones, and one or more
- *             of the specified instances are enabled for termination protection, the request fails with
- *             the following results:</p>
- *         <ul>
- *             <li>
- *                 <p>The specified instances that are in the same Availability Zone as the protected
- *                     instance are not terminated.</p>
- *             </li>
- *             <li>
- *                 <p>The specified instances that are in different Availability Zones, where no other
- *                     specified instances are protected, are successfully terminated.</p>
- *             </li>
- *          </ul>
- *
- *         <p>For example, say you have the following instances:</p>
- *         <ul>
- *             <li>
- *                 <p>Instance A: <code>us-east-1a</code>; Not protected</p>
- *             </li>
- *             <li>
- *                 <p>Instance B: <code>us-east-1a</code>; Not protected</p>
- *             </li>
- *             <li>
- *                 <p>Instance C: <code>us-east-1b</code>; Protected</p>
- *             </li>
- *             <li>
- *                 <p>Instance D: <code>us-east-1b</code>; not protected</p>
- *             </li>
- *          </ul>
- *         <p>If you attempt to terminate all of these instances in the same request, the request reports
- *             failure with the following results:</p>
- *         <ul>
- *             <li>
- *                 <p>Instance A and Instance B are successfully terminated because none of the specified
- *                     instances in <code>us-east-1a</code> are enabled for termination protection.</p>
- *             </li>
- *             <li>
- *                 <p>Instance C and Instance D fail to terminate because at least one of the specified
- *                     instances in <code>us-east-1b</code> (Instance C) is enabled for termination protection.</p>
- *             </li>
- *          </ul>
- *
- *
- *         <p>Terminated instances remain visible after termination (for approximately one
- *             hour).</p>
- *         <p>By default, Amazon EC2 deletes all EBS volumes that were attached when the instance
- *             launched. Volumes attached after instance launch continue running.</p>
- *         <p>You can stop, start, and terminate EBS-backed instances. You can only terminate
- *             instance store-backed instances. What happens to an instance differs if you stop it or
- *             terminate it. For example, when you stop an instance, the root device and any other
- *             devices attached to the instance persist. When you terminate an instance, any attached
- *             EBS volumes with the <code>DeleteOnTermination</code> block device mapping parameter set
- *             to <code>true</code> are automatically deleted. For more information about the
- *             differences between stopping and terminating instances, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-lifecycle.html">Instance lifecycle</a>
- *             in the <i>Amazon EC2 User Guide</i>.</p>
- *         <p>For more information about troubleshooting, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstancesShuttingDown.html">Troubleshooting terminating your instance</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, TerminateInstancesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, TerminateInstancesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new TerminateInstancesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TerminateInstancesCommandInput} for command's `input` shape.
- * @see {@link TerminateInstancesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TerminateInstancesCommand extends $Command<TerminateInstancesCommandInput, TerminateInstancesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: TerminateInstancesCommandInput;
     constructor(input: TerminateInstancesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TerminateInstancesCommandInput, TerminateInstancesCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,30 +6,11 @@ export interface UnmonitorInstancesCommandInput extends UnmonitorInstancesReques
 }
 export interface UnmonitorInstancesCommandOutput extends UnmonitorInstancesResult, __MetadataBearer {
 }
-/**
- * <p>Disables detailed monitoring for a running instance. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-cloudwatch.html">Monitoring
- *             your instances and volumes</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, UnmonitorInstancesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, UnmonitorInstancesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new UnmonitorInstancesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UnmonitorInstancesCommandInput} for command's `input` shape.
- * @see {@link UnmonitorInstancesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UnmonitorInstancesCommand extends $Command<UnmonitorInstancesCommandInput, UnmonitorInstancesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: UnmonitorInstancesCommandInput;
     constructor(input: UnmonitorInstancesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UnmonitorInstancesCommandInput, UnmonitorInstancesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface UpdateSecurityGroupRuleDescriptionsEgressCommandInput extends U
 }
 export interface UpdateSecurityGroupRuleDescriptionsEgressCommandOutput extends UpdateSecurityGroupRuleDescriptionsEgressResult, __MetadataBearer {
 }
-/**
- * <p>[VPC only] Updates the description of an egress (outbound) security group rule. You
- * 			can replace an existing description, or add a description to a rule that did not have one
- * 			previously. You can remove a description for a security group rule by omitting the
- * 			description parameter in the request.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, UpdateSecurityGroupRuleDescriptionsEgressCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, UpdateSecurityGroupRuleDescriptionsEgressCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new UpdateSecurityGroupRuleDescriptionsEgressCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateSecurityGroupRuleDescriptionsEgressCommandInput} for command's `input` shape.
- * @see {@link UpdateSecurityGroupRuleDescriptionsEgressCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateSecurityGroupRuleDescriptionsEgressCommand extends $Command<UpdateSecurityGroupRuleDescriptionsEgressCommandInput, UpdateSecurityGroupRuleDescriptionsEgressCommandOutput, EC2ClientResolvedConfig> {
     readonly input: UpdateSecurityGroupRuleDescriptionsEgressCommandInput;
     constructor(input: UpdateSecurityGroupRuleDescriptionsEgressCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateSecurityGroupRuleDescriptionsEgressCommandInput, UpdateSecurityGroupRuleDescriptionsEgressCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface UpdateSecurityGroupRuleDescriptionsIngressCommandInput extends
 }
 export interface UpdateSecurityGroupRuleDescriptionsIngressCommandOutput extends UpdateSecurityGroupRuleDescriptionsIngressResult, __MetadataBearer {
 }
-/**
- * <p>Updates the description of an ingress (inbound) security group rule. You can replace an
- * 			existing description, or add a description to a rule that did not have one previously.
- * 		    You can remove a description for a security group rule by omitting the description
- * 		    parameter in the request.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, UpdateSecurityGroupRuleDescriptionsIngressCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, UpdateSecurityGroupRuleDescriptionsIngressCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new UpdateSecurityGroupRuleDescriptionsIngressCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateSecurityGroupRuleDescriptionsIngressCommandInput} for command's `input` shape.
- * @see {@link UpdateSecurityGroupRuleDescriptionsIngressCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateSecurityGroupRuleDescriptionsIngressCommand extends $Command<UpdateSecurityGroupRuleDescriptionsIngressCommandInput, UpdateSecurityGroupRuleDescriptionsIngressCommandOutput, EC2ClientResolvedConfig> {
     readonly input: UpdateSecurityGroupRuleDescriptionsIngressCommandInput;
     constructor(input: UpdateSecurityGroupRuleDescriptionsIngressCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateSecurityGroupRuleDescriptionsIngressCommandInput, UpdateSecurityGroupRuleDescriptionsIngressCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface WithdrawByoipCidrCommandInput extends WithdrawByoipCidrRequest
 }
 export interface WithdrawByoipCidrCommandOutput extends WithdrawByoipCidrResult, __MetadataBearer {
 }
-/**
- * <p>Stops advertising an address range that is provisioned as an address pool.</p>
- *          <p>You can perform this operation at most once every 10 seconds, even if you specify different
- *          address ranges each time.</p>
- *          <p>It can take a few minutes before traffic to the specified addresses stops routing to Amazon Web Services
- *           because of BGP propagation delays.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, WithdrawByoipCidrCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, WithdrawByoipCidrCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new WithdrawByoipCidrCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link WithdrawByoipCidrCommandInput} for command's `input` shape.
- * @see {@link WithdrawByoipCidrCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class WithdrawByoipCidrCommand extends $Command<WithdrawByoipCidrCommandInput, WithdrawByoipCidrCommandOutput, EC2ClientResolvedConfig> {
     readonly input: WithdrawByoipCidrCommandInput;
     constructor(input: WithdrawByoipCidrCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<WithdrawByoipCidrCommandInput, WithdrawByoipCidrCommandOutput>;
     private serialize;
     private deserialize;