@aws-sdk/client-ec2 3.36.0 → 3.39.0

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

@@ -6,41 +6,11 @@ export interface AllocateAddressCommandInput extends AllocateAddressRequest {
 }
 export interface AllocateAddressCommandOutput extends AllocateAddressResult, __MetadataBearer {
 }
-/**
- * <p>Allocates an Elastic IP address to your Amazon Web Services account. After you allocate the Elastic IP address you can associate
- *          it with an instance or network interface. After you release an Elastic IP address, it is released to the IP address
- *          pool and can be allocated to a different Amazon Web Services account.</p>
- *          <p>You can allocate an Elastic IP address from an address pool owned by Amazon Web Services or from an address pool created
- *        from a public IPv4 address range that you have brought to Amazon Web Services for use with your Amazon Web Services resources using bring your own
- *          IP addresses (BYOIP). For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-byoip.html">Bring Your Own IP Addresses (BYOIP)</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
- *          <p>[EC2-VPC] If you release an Elastic IP address, you might be able to recover it. You cannot recover an
- *        Elastic IP address that you released after it is allocated to another Amazon Web Services account. You cannot recover an Elastic IP
- *          address for EC2-Classic. To attempt to recover an Elastic IP address that you released, specify it in this operation.</p>
- *          <p>An Elastic IP address is for use either in the EC2-Classic platform or in a VPC. By default, you can allocate
- *          5 Elastic IP addresses for EC2-Classic per Region and 5 Elastic IP addresses for EC2-VPC per Region.</p>
- *          <p>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>You can allocate a carrier IP address which is a public IP address from a telecommunication carrier, to a network interface which resides in a subnet in a Wavelength Zone (for example an EC2 instance). </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, AllocateAddressCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, AllocateAddressCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new AllocateAddressCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AllocateAddressCommandInput} for command's `input` shape.
- * @see {@link AllocateAddressCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AllocateAddressCommand extends $Command<AllocateAddressCommandInput, AllocateAddressCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AllocateAddressCommandInput;
     constructor(input: AllocateAddressCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AllocateAddressCommandInput, AllocateAddressCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface AllocateHostsCommandInput extends AllocateHostsRequest {
 }
 export interface AllocateHostsCommandOutput extends AllocateHostsResult, __MetadataBearer {
 }
-/**
- * <p>Allocates a Dedicated Host to your account. At a minimum, specify the supported instance
- *         	type or instance family, the Availability Zone in which to allocate the host, and the number of
- *         	hosts to allocate.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, AllocateHostsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, AllocateHostsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new AllocateHostsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AllocateHostsCommandInput} for command's `input` shape.
- * @see {@link AllocateHostsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AllocateHostsCommand extends $Command<AllocateHostsCommandInput, AllocateHostsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AllocateHostsCommandInput;
     constructor(input: AllocateHostsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AllocateHostsCommandInput, AllocateHostsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ApplySecurityGroupsToClientVpnTargetNetworkCommandInput extends
 }
 export interface ApplySecurityGroupsToClientVpnTargetNetworkCommandOutput extends ApplySecurityGroupsToClientVpnTargetNetworkResult, __MetadataBearer {
 }
-/**
- * <p>Applies a security group to the association between the target network and the Client VPN endpoint. This action replaces the existing
- * 			security groups with the specified security groups.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ApplySecurityGroupsToClientVpnTargetNetworkCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ApplySecurityGroupsToClientVpnTargetNetworkCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ApplySecurityGroupsToClientVpnTargetNetworkCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ApplySecurityGroupsToClientVpnTargetNetworkCommandInput} for command's `input` shape.
- * @see {@link ApplySecurityGroupsToClientVpnTargetNetworkCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ApplySecurityGroupsToClientVpnTargetNetworkCommand extends $Command<ApplySecurityGroupsToClientVpnTargetNetworkCommandInput, ApplySecurityGroupsToClientVpnTargetNetworkCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ApplySecurityGroupsToClientVpnTargetNetworkCommandInput;
     constructor(input: ApplySecurityGroupsToClientVpnTargetNetworkCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ApplySecurityGroupsToClientVpnTargetNetworkCommandInput, ApplySecurityGroupsToClientVpnTargetNetworkCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,39 +6,11 @@ export interface AssignIpv6AddressesCommandInput extends AssignIpv6AddressesRequ
 }
 export interface AssignIpv6AddressesCommandOutput extends AssignIpv6AddressesResult, __MetadataBearer {
 }
-/**
- * <p>Assigns one or more IPv6 addresses to the specified network interface. You can
- *             specify one or more specific IPv6 addresses, or you can specify the number of IPv6
- *             addresses to be automatically assigned from within the subnet's IPv6 CIDR block range.
- *             You can assign as many IPv6 addresses to a network interface as you can assign private
- *             IPv4 addresses, and the limit varies per instance type. For information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html#AvailableIpPerENI">IP Addresses Per Network Interface Per Instance Type</a>
- *             in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
- *         <p>You must specify either the IPv6 addresses or the IPv6 address count in the request. </p>
- *         <p>You can optionally use Prefix Delegation on the network interface. You must specify
- *             either the IPV6 Prefix Delegation prefixes, or the IPv6 Prefix Delegation count. For
- *             information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-prefix-eni.html">
- *                 Assigning prefixes to Amazon EC2 network interfaces</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, AssignIpv6AddressesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, AssignIpv6AddressesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new AssignIpv6AddressesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AssignIpv6AddressesCommandInput} for command's `input` shape.
- * @see {@link AssignIpv6AddressesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AssignIpv6AddressesCommand extends $Command<AssignIpv6AddressesCommandInput, AssignIpv6AddressesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AssignIpv6AddressesCommandInput;
     constructor(input: AssignIpv6AddressesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssignIpv6AddressesCommandInput, AssignIpv6AddressesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,44 +6,11 @@ export interface AssignPrivateIpAddressesCommandInput extends AssignPrivateIpAdd
 }
 export interface AssignPrivateIpAddressesCommandOutput extends AssignPrivateIpAddressesResult, __MetadataBearer {
 }
-/**
- * <p>Assigns one or more secondary private IP addresses to the specified network interface.</p>
- *         <p>You can specify one or more specific secondary IP addresses, or you can specify the number
- *             of secondary IP addresses to be automatically assigned within the subnet's CIDR block range.
- *             The number of secondary IP addresses that you can assign to an instance varies by instance type.
- *             For information about instance types, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html">Instance Types</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>. For more information about
- *             Elastic IP addresses, 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>When you move a secondary private IP address to another network interface, any Elastic IP address
- *             that is associated with the IP address is also moved.</p>
- *         <p>Remapping an IP address is an asynchronous operation. When you move an IP address from one network
- *             interface to another, check <code>network/interfaces/macs/mac/local-ipv4s</code> in the instance
- *             metadata to confirm that the remapping is complete.</p>
- *         <p>You must specify either the IP addresses or the IP address count in the request.</p>
- *         <p>You can optionally use Prefix Delegation on the network interface. You must specify
- *             either the IPv4 Prefix Delegation prefixes, or the IPv4 Prefix Delegation count. For
- *             information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-prefix-eni.html">
- *                 Assigning prefixes to Amazon EC2 network interfaces</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, AssignPrivateIpAddressesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, AssignPrivateIpAddressesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new AssignPrivateIpAddressesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AssignPrivateIpAddressesCommandInput} for command's `input` shape.
- * @see {@link AssignPrivateIpAddressesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AssignPrivateIpAddressesCommand extends $Command<AssignPrivateIpAddressesCommandInput, AssignPrivateIpAddressesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AssignPrivateIpAddressesCommandInput;
     constructor(input: AssignPrivateIpAddressesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssignPrivateIpAddressesCommandInput, AssignPrivateIpAddressesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,53 +6,11 @@ export interface AssociateAddressCommandInput extends AssociateAddressRequest {
 }
 export interface AssociateAddressCommandOutput extends AssociateAddressResult, __MetadataBearer {
 }
-/**
- * <p>Associates an Elastic IP address, or carrier IP address (for instances that are in
- *       subnets in Wavelength Zones) with an instance or a network interface. Before you can use an
- *       Elastic IP address, you must allocate it to your account.</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>[EC2-Classic, VPC in an EC2-VPC-only account] If the Elastic IP address is already
- *       associated with a different instance, it is disassociated from that instance and associated
- *       with the specified instance. If you associate an Elastic IP address with an instance that has
- *       an existing Elastic IP address, the existing address is disassociated from the instance, but
- *       remains allocated to your account.</p>
- *          <p>[VPC in an EC2-Classic account] If you don't specify a private IP address, the Elastic
- *       IP address is associated with the primary IP address. If the Elastic IP address is already
- *       associated with a different instance or a network interface, you get an error unless you allow
- *       reassociation. You cannot associate an Elastic IP address with an instance or network
- *       interface that has an existing Elastic IP address.</p>
- *          <p>[Subnets in Wavelength Zones] You can associate an IP address from the telecommunication
- *       carrier to the instance or network interface. </p>
- *          <p>You cannot associate an Elastic IP address with an interface in a different network border group.</p>
- *          <important>
- *             <p>This is an idempotent operation. If you perform the operation more than once, Amazon EC2
- *         doesn't return an error, and you may be charged for each time the Elastic IP address is
- *         remapped to the same instance. For more information, see the <i>Elastic IP
- *           Addresses</i> section of <a href="http://aws.amazon.com/ec2/pricing/">Amazon EC2
- *           Pricing</a>.</p>
- *          </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, AssociateAddressCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, AssociateAddressCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new AssociateAddressCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AssociateAddressCommandInput} for command's `input` shape.
- * @see {@link AssociateAddressCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AssociateAddressCommand extends $Command<AssociateAddressCommandInput, AssociateAddressCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AssociateAddressCommandInput;
     constructor(input: AssociateAddressCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateAddressCommandInput, AssociateAddressCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface AssociateClientVpnTargetNetworkCommandInput extends AssociateCl
 }
 export interface AssociateClientVpnTargetNetworkCommandOutput extends AssociateClientVpnTargetNetworkResult, __MetadataBearer {
 }
-/**
- * <p>Associates a target network with a Client VPN endpoint. A target network is a subnet in a VPC. You can associate multiple subnets from the same VPC with a Client VPN endpoint. You can associate only one subnet in each Availability Zone. We recommend that you associate at least two subnets to provide Availability Zone redundancy.</p>
- * 	        <p>If you specified a VPC when you created the Client VPN endpoint or if you have previous subnet associations, the specified subnet must be in the same VPC. To specify a subnet that's in a different VPC, you must first modify the Client VPN endpoint (<a>ModifyClientVpnEndpoint</a>) and change the VPC that's associated with it.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, AssociateClientVpnTargetNetworkCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, AssociateClientVpnTargetNetworkCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new AssociateClientVpnTargetNetworkCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AssociateClientVpnTargetNetworkCommandInput} for command's `input` shape.
- * @see {@link AssociateClientVpnTargetNetworkCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AssociateClientVpnTargetNetworkCommand extends $Command<AssociateClientVpnTargetNetworkCommandInput, AssociateClientVpnTargetNetworkCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AssociateClientVpnTargetNetworkCommandInput;
     constructor(input: AssociateClientVpnTargetNetworkCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateClientVpnTargetNetworkCommandInput, AssociateClientVpnTargetNetworkCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface AssociateDhcpOptionsCommandInput extends AssociateDhcpOptionsRe
 }
 export interface AssociateDhcpOptionsCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Associates a set of DHCP options (that you've previously created) with the specified VPC, or associates no DHCP options with the VPC.</p>
- *          <p>After you associate the options with the VPC, any existing instances and all new instances that you launch in that VPC use the options. You don't need to restart or relaunch the instances. They automatically pick up the changes within a few hours, depending on how frequently the instance renews its DHCP lease. You can explicitly renew the lease using the operating system on the instance.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_DHCP_Options.html">DHCP options sets</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, AssociateDhcpOptionsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, AssociateDhcpOptionsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new AssociateDhcpOptionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AssociateDhcpOptionsCommandInput} for command's `input` shape.
- * @see {@link AssociateDhcpOptionsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AssociateDhcpOptionsCommand extends $Command<AssociateDhcpOptionsCommandInput, AssociateDhcpOptionsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AssociateDhcpOptionsCommandInput;
     constructor(input: AssociateDhcpOptionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateDhcpOptionsCommandInput, AssociateDhcpOptionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,43 +6,11 @@ export interface AssociateEnclaveCertificateIamRoleCommandInput extends Associat
 }
 export interface AssociateEnclaveCertificateIamRoleCommandOutput extends AssociateEnclaveCertificateIamRoleResult, __MetadataBearer {
 }
-/**
- * <p>Associates an Identity and Access Management (IAM) role with an Certificate Manager (ACM) certificate.
- * 			This enables the certificate to be used by the ACM for Nitro Enclaves application inside an enclave. For more
- * 			information, see <a href="https://docs.aws.amazon.com/enclaves/latest/user/nitro-enclave-refapp.html">Certificate Manager for Nitro Enclaves</a> in the <i>Amazon Web Services Nitro Enclaves
- * 					User Guide</i>.</p>
- *
- * 		       <p>When the IAM role is associated with the ACM certificate, the certificate, certificate chain, and encrypted
- * 			private key are placed in an Amazon S3 bucket that only the associated IAM role can access. The private key of the certificate
- * 			is encrypted with an Amazon Web Services managed key that has an attached attestation-based key policy.</p>
- *
- * 		       <p>To enable the IAM role to access the Amazon S3 object, you must grant it permission to call <code>s3:GetObject</code>
- * 			on the Amazon S3 bucket returned by the command. To enable the IAM role to access the KMS key,
- * 			you must grant it permission to call <code>kms:Decrypt</code> on the KMS key returned by the command.
- * 			For more information, see <a href="https://docs.aws.amazon.com/enclaves/latest/user/nitro-enclave-refapp.html#add-policy">
- * 				Grant the role permission to access the certificate and encryption key</a> in the
- * 			<i>Amazon Web Services Nitro Enclaves User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, AssociateEnclaveCertificateIamRoleCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, AssociateEnclaveCertificateIamRoleCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new AssociateEnclaveCertificateIamRoleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AssociateEnclaveCertificateIamRoleCommandInput} for command's `input` shape.
- * @see {@link AssociateEnclaveCertificateIamRoleCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AssociateEnclaveCertificateIamRoleCommand extends $Command<AssociateEnclaveCertificateIamRoleCommandInput, AssociateEnclaveCertificateIamRoleCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AssociateEnclaveCertificateIamRoleCommandInput;
     constructor(input: AssociateEnclaveCertificateIamRoleCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateEnclaveCertificateIamRoleCommandInput, AssociateEnclaveCertificateIamRoleCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface AssociateIamInstanceProfileCommandInput extends AssociateIamIns
 }
 export interface AssociateIamInstanceProfileCommandOutput extends AssociateIamInstanceProfileResult, __MetadataBearer {
 }
-/**
- * <p>Associates an IAM instance profile with a running or stopped instance. You cannot
- *             associate more than one IAM instance profile with an instance.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, AssociateIamInstanceProfileCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, AssociateIamInstanceProfileCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new AssociateIamInstanceProfileCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AssociateIamInstanceProfileCommandInput} for command's `input` shape.
- * @see {@link AssociateIamInstanceProfileCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AssociateIamInstanceProfileCommand extends $Command<AssociateIamInstanceProfileCommandInput, AssociateIamInstanceProfileCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AssociateIamInstanceProfileCommandInput;
     constructor(input: AssociateIamInstanceProfileCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateIamInstanceProfileCommandInput, AssociateIamInstanceProfileCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface AssociateInstanceEventWindowCommandInput extends AssociateInsta
 }
 export interface AssociateInstanceEventWindowCommandOutput extends AssociateInstanceEventWindowResult, __MetadataBearer {
 }
-/**
- * <p>Associates one or more targets with an event window. Only one type of target (instance IDs,
- *          Dedicated Host IDs, or tags) can be specified with 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, AssociateInstanceEventWindowCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, AssociateInstanceEventWindowCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new AssociateInstanceEventWindowCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AssociateInstanceEventWindowCommandInput} for command's `input` shape.
- * @see {@link AssociateInstanceEventWindowCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AssociateInstanceEventWindowCommand extends $Command<AssociateInstanceEventWindowCommandInput, AssociateInstanceEventWindowCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AssociateInstanceEventWindowCommandInput;
     constructor(input: AssociateInstanceEventWindowCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateInstanceEventWindowCommandInput, AssociateInstanceEventWindowCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface AssociateRouteTableCommandInput extends AssociateRouteTableRequ
 }
 export interface AssociateRouteTableCommandOutput extends AssociateRouteTableResult, __MetadataBearer {
 }
-/**
- * <p>Associates a subnet in your VPC or an internet gateway or virtual private gateway
- *             attached to your VPC with a route table in your VPC. This association causes traffic
- *             from the subnet or gateway to be routed according to the routes in the route table. The
- *             action returns an association ID, which you need in order to disassociate the route
- *             table later. A route table can be associated with multiple subnets.</p>
- *         <p>For more information, 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, AssociateRouteTableCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, AssociateRouteTableCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new AssociateRouteTableCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AssociateRouteTableCommandInput} for command's `input` shape.
- * @see {@link AssociateRouteTableCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AssociateRouteTableCommand extends $Command<AssociateRouteTableCommandInput, AssociateRouteTableCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AssociateRouteTableCommandInput;
     constructor(input: AssociateRouteTableCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateRouteTableCommandInput, AssociateRouteTableCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface AssociateSubnetCidrBlockCommandInput extends AssociateSubnetCid
 }
 export interface AssociateSubnetCidrBlockCommandOutput extends AssociateSubnetCidrBlockResult, __MetadataBearer {
 }
-/**
- * <p>Associates a CIDR block with your subnet. You can only associate a single IPv6 CIDR
- *             block with your subnet. An IPv6 CIDR block must have a prefix length of /64.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, AssociateSubnetCidrBlockCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, AssociateSubnetCidrBlockCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new AssociateSubnetCidrBlockCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AssociateSubnetCidrBlockCommandInput} for command's `input` shape.
- * @see {@link AssociateSubnetCidrBlockCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AssociateSubnetCidrBlockCommand extends $Command<AssociateSubnetCidrBlockCommandInput, AssociateSubnetCidrBlockCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AssociateSubnetCidrBlockCommandInput;
     constructor(input: AssociateSubnetCidrBlockCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateSubnetCidrBlockCommandInput, AssociateSubnetCidrBlockCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface AssociateTransitGatewayMulticastDomainCommandInput extends Asso
 }
 export interface AssociateTransitGatewayMulticastDomainCommandOutput extends AssociateTransitGatewayMulticastDomainResult, __MetadataBearer {
 }
-/**
- * <p>Associates the specified subnets and transit gateway attachments with the specified transit gateway multicast domain.</p>
- *         <p>The transit gateway attachment must be in the available state before you can add a resource. Use <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeTransitGatewayAttachments.html">DescribeTransitGatewayAttachments</a>
- *             to see the state of the attachment.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, AssociateTransitGatewayMulticastDomainCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, AssociateTransitGatewayMulticastDomainCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new AssociateTransitGatewayMulticastDomainCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AssociateTransitGatewayMulticastDomainCommandInput} for command's `input` shape.
- * @see {@link AssociateTransitGatewayMulticastDomainCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AssociateTransitGatewayMulticastDomainCommand extends $Command<AssociateTransitGatewayMulticastDomainCommandInput, AssociateTransitGatewayMulticastDomainCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AssociateTransitGatewayMulticastDomainCommandInput;
     constructor(input: AssociateTransitGatewayMulticastDomainCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateTransitGatewayMulticastDomainCommandInput, AssociateTransitGatewayMulticastDomainCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,36 +6,11 @@ export interface AssociateTrunkInterfaceCommandInput extends AssociateTrunkInter
 }
 export interface AssociateTrunkInterfaceCommandOutput extends AssociateTrunkInterfaceResult, __MetadataBearer {
 }
-/**
- * <note>
- *             <p>This API action is currently in <b>limited preview only</b>.
- *                 If you are interested in using this feature, contact your account manager.</p>
- *         </note>
- *
- *         <p>Associates a branch network interface with a trunk network interface.</p>
- *         <p>Before you create the association, run the <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateNetworkInterface.html">create-network-interface</a> command and set
- *             <code>--interface-type</code> to <code>trunk</code>. You must also create a network interface for each branch network interface that you want to associate with the trunk network interface.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, AssociateTrunkInterfaceCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, AssociateTrunkInterfaceCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new AssociateTrunkInterfaceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AssociateTrunkInterfaceCommandInput} for command's `input` shape.
- * @see {@link AssociateTrunkInterfaceCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AssociateTrunkInterfaceCommand extends $Command<AssociateTrunkInterfaceCommandInput, AssociateTrunkInterfaceCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AssociateTrunkInterfaceCommandInput;
     constructor(input: AssociateTrunkInterfaceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateTrunkInterfaceCommandInput, AssociateTrunkInterfaceCommandOutput>;
     private serialize;
     private deserialize;