@aws-sdk/client-ec2 3.296.0 → 3.297.0

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { AllocateHostsRequest, AllocateHostsResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link AllocateHostsCommand}.
  */
 export interface AllocateHostsCommandInput extends AllocateHostsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link AllocateHostsCommand}.
  */
 export interface AllocateHostsCommandOutput extends AllocateHostsResult, __MetadataBearer {
 }
 /**
+ * @public
  * <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>
@@ -27,6 +32,8 @@ export interface AllocateHostsCommandOutput extends AllocateHostsResult, __Metad
  * const response = await client.send(command);
  * ```
  *
+ * @param AllocateHostsCommandInput - {@link AllocateHostsCommandInput}
+ * @returns {@link AllocateHostsCommandOutput}
  * @see {@link AllocateHostsCommandInput} for command's `input` shape.
  * @see {@link AllocateHostsCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -36,11 +43,20 @@ export interface AllocateHostsCommandOutput extends AllocateHostsResult, __Metad
 export declare class AllocateHostsCommand extends $Command<AllocateHostsCommandInput, AllocateHostsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AllocateHostsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: AllocateHostsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AllocateHostsCommandInput, AllocateHostsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/AllocateIpamPoolCidrCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { AllocateIpamPoolCidrRequest, AllocateIpamPoolCidrResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link AllocateIpamPoolCidrCommand}.
  */
 export interface AllocateIpamPoolCidrCommandInput extends AllocateIpamPoolCidrRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link AllocateIpamPoolCidrCommand}.
  */
 export interface AllocateIpamPoolCidrCommandOutput extends AllocateIpamPoolCidrResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Allocate a CIDR from an IPAM pool. In IPAM, an allocation is a CIDR assignment from an IPAM pool to another IPAM pool or to a resource. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/ipam/allocate-cidrs-ipam.html">Allocate CIDRs</a> in the <i>Amazon VPC IPAM User Guide</i>.</p>
  *          <note>
  *             <p>This action creates an allocation with strong consistency. The returned CIDR will not overlap with any other allocations from the same pool.</p>
@@ -28,6 +33,8 @@ export interface AllocateIpamPoolCidrCommandOutput extends AllocateIpamPoolCidrR
  * const response = await client.send(command);
  * ```
  *
+ * @param AllocateIpamPoolCidrCommandInput - {@link AllocateIpamPoolCidrCommandInput}
+ * @returns {@link AllocateIpamPoolCidrCommandOutput}
  * @see {@link AllocateIpamPoolCidrCommandInput} for command's `input` shape.
  * @see {@link AllocateIpamPoolCidrCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -37,11 +44,20 @@ export interface AllocateIpamPoolCidrCommandOutput extends AllocateIpamPoolCidrR
 export declare class AllocateIpamPoolCidrCommand extends $Command<AllocateIpamPoolCidrCommandInput, AllocateIpamPoolCidrCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AllocateIpamPoolCidrCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: AllocateIpamPoolCidrCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AllocateIpamPoolCidrCommandInput, AllocateIpamPoolCidrCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { ApplySecurityGroupsToClientVpnTargetNetworkRequest, ApplySecurityGroupsToClientVpnTargetNetworkResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link ApplySecurityGroupsToClientVpnTargetNetworkCommand}.
  */
 export interface ApplySecurityGroupsToClientVpnTargetNetworkCommandInput extends ApplySecurityGroupsToClientVpnTargetNetworkRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ApplySecurityGroupsToClientVpnTargetNetworkCommand}.
  */
 export interface ApplySecurityGroupsToClientVpnTargetNetworkCommandOutput extends ApplySecurityGroupsToClientVpnTargetNetworkResult, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -26,6 +31,8 @@ export interface ApplySecurityGroupsToClientVpnTargetNetworkCommandOutput extend
  * const response = await client.send(command);
  * ```
  *
+ * @param ApplySecurityGroupsToClientVpnTargetNetworkCommandInput - {@link ApplySecurityGroupsToClientVpnTargetNetworkCommandInput}
+ * @returns {@link ApplySecurityGroupsToClientVpnTargetNetworkCommandOutput}
  * @see {@link ApplySecurityGroupsToClientVpnTargetNetworkCommandInput} for command's `input` shape.
  * @see {@link ApplySecurityGroupsToClientVpnTargetNetworkCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -35,11 +42,20 @@ export interface ApplySecurityGroupsToClientVpnTargetNetworkCommandOutput extend
 export declare class ApplySecurityGroupsToClientVpnTargetNetworkCommand extends $Command<ApplySecurityGroupsToClientVpnTargetNetworkCommandInput, ApplySecurityGroupsToClientVpnTargetNetworkCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ApplySecurityGroupsToClientVpnTargetNetworkCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ApplySecurityGroupsToClientVpnTargetNetworkCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ApplySecurityGroupsToClientVpnTargetNetworkCommandInput, ApplySecurityGroupsToClientVpnTargetNetworkCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { AssignIpv6AddressesRequest, AssignIpv6AddressesResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link AssignIpv6AddressesCommand}.
  */
 export interface AssignIpv6AddressesCommandInput extends AssignIpv6AddressesRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link AssignIpv6AddressesCommand}.
  */
 export interface AssignIpv6AddressesCommandOutput extends AssignIpv6AddressesResult, __MetadataBearer {
 }
 /**
+ * @public
  * <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.
@@ -35,6 +40,8 @@ export interface AssignIpv6AddressesCommandOutput extends AssignIpv6AddressesRes
  * const response = await client.send(command);
  * ```
  *
+ * @param AssignIpv6AddressesCommandInput - {@link AssignIpv6AddressesCommandInput}
+ * @returns {@link AssignIpv6AddressesCommandOutput}
  * @see {@link AssignIpv6AddressesCommandInput} for command's `input` shape.
  * @see {@link AssignIpv6AddressesCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -44,11 +51,20 @@ export interface AssignIpv6AddressesCommandOutput extends AssignIpv6AddressesRes
 export declare class AssignIpv6AddressesCommand extends $Command<AssignIpv6AddressesCommandInput, AssignIpv6AddressesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AssignIpv6AddressesCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: AssignIpv6AddressesCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssignIpv6AddressesCommandInput, AssignIpv6AddressesCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { AssignPrivateIpAddressesRequest, AssignPrivateIpAddressesResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link AssignPrivateIpAddressesCommand}.
  */
 export interface AssignPrivateIpAddressesCommandInput extends AssignPrivateIpAddressesRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link AssignPrivateIpAddressesCommand}.
  */
 export interface AssignPrivateIpAddressesCommandOutput extends AssignPrivateIpAddressesResult, __MetadataBearer {
 }
 /**
+ * @public
  * <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.
@@ -40,6 +45,8 @@ export interface AssignPrivateIpAddressesCommandOutput extends AssignPrivateIpAd
  * const response = await client.send(command);
  * ```
  *
+ * @param AssignPrivateIpAddressesCommandInput - {@link AssignPrivateIpAddressesCommandInput}
+ * @returns {@link AssignPrivateIpAddressesCommandOutput}
  * @see {@link AssignPrivateIpAddressesCommandInput} for command's `input` shape.
  * @see {@link AssignPrivateIpAddressesCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -75,11 +82,20 @@ export interface AssignPrivateIpAddressesCommandOutput extends AssignPrivateIpAd
 export declare class AssignPrivateIpAddressesCommand extends $Command<AssignPrivateIpAddressesCommandInput, AssignPrivateIpAddressesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AssignPrivateIpAddressesCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: AssignPrivateIpAddressesCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssignPrivateIpAddressesCommandInput, AssignPrivateIpAddressesCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/AssignPrivateNatGatewayAddressCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { AssignPrivateNatGatewayAddressRequest, AssignPrivateNatGatewayAddressResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link AssignPrivateNatGatewayAddressCommand}.
  */
 export interface AssignPrivateNatGatewayAddressCommandInput extends AssignPrivateNatGatewayAddressRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link AssignPrivateNatGatewayAddressCommand}.
  */
 export interface AssignPrivateNatGatewayAddressCommandOutput extends AssignPrivateNatGatewayAddressResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Assigns one or more private IPv4 addresses to a private NAT gateway. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-working-with">Work with NAT gateways</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.
@@ -25,6 +30,8 @@ export interface AssignPrivateNatGatewayAddressCommandOutput extends AssignPriva
  * const response = await client.send(command);
  * ```
  *
+ * @param AssignPrivateNatGatewayAddressCommandInput - {@link AssignPrivateNatGatewayAddressCommandInput}
+ * @returns {@link AssignPrivateNatGatewayAddressCommandOutput}
  * @see {@link AssignPrivateNatGatewayAddressCommandInput} for command's `input` shape.
  * @see {@link AssignPrivateNatGatewayAddressCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -34,11 +41,20 @@ export interface AssignPrivateNatGatewayAddressCommandOutput extends AssignPriva
 export declare class AssignPrivateNatGatewayAddressCommand extends $Command<AssignPrivateNatGatewayAddressCommandInput, AssignPrivateNatGatewayAddressCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AssignPrivateNatGatewayAddressCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: AssignPrivateNatGatewayAddressCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssignPrivateNatGatewayAddressCommandInput, AssignPrivateNatGatewayAddressCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { AssociateAddressRequest, AssociateAddressResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link AssociateAddressCommand}.
  */
 export interface AssociateAddressCommandInput extends AssociateAddressRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link AssociateAddressCommand}.
  */
 export interface AssociateAddressCommandOutput extends AssociateAddressResult, __MetadataBearer {
 }
 /**
+ * @public
  * <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>
@@ -52,6 +57,8 @@ export interface AssociateAddressCommandOutput extends AssociateAddressResult, _
  * const response = await client.send(command);
  * ```
  *
+ * @param AssociateAddressCommandInput - {@link AssociateAddressCommandInput}
+ * @returns {@link AssociateAddressCommandOutput}
  * @see {@link AssociateAddressCommandInput} for command's `input` shape.
  * @see {@link AssociateAddressCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -107,11 +114,20 @@ export interface AssociateAddressCommandOutput extends AssociateAddressResult, _
 export declare class AssociateAddressCommand extends $Command<AssociateAddressCommandInput, AssociateAddressCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AssociateAddressCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: AssociateAddressCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateAddressCommandInput, AssociateAddressCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { AssociateClientVpnTargetNetworkRequest, AssociateClientVpnTargetNetworkResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link AssociateClientVpnTargetNetworkCommand}.
  */
 export interface AssociateClientVpnTargetNetworkCommandInput extends AssociateClientVpnTargetNetworkRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link AssociateClientVpnTargetNetworkCommand}.
  */
 export interface AssociateClientVpnTargetNetworkCommandOutput extends AssociateClientVpnTargetNetworkResult, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -26,6 +31,8 @@ export interface AssociateClientVpnTargetNetworkCommandOutput extends AssociateC
  * const response = await client.send(command);
  * ```
  *
+ * @param AssociateClientVpnTargetNetworkCommandInput - {@link AssociateClientVpnTargetNetworkCommandInput}
+ * @returns {@link AssociateClientVpnTargetNetworkCommandOutput}
  * @see {@link AssociateClientVpnTargetNetworkCommandInput} for command's `input` shape.
  * @see {@link AssociateClientVpnTargetNetworkCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -35,11 +42,20 @@ export interface AssociateClientVpnTargetNetworkCommandOutput extends AssociateC
 export declare class AssociateClientVpnTargetNetworkCommand extends $Command<AssociateClientVpnTargetNetworkCommandInput, AssociateClientVpnTargetNetworkCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AssociateClientVpnTargetNetworkCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: AssociateClientVpnTargetNetworkCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateClientVpnTargetNetworkCommandInput, AssociateClientVpnTargetNetworkCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { AssociateDhcpOptionsRequest } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link AssociateDhcpOptionsCommand}.
  */
 export interface AssociateDhcpOptionsCommandInput extends AssociateDhcpOptionsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link AssociateDhcpOptionsCommand}.
  */
 export interface AssociateDhcpOptionsCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <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>
@@ -28,6 +33,8 @@ export interface AssociateDhcpOptionsCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param AssociateDhcpOptionsCommandInput - {@link AssociateDhcpOptionsCommandInput}
+ * @returns {@link AssociateDhcpOptionsCommandOutput}
  * @see {@link AssociateDhcpOptionsCommandInput} for command's `input` shape.
  * @see {@link AssociateDhcpOptionsCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -61,11 +68,20 @@ export interface AssociateDhcpOptionsCommandOutput extends __MetadataBearer {
 export declare class AssociateDhcpOptionsCommand extends $Command<AssociateDhcpOptionsCommandInput, AssociateDhcpOptionsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AssociateDhcpOptionsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: AssociateDhcpOptionsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateDhcpOptionsCommandInput, AssociateDhcpOptionsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { AssociateEnclaveCertificateIamRoleRequest, AssociateEnclaveCertificateIamRoleResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link AssociateEnclaveCertificateIamRoleCommand}.
  */
 export interface AssociateEnclaveCertificateIamRoleCommandInput extends AssociateEnclaveCertificateIamRoleRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link AssociateEnclaveCertificateIamRoleCommand}.
  */
 export interface AssociateEnclaveCertificateIamRoleCommandOutput extends AssociateEnclaveCertificateIamRoleResult, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -37,6 +42,8 @@ export interface AssociateEnclaveCertificateIamRoleCommandOutput extends Associa
  * const response = await client.send(command);
  * ```
  *
+ * @param AssociateEnclaveCertificateIamRoleCommandInput - {@link AssociateEnclaveCertificateIamRoleCommandInput}
+ * @returns {@link AssociateEnclaveCertificateIamRoleCommandOutput}
  * @see {@link AssociateEnclaveCertificateIamRoleCommandInput} for command's `input` shape.
  * @see {@link AssociateEnclaveCertificateIamRoleCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -46,11 +53,20 @@ export interface AssociateEnclaveCertificateIamRoleCommandOutput extends Associa
 export declare class AssociateEnclaveCertificateIamRoleCommand extends $Command<AssociateEnclaveCertificateIamRoleCommandInput, AssociateEnclaveCertificateIamRoleCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AssociateEnclaveCertificateIamRoleCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: AssociateEnclaveCertificateIamRoleCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateEnclaveCertificateIamRoleCommandInput, AssociateEnclaveCertificateIamRoleCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { AssociateIamInstanceProfileRequest, AssociateIamInstanceProfileResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link AssociateIamInstanceProfileCommand}.
  */
 export interface AssociateIamInstanceProfileCommandInput extends AssociateIamInstanceProfileRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link AssociateIamInstanceProfileCommand}.
  */
 export interface AssociateIamInstanceProfileCommandOutput extends AssociateIamInstanceProfileResult, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -26,6 +31,8 @@ export interface AssociateIamInstanceProfileCommandOutput extends AssociateIamIn
  * const response = await client.send(command);
  * ```
  *
+ * @param AssociateIamInstanceProfileCommandInput - {@link AssociateIamInstanceProfileCommandInput}
+ * @returns {@link AssociateIamInstanceProfileCommandOutput}
  * @see {@link AssociateIamInstanceProfileCommandInput} for command's `input` shape.
  * @see {@link AssociateIamInstanceProfileCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -62,11 +69,20 @@ export interface AssociateIamInstanceProfileCommandOutput extends AssociateIamIn
 export declare class AssociateIamInstanceProfileCommand extends $Command<AssociateIamInstanceProfileCommandInput, AssociateIamInstanceProfileCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AssociateIamInstanceProfileCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: AssociateIamInstanceProfileCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateIamInstanceProfileCommandInput, AssociateIamInstanceProfileCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { AssociateInstanceEventWindowRequest, AssociateInstanceEventWindowResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link AssociateInstanceEventWindowCommand}.
  */
 export interface AssociateInstanceEventWindowCommandInput extends AssociateInstanceEventWindowRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link AssociateInstanceEventWindowCommand}.
  */
 export interface AssociateInstanceEventWindowCommandOutput extends AssociateInstanceEventWindowResult, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -28,6 +33,8 @@ export interface AssociateInstanceEventWindowCommandOutput extends AssociateInst
  * const response = await client.send(command);
  * ```
  *
+ * @param AssociateInstanceEventWindowCommandInput - {@link AssociateInstanceEventWindowCommandInput}
+ * @returns {@link AssociateInstanceEventWindowCommandOutput}
  * @see {@link AssociateInstanceEventWindowCommandInput} for command's `input` shape.
  * @see {@link AssociateInstanceEventWindowCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -37,11 +44,20 @@ export interface AssociateInstanceEventWindowCommandOutput extends AssociateInst
 export declare class AssociateInstanceEventWindowCommand extends $Command<AssociateInstanceEventWindowCommandInput, AssociateInstanceEventWindowCommandOutput, EC2ClientResolvedConfig> {
     readonly input: AssociateInstanceEventWindowCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: AssociateInstanceEventWindowCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateInstanceEventWindowCommandInput, AssociateInstanceEventWindowCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }