@aws-sdk/client-ec2 3.36.0 → 3.39.0

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

@@ -6,31 +6,11 @@ export interface ResetSnapshotAttributeCommandInput extends ResetSnapshotAttribu
 }
 export interface ResetSnapshotAttributeCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Resets permission settings for the specified snapshot.</p>
- *          <p>For more information about modifying snapshot permissions, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-modifying-snapshot-permissions.html">Share a snapshot</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, ResetSnapshotAttributeCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ResetSnapshotAttributeCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ResetSnapshotAttributeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ResetSnapshotAttributeCommandInput} for command's `input` shape.
- * @see {@link ResetSnapshotAttributeCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ResetSnapshotAttributeCommand extends $Command<ResetSnapshotAttributeCommandInput, ResetSnapshotAttributeCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ResetSnapshotAttributeCommandInput;
     constructor(input: ResetSnapshotAttributeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ResetSnapshotAttributeCommandInput, ResetSnapshotAttributeCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface RestoreAddressToClassicCommandInput extends RestoreAddressToCla
 }
 export interface RestoreAddressToClassicCommandOutput extends RestoreAddressToClassicResult, __MetadataBearer {
 }
-/**
- * <p>Restores an Elastic IP address that was previously moved to the EC2-VPC platform back to the EC2-Classic platform. You cannot move an Elastic IP address that was originally allocated for use in EC2-VPC. The Elastic IP address must not be associated with an instance or network interface.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, RestoreAddressToClassicCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, RestoreAddressToClassicCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new RestoreAddressToClassicCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RestoreAddressToClassicCommandInput} for command's `input` shape.
- * @see {@link RestoreAddressToClassicCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RestoreAddressToClassicCommand extends $Command<RestoreAddressToClassicCommandInput, RestoreAddressToClassicCommandOutput, EC2ClientResolvedConfig> {
     readonly input: RestoreAddressToClassicCommandInput;
     constructor(input: RestoreAddressToClassicCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RestoreAddressToClassicCommandInput, RestoreAddressToClassicCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,44 +6,11 @@ export interface RevokeSecurityGroupEgressCommandInput extends RevokeSecurityGro
 }
 export interface RevokeSecurityGroupEgressCommandOutput extends RevokeSecurityGroupEgressResult, __MetadataBearer {
 }
-/**
- * <p>[VPC only] Removes the specified outbound (egress) rules from a security group for EC2-VPC.
- *        This action does not apply to security groups for use in EC2-Classic.</p>
- *
- *          <p>You can specify rules using either rule IDs or security group rule properties. If you use
- *          rule properties, the values that you specify (for example, ports) must match the existing rule's
- *          values exactly. Each rule has a protocol, from and to ports, and destination (CIDR range,
- *          security group, or prefix list). For the TCP and UDP protocols, you must also specify the
- *          destination port or range of ports. For the ICMP protocol, you must also specify the ICMP type
- *          and code. If the security group rule has a description, you do not need to specify the description
- *          to revoke the rule.</p>
- *          <p>[Default VPC] If the values you specify do not match the existing rule's values, no error is
- *          returned, and the output describes the security group rules that were not revoked.</p>
- *          <p>Amazon Web Services recommends that you describe the security group to verify that the rules were removed.</p>
- *
- *          <p>Rule changes are propagated to instances within the security group as quickly as possible. However,
- *          a small delay might occur.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, RevokeSecurityGroupEgressCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, RevokeSecurityGroupEgressCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new RevokeSecurityGroupEgressCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RevokeSecurityGroupEgressCommandInput} for command's `input` shape.
- * @see {@link RevokeSecurityGroupEgressCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RevokeSecurityGroupEgressCommand extends $Command<RevokeSecurityGroupEgressCommandInput, RevokeSecurityGroupEgressCommandOutput, EC2ClientResolvedConfig> {
     readonly input: RevokeSecurityGroupEgressCommandInput;
     constructor(input: RevokeSecurityGroupEgressCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RevokeSecurityGroupEgressCommandInput, RevokeSecurityGroupEgressCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,42 +6,11 @@ export interface RevokeSecurityGroupIngressCommandInput extends RevokeSecurityGr
 }
 export interface RevokeSecurityGroupIngressCommandOutput extends RevokeSecurityGroupIngressResult, __MetadataBearer {
 }
-/**
- * <p>Removes the specified inbound (ingress) rules from a security group.</p>
- *
- *          <p>You can specify rules using either rule IDs or security group rule properties. If you use
- *            rule properties, the values that you specify (for example, ports) must match the existing rule's
- *            values exactly. Each rule has a protocol, from and to ports, and source (CIDR range,
- *            security group, or prefix list). For the TCP and UDP protocols, you must also specify the
- *            destination port or range of ports. For the ICMP protocol, you must also specify the ICMP type
- *            and code. If the security group rule has a description, you do not need to specify the description
- *            to revoke the rule.</p>
- *          <p>[EC2-Classic, default VPC] If the values you specify do not match the existing rule's values, no error is
- *            returned, and the output describes the security group rules that were not revoked.</p>
- *          <p>Amazon Web Services recommends that you describe the security group to verify that the rules were removed.</p>
- *
- *          <p>Rule changes are propagated to instances within the security group as quickly as possible. However, a small delay might occur.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, RevokeSecurityGroupIngressCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, RevokeSecurityGroupIngressCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new RevokeSecurityGroupIngressCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RevokeSecurityGroupIngressCommandInput} for command's `input` shape.
- * @see {@link RevokeSecurityGroupIngressCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RevokeSecurityGroupIngressCommand extends $Command<RevokeSecurityGroupIngressCommandInput, RevokeSecurityGroupIngressCommandOutput, EC2ClientResolvedConfig> {
     readonly input: RevokeSecurityGroupIngressCommandInput;
     constructor(input: RevokeSecurityGroupIngressCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RevokeSecurityGroupIngressCommandInput, RevokeSecurityGroupIngressCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -7,85 +7,11 @@ export interface RunInstancesCommandInput extends RunInstancesRequest {
 }
 export interface RunInstancesCommandOutput extends Reservation, __MetadataBearer {
 }
-/**
- * <p>Launches the specified number of instances using an AMI for which you have
- *             permissions.</p>
- *         <p>You can specify a number of options, or leave the default options. The following rules
- *             apply:</p>
- *         <ul>
- *             <li>
- *                 <p>[EC2-VPC] If you don't specify a subnet ID, we choose a default subnet from
- *                     your default VPC for you. If you don't have a default VPC, you must specify a
- *                     subnet ID in the request.</p>
- *             </li>
- *             <li>
- *                 <p>[EC2-Classic] If don't specify an Availability Zone, we choose one for
- *                     you.</p>
- *             </li>
- *             <li>
- *                 <p>Some instance types must be launched into a VPC. If you do not have a default
- *                     VPC, or if you do not specify a subnet ID, the request fails. For more
- *                     information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-vpc.html#vpc-only-instance-types">Instance types available only in a VPC</a>.</p>
- *             </li>
- *             <li>
- *                 <p>[EC2-VPC] All instances have a network interface with a primary private IPv4
- *                     address. If you don't specify this address, we choose one from the IPv4 range of
- *                     your subnet.</p>
- *             </li>
- *             <li>
- *                 <p>Not all instance types support IPv6 addresses. For more information, see
- *                         <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html">Instance
- *                     types</a>.</p>
- *             </li>
- *             <li>
- *                 <p>If you don't specify a security group ID, we use the default security group.
- *                     For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html">Security
- *                         groups</a>.</p>
- *             </li>
- *             <li>
- *                 <p>If any of the AMIs have a product code attached for which the user has not
- *                     subscribed, the request fails.</p>
- *             </li>
- *          </ul>
- *         <p>You can create a <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html">launch template</a>,
- *             which is a resource that contains the parameters to launch an instance. When you launch
- *             an instance using <a>RunInstances</a>, you can specify the launch template
- *             instead of specifying the launch parameters.</p>
- *         <p>To ensure faster instance launches, break up large requests into smaller batches. For
- *             example, create five separate launch requests for 100 instances each instead of one
- *             launch request for 500 instances.</p>
- *         <p>An instance is ready for you to use when it's in the <code>running</code> state. You
- *             can check the state of your instance using <a>DescribeInstances</a>. You can
- *             tag instances and EBS volumes during launch, after launch, or both. For more
- *             information, see <a>CreateTags</a> and <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html">Tagging your Amazon EC2
- *                 resources</a>.</p>
- *         <p>Linux instances have access to the public key of the key pair at boot. You can use
- *             this key to provide secure access to the instance. Amazon EC2 public images use this
- *             feature to provide secure access without passwords. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html">Key
- *                 pairs</a>.</p>
- *         <p>For troubleshooting, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_InstanceStraightToTerminated.html">What to do if
- *                 an instance immediately terminates</a>, and <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstancesConnecting.html">Troubleshooting connecting to your instance</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, RunInstancesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, RunInstancesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new RunInstancesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RunInstancesCommandInput} for command's `input` shape.
- * @see {@link RunInstancesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RunInstancesCommand extends $Command<RunInstancesCommandInput, RunInstancesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: RunInstancesCommandInput;
     constructor(input: RunInstancesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RunInstancesCommandInput, RunInstancesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface RunScheduledInstancesCommandInput extends RunScheduledInstances
 }
 export interface RunScheduledInstancesCommandOutput extends RunScheduledInstancesResult, __MetadataBearer {
 }
-/**
- * <p>Launches the specified Scheduled Instances.</p>
- *          <p>Before you can launch a Scheduled Instance, you must purchase it and obtain an identifier using <a>PurchaseScheduledInstances</a>.</p>
- *          <p>You must launch a Scheduled Instance during its scheduled time period. You can't stop or reboot a Scheduled Instance,
- *          but you can terminate it as needed. If you terminate a Scheduled Instance before the current scheduled time period ends,
- *          you can launch it again after a few minutes. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-scheduled-instances.html">Scheduled Instances</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, RunScheduledInstancesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, RunScheduledInstancesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new RunScheduledInstancesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RunScheduledInstancesCommandInput} for command's `input` shape.
- * @see {@link RunScheduledInstancesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RunScheduledInstancesCommand extends $Command<RunScheduledInstancesCommandInput, RunScheduledInstancesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: RunScheduledInstancesCommandInput;
     constructor(input: RunScheduledInstancesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RunScheduledInstancesCommandInput, RunScheduledInstancesCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,29 +6,11 @@ export interface SearchTransitGatewayMulticastGroupsCommandInput extends SearchT
 }
 export interface SearchTransitGatewayMulticastGroupsCommandOutput extends SearchTransitGatewayMulticastGroupsResult, __MetadataBearer {
 }
-/**
- * <p>Searches one or more  transit gateway multicast groups and returns the group membership information.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, SearchTransitGatewayMulticastGroupsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, SearchTransitGatewayMulticastGroupsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new SearchTransitGatewayMulticastGroupsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SearchTransitGatewayMulticastGroupsCommandInput} for command's `input` shape.
- * @see {@link SearchTransitGatewayMulticastGroupsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SearchTransitGatewayMulticastGroupsCommand extends $Command<SearchTransitGatewayMulticastGroupsCommandInput, SearchTransitGatewayMulticastGroupsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: SearchTransitGatewayMulticastGroupsCommandInput;
     constructor(input: SearchTransitGatewayMulticastGroupsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SearchTransitGatewayMulticastGroupsCommandInput, SearchTransitGatewayMulticastGroupsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,44 +6,11 @@ export interface SendDiagnosticInterruptCommandInput extends SendDiagnosticInter
 }
 export interface SendDiagnosticInterruptCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Sends a diagnostic interrupt to the specified Amazon EC2 instance to trigger a
- * 			<i>kernel panic</i> (on Linux instances), or a
- * 			<i>blue screen</i>/<i>stop error</i> (on Windows
- * 			instances). For instances based on Intel and AMD processors, the interrupt is
- * 			received as a <i>non-maskable interrupt</i> (NMI).</p>
- *
- * 		       <p>In general, the operating system crashes and reboots when a kernel panic or stop
- * 			error is triggered. The operating system can also be configured to perform diagnostic
- * 			tasks, such as generating a memory dump file, loading a secondary kernel, or
- * 			obtaining a call trace.</p>
- *
- * 		       <p>Before sending a diagnostic interrupt to your instance, ensure that its operating
- * 			system is configured to perform the required diagnostic tasks.</p>
- *
- * 		       <p>For more information about configuring your operating system to generate a crash dump
- * 			when a kernel panic or stop error occurs, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/diagnostic-interrupt.html">Send a diagnostic interrupt</a> (Linux instances) or <a href="https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/diagnostic-interrupt.html">Send a Diagnostic Interrupt</a> (Windows instances).</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, SendDiagnosticInterruptCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, SendDiagnosticInterruptCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new SendDiagnosticInterruptCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SendDiagnosticInterruptCommandInput} for command's `input` shape.
- * @see {@link SendDiagnosticInterruptCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SendDiagnosticInterruptCommand extends $Command<SendDiagnosticInterruptCommandInput, SendDiagnosticInterruptCommandOutput, EC2ClientResolvedConfig> {
     readonly input: SendDiagnosticInterruptCommandInput;
     constructor(input: SendDiagnosticInterruptCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SendDiagnosticInterruptCommandInput, SendDiagnosticInterruptCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,48 +6,11 @@ export interface StartInstancesCommandInput extends StartInstancesRequest {
 }
 export interface StartInstancesCommandOutput extends StartInstancesResult, __MetadataBearer {
 }
-/**
- * <p>Starts an Amazon EBS-backed instance that you've previously stopped.</p>
- *         <p>Instances that use Amazon EBS volumes as their root devices can be quickly stopped and
- *             started. When an instance is stopped, the compute resources are released and you are not
- *             billed for instance usage. However, your root partition Amazon EBS volume remains and
- *             continues to persist your data, and you are charged for Amazon EBS volume usage. You can
- *             restart your instance at any time. 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>Before stopping 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.</p>
- *         <p>Performing this operation on an instance that uses an instance store as its root
- *             device returns an error.</p>
- *
- *         <p>If you attempt to start a T3 instance with <code>host</code> tenancy and the <code>unlimted</code>
- *             CPU credit option, the request fails. The <code>unlimited</code> CPU credit option is not
- *             supported on Dedicated Hosts. Before you start the instance, either change its CPU credit
- *             option to <code>standard</code>, or change its tenancy to <code>default</code> or <code>dedicated</code>.</p>
- *
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Stop_Start.html">Stopping instances</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, StartInstancesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, StartInstancesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new StartInstancesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartInstancesCommandInput} for command's `input` shape.
- * @see {@link StartInstancesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartInstancesCommand extends $Command<StartInstancesCommandInput, StartInstancesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: StartInstancesCommandInput;
     constructor(input: StartInstancesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartInstancesCommandInput, StartInstancesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface StartNetworkInsightsAnalysisCommandInput extends StartNetworkIn
 }
 export interface StartNetworkInsightsAnalysisCommandOutput extends StartNetworkInsightsAnalysisResult, __MetadataBearer {
 }
-/**
- * <p>Starts analyzing the specified path. If the path is reachable, the
- *          operation returns the shortest feasible path.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, StartNetworkInsightsAnalysisCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, StartNetworkInsightsAnalysisCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new StartNetworkInsightsAnalysisCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartNetworkInsightsAnalysisCommandInput} for command's `input` shape.
- * @see {@link StartNetworkInsightsAnalysisCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartNetworkInsightsAnalysisCommand extends $Command<StartNetworkInsightsAnalysisCommandInput, StartNetworkInsightsAnalysisCommandOutput, EC2ClientResolvedConfig> {
     readonly input: StartNetworkInsightsAnalysisCommandInput;
     constructor(input: StartNetworkInsightsAnalysisCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartNetworkInsightsAnalysisCommandInput, StartNetworkInsightsAnalysisCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface StartVpcEndpointServicePrivateDnsVerificationCommandInput exten
 }
 export interface StartVpcEndpointServicePrivateDnsVerificationCommandOutput extends StartVpcEndpointServicePrivateDnsVerificationResult, __MetadataBearer {
 }
-/**
- * <p>Initiates the verification process to prove that the service provider owns the private
- *             DNS name domain for the endpoint service.</p>
- *         <p>The service provider must successfully perform the verification before the consumer can use the name to access the service.</p>
- *         <p>Before the service provider runs this command, they must add a record to the DNS server. For more information, see  <a href="https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-services-dns-validation.html#add-dns-txt-record">Adding a TXT Record to Your Domain's DNS Server </a> in the <i>Amazon VPC User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, StartVpcEndpointServicePrivateDnsVerificationCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, StartVpcEndpointServicePrivateDnsVerificationCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new StartVpcEndpointServicePrivateDnsVerificationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartVpcEndpointServicePrivateDnsVerificationCommandInput} for command's `input` shape.
- * @see {@link StartVpcEndpointServicePrivateDnsVerificationCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartVpcEndpointServicePrivateDnsVerificationCommand extends $Command<StartVpcEndpointServicePrivateDnsVerificationCommandInput, StartVpcEndpointServicePrivateDnsVerificationCommandOutput, EC2ClientResolvedConfig> {
     readonly input: StartVpcEndpointServicePrivateDnsVerificationCommandInput;
     constructor(input: StartVpcEndpointServicePrivateDnsVerificationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartVpcEndpointServicePrivateDnsVerificationCommandInput, StartVpcEndpointServicePrivateDnsVerificationCommandOutput>;
     private serialize;
     private deserialize;