@aws-sdk/client-ec2 3.295.0 → 3.297.0

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateClientVpnEndpointRequest, CreateClientVpnEndpointResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateClientVpnEndpointCommand}.
  */
 export interface CreateClientVpnEndpointCommandInput extends CreateClientVpnEndpointRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateClientVpnEndpointCommand}.
  */
 export interface CreateClientVpnEndpointCommandOutput extends CreateClientVpnEndpointResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a Client VPN endpoint. A Client VPN endpoint is the resource you create and configure to
  * 			enable and manage client VPN sessions. It is the destination endpoint at which all client VPN sessions
  * 			are terminated.</p>
@@ -27,6 +32,8 @@ export interface CreateClientVpnEndpointCommandOutput extends CreateClientVpnEnd
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateClientVpnEndpointCommandInput - {@link CreateClientVpnEndpointCommandInput}
+ * @returns {@link CreateClientVpnEndpointCommandOutput}
  * @see {@link CreateClientVpnEndpointCommandInput} for command's `input` shape.
  * @see {@link CreateClientVpnEndpointCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -36,11 +43,20 @@ export interface CreateClientVpnEndpointCommandOutput extends CreateClientVpnEnd
 export declare class CreateClientVpnEndpointCommand extends $Command<CreateClientVpnEndpointCommandInput, CreateClientVpnEndpointCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateClientVpnEndpointCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateClientVpnEndpointCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateClientVpnEndpointCommandInput, CreateClientVpnEndpointCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateClientVpnRouteRequest, CreateClientVpnRouteResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateClientVpnRouteCommand}.
  */
 export interface CreateClientVpnRouteCommandInput extends CreateClientVpnRouteRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateClientVpnRouteCommand}.
  */
 export interface CreateClientVpnRouteCommandOutput extends CreateClientVpnRouteResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Adds a route to a network to a Client VPN endpoint. Each Client VPN endpoint has a route table that describes the
  * 			available destination network routes. Each route in the route table specifies the path for traffic to specific resources or networks.</p>
  * @example
@@ -26,6 +31,8 @@ export interface CreateClientVpnRouteCommandOutput extends CreateClientVpnRouteR
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateClientVpnRouteCommandInput - {@link CreateClientVpnRouteCommandInput}
+ * @returns {@link CreateClientVpnRouteCommandOutput}
  * @see {@link CreateClientVpnRouteCommandInput} for command's `input` shape.
  * @see {@link CreateClientVpnRouteCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -35,11 +42,20 @@ export interface CreateClientVpnRouteCommandOutput extends CreateClientVpnRouteR
 export declare class CreateClientVpnRouteCommand extends $Command<CreateClientVpnRouteCommandInput, CreateClientVpnRouteCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateClientVpnRouteCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateClientVpnRouteCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateClientVpnRouteCommandInput, CreateClientVpnRouteCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateCoipCidrRequest, CreateCoipCidrResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateCoipCidrCommand}.
  */
 export interface CreateCoipCidrCommandInput extends CreateCoipCidrRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateCoipCidrCommand}.
  */
 export interface CreateCoipCidrCommandOutput extends CreateCoipCidrResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>
  *      Creates a range of customer-owned IP addresses.
  *       </p>
@@ -27,6 +32,8 @@ export interface CreateCoipCidrCommandOutput extends CreateCoipCidrResult, __Met
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateCoipCidrCommandInput - {@link CreateCoipCidrCommandInput}
+ * @returns {@link CreateCoipCidrCommandOutput}
  * @see {@link CreateCoipCidrCommandInput} for command's `input` shape.
  * @see {@link CreateCoipCidrCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -36,11 +43,20 @@ export interface CreateCoipCidrCommandOutput extends CreateCoipCidrResult, __Met
 export declare class CreateCoipCidrCommand extends $Command<CreateCoipCidrCommandInput, CreateCoipCidrCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateCoipCidrCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateCoipCidrCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateCoipCidrCommandInput, CreateCoipCidrCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateCoipPoolRequest, CreateCoipPoolResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateCoipPoolCommand}.
  */
 export interface CreateCoipPoolCommandInput extends CreateCoipPoolRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateCoipPoolCommand}.
  */
 export interface CreateCoipPoolCommandOutput extends CreateCoipPoolResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p> Creates a pool of customer-owned IP (CoIP) addresses. </p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface CreateCoipPoolCommandOutput extends CreateCoipPoolResult, __Met
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateCoipPoolCommandInput - {@link CreateCoipPoolCommandInput}
+ * @returns {@link CreateCoipPoolCommandOutput}
  * @see {@link CreateCoipPoolCommandInput} for command's `input` shape.
  * @see {@link CreateCoipPoolCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -34,11 +41,20 @@ export interface CreateCoipPoolCommandOutput extends CreateCoipPoolResult, __Met
 export declare class CreateCoipPoolCommand extends $Command<CreateCoipPoolCommandInput, CreateCoipPoolCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateCoipPoolCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateCoipPoolCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateCoipPoolCommandInput, CreateCoipPoolCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateCustomerGatewayRequest, CreateCustomerGatewayResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateCustomerGatewayCommand}.
  */
 export interface CreateCustomerGatewayCommandInput extends CreateCustomerGatewayRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateCustomerGatewayCommand}.
  */
 export interface CreateCustomerGatewayCommandOutput extends CreateCustomerGatewayResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Provides information to Amazon Web Services about your customer gateway device. The
  *             customer gateway device is the appliance at your end of the VPN connection. You
  *             must provide the IP address of the customer gateway device’s external
@@ -38,6 +43,8 @@ export interface CreateCustomerGatewayCommandOutput extends CreateCustomerGatewa
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateCustomerGatewayCommandInput - {@link CreateCustomerGatewayCommandInput}
+ * @returns {@link CreateCustomerGatewayCommandOutput}
  * @see {@link CreateCustomerGatewayCommandInput} for command's `input` shape.
  * @see {@link CreateCustomerGatewayCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -71,11 +78,20 @@ export interface CreateCustomerGatewayCommandOutput extends CreateCustomerGatewa
 export declare class CreateCustomerGatewayCommand extends $Command<CreateCustomerGatewayCommandInput, CreateCustomerGatewayCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateCustomerGatewayCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateCustomerGatewayCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateCustomerGatewayCommandInput, CreateCustomerGatewayCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateDefaultSubnetRequest, CreateDefaultSubnetResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateDefaultSubnetCommand}.
  */
 export interface CreateDefaultSubnetCommandInput extends CreateDefaultSubnetRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateDefaultSubnetCommand}.
  */
 export interface CreateDefaultSubnetCommandOutput extends CreateDefaultSubnetResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a default subnet with a size <code>/20</code> IPv4 CIDR block in the
  *             specified Availability Zone in your default VPC. You can have only one default subnet
  *             per Availability Zone. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html#create-default-subnet">Creating a default
@@ -28,6 +33,8 @@ export interface CreateDefaultSubnetCommandOutput extends CreateDefaultSubnetRes
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateDefaultSubnetCommandInput - {@link CreateDefaultSubnetCommandInput}
+ * @returns {@link CreateDefaultSubnetCommandOutput}
  * @see {@link CreateDefaultSubnetCommandInput} for command's `input` shape.
  * @see {@link CreateDefaultSubnetCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -37,11 +44,20 @@ export interface CreateDefaultSubnetCommandOutput extends CreateDefaultSubnetRes
 export declare class CreateDefaultSubnetCommand extends $Command<CreateDefaultSubnetCommandInput, CreateDefaultSubnetCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateDefaultSubnetCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateDefaultSubnetCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDefaultSubnetCommandInput, CreateDefaultSubnetCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateDefaultVpcRequest, CreateDefaultVpcResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateDefaultVpcCommand}.
  */
 export interface CreateDefaultVpcCommandInput extends CreateDefaultVpcRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateDefaultVpcCommand}.
  */
 export interface CreateDefaultVpcCommandOutput extends CreateDefaultVpcResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a default VPC with a size <code>/16</code> IPv4 CIDR block and a default subnet
  * 			in each Availability Zone. For more information about the components of a default VPC,
  * 			see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html">Default VPC and
@@ -39,6 +44,8 @@ export interface CreateDefaultVpcCommandOutput extends CreateDefaultVpcResult, _
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateDefaultVpcCommandInput - {@link CreateDefaultVpcCommandInput}
+ * @returns {@link CreateDefaultVpcCommandOutput}
  * @see {@link CreateDefaultVpcCommandInput} for command's `input` shape.
  * @see {@link CreateDefaultVpcCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -48,11 +55,20 @@ export interface CreateDefaultVpcCommandOutput extends CreateDefaultVpcResult, _
 export declare class CreateDefaultVpcCommand extends $Command<CreateDefaultVpcCommandInput, CreateDefaultVpcCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateDefaultVpcCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateDefaultVpcCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDefaultVpcCommandInput, CreateDefaultVpcCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateDhcpOptionsRequest, CreateDhcpOptionsResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateDhcpOptionsCommand}.
  */
 export interface CreateDhcpOptionsCommandInput extends CreateDhcpOptionsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateDhcpOptionsCommand}.
  */
 export interface CreateDhcpOptionsCommandOutput extends CreateDhcpOptionsResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a set of DHCP options for your VPC. After creating the set, you must
  * 				associate it with the VPC, causing all existing and new instances that you launch in
  * 				the VPC to use this set of DHCP options. The following are the individual DHCP
@@ -76,6 +81,8 @@ export interface CreateDhcpOptionsCommandOutput extends CreateDhcpOptionsResult,
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateDhcpOptionsCommandInput - {@link CreateDhcpOptionsCommandInput}
+ * @returns {@link CreateDhcpOptionsCommandOutput}
  * @see {@link CreateDhcpOptionsCommandInput} for command's `input` shape.
  * @see {@link CreateDhcpOptionsCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -124,11 +131,20 @@ export interface CreateDhcpOptionsCommandOutput extends CreateDhcpOptionsResult,
 export declare class CreateDhcpOptionsCommand extends $Command<CreateDhcpOptionsCommandInput, CreateDhcpOptionsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateDhcpOptionsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateDhcpOptionsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDhcpOptionsCommandInput, CreateDhcpOptionsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateEgressOnlyInternetGatewayRequest, CreateEgressOnlyInternetGatewayResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateEgressOnlyInternetGatewayCommand}.
  */
 export interface CreateEgressOnlyInternetGatewayCommandInput extends CreateEgressOnlyInternetGatewayRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateEgressOnlyInternetGatewayCommand}.
  */
 export interface CreateEgressOnlyInternetGatewayCommandOutput extends CreateEgressOnlyInternetGatewayResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>[IPv6 only] Creates an egress-only internet gateway for your VPC. An egress-only
  * 			internet gateway is used to enable outbound communication over IPv6 from instances in
  * 			your VPC to the internet, and prevents hosts outside of your VPC from initiating an IPv6
@@ -28,6 +33,8 @@ export interface CreateEgressOnlyInternetGatewayCommandOutput extends CreateEgre
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateEgressOnlyInternetGatewayCommandInput - {@link CreateEgressOnlyInternetGatewayCommandInput}
+ * @returns {@link CreateEgressOnlyInternetGatewayCommandOutput}
  * @see {@link CreateEgressOnlyInternetGatewayCommandInput} for command's `input` shape.
  * @see {@link CreateEgressOnlyInternetGatewayCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -37,11 +44,20 @@ export interface CreateEgressOnlyInternetGatewayCommandOutput extends CreateEgre
 export declare class CreateEgressOnlyInternetGatewayCommand extends $Command<CreateEgressOnlyInternetGatewayCommandInput, CreateEgressOnlyInternetGatewayCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateEgressOnlyInternetGatewayCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateEgressOnlyInternetGatewayCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateEgressOnlyInternetGatewayCommandInput, CreateEgressOnlyInternetGatewayCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateFleetRequest, CreateFleetResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateFleetCommand}.
  */
 export interface CreateFleetCommandInput extends CreateFleetRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateFleetCommand}.
  */
 export interface CreateFleetCommandOutput extends CreateFleetResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Launches an EC2 Fleet.</p>
  *          <p>You can create a single EC2 Fleet that includes multiple launch specifications that vary by
  *          instance type, AMI, Availability Zone, or subnet.</p>
@@ -28,6 +33,8 @@ export interface CreateFleetCommandOutput extends CreateFleetResult, __MetadataB
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateFleetCommandInput - {@link CreateFleetCommandInput}
+ * @returns {@link CreateFleetCommandOutput}
  * @see {@link CreateFleetCommandInput} for command's `input` shape.
  * @see {@link CreateFleetCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -37,11 +44,20 @@ export interface CreateFleetCommandOutput extends CreateFleetResult, __MetadataB
 export declare class CreateFleetCommand extends $Command<CreateFleetCommandInput, CreateFleetCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateFleetCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateFleetCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateFleetCommandInput, CreateFleetCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateFlowLogsRequest, CreateFlowLogsResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateFlowLogsCommand}.
  */
 export interface CreateFlowLogsCommandInput extends CreateFlowLogsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateFlowLogsCommand}.
  */
 export interface CreateFlowLogsCommandOutput extends CreateFlowLogsResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates one or more flow logs to capture information about IP traffic for a specific network interface,
  *             subnet, or VPC. </p>
  *          <p>Flow log data for a monitored network interface is recorded as flow log records, which are log events
@@ -35,6 +40,8 @@ export interface CreateFlowLogsCommandOutput extends CreateFlowLogsResult, __Met
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateFlowLogsCommandInput - {@link CreateFlowLogsCommandInput}
+ * @returns {@link CreateFlowLogsCommandOutput}
  * @see {@link CreateFlowLogsCommandInput} for command's `input` shape.
  * @see {@link CreateFlowLogsCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -44,11 +51,20 @@ export interface CreateFlowLogsCommandOutput extends CreateFlowLogsResult, __Met
 export declare class CreateFlowLogsCommand extends $Command<CreateFlowLogsCommandInput, CreateFlowLogsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateFlowLogsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateFlowLogsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateFlowLogsCommandInput, CreateFlowLogsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateFpgaImageRequest, CreateFpgaImageResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateFpgaImageCommand}.
  */
 export interface CreateFpgaImageCommandInput extends CreateFpgaImageRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateFpgaImageCommand}.
  */
 export interface CreateFpgaImageCommandOutput extends CreateFpgaImageResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates an Amazon FPGA Image (AFI) from the specified design checkpoint (DCP).</p>
  *          <p>The create operation is asynchronous. To verify that the AFI is ready for use,
  *          check the output logs.</p>
@@ -30,6 +35,8 @@ export interface CreateFpgaImageCommandOutput extends CreateFpgaImageResult, __M
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateFpgaImageCommandInput - {@link CreateFpgaImageCommandInput}
+ * @returns {@link CreateFpgaImageCommandOutput}
  * @see {@link CreateFpgaImageCommandInput} for command's `input` shape.
  * @see {@link CreateFpgaImageCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -39,11 +46,20 @@ export interface CreateFpgaImageCommandOutput extends CreateFpgaImageResult, __M
 export declare class CreateFpgaImageCommand extends $Command<CreateFpgaImageCommandInput, CreateFpgaImageCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateFpgaImageCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateFpgaImageCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateFpgaImageCommandInput, CreateFpgaImageCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateImageRequest, CreateImageResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateImageCommand}.
  */
 export interface CreateImageCommandInput extends CreateImageRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateImageCommand}.
  */
 export interface CreateImageCommandOutput extends CreateImageResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates an Amazon EBS-backed AMI from an Amazon EBS-backed instance
  *      	that is either running or stopped.</p>
  *          <p>By default, when Amazon EC2 creates the new AMI, it reboots the instance so that it can
@@ -41,6 +46,8 @@ export interface CreateImageCommandOutput extends CreateImageResult, __MetadataB
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateImageCommandInput - {@link CreateImageCommandInput}
+ * @returns {@link CreateImageCommandOutput}
  * @see {@link CreateImageCommandInput} for command's `input` shape.
  * @see {@link CreateImageCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -81,11 +88,20 @@ export interface CreateImageCommandOutput extends CreateImageResult, __MetadataB
 export declare class CreateImageCommand extends $Command<CreateImageCommandInput, CreateImageCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateImageCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateImageCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateImageCommandInput, CreateImageCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }