@aws-sdk/client-ec2 3.295.0 → 3.297.0

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateInstanceEventWindowRequest, CreateInstanceEventWindowResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateInstanceEventWindowCommand}.
  */
 export interface CreateInstanceEventWindowCommandInput extends CreateInstanceEventWindowRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateInstanceEventWindowCommand}.
  */
 export interface CreateInstanceEventWindowCommandOutput extends CreateInstanceEventWindowResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates an event window in which scheduled events for the associated Amazon EC2 instances can
  *          run.</p>
  *          <p>You can define either a set of time ranges or a cron expression when creating the event
@@ -47,6 +52,8 @@ export interface CreateInstanceEventWindowCommandOutput extends CreateInstanceEv
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateInstanceEventWindowCommandInput - {@link CreateInstanceEventWindowCommandInput}
+ * @returns {@link CreateInstanceEventWindowCommandOutput}
  * @see {@link CreateInstanceEventWindowCommandInput} for command's `input` shape.
  * @see {@link CreateInstanceEventWindowCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -56,11 +63,20 @@ export interface CreateInstanceEventWindowCommandOutput extends CreateInstanceEv
 export declare class CreateInstanceEventWindowCommand extends $Command<CreateInstanceEventWindowCommandInput, CreateInstanceEventWindowCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateInstanceEventWindowCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateInstanceEventWindowCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateInstanceEventWindowCommandInput, CreateInstanceEventWindowCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateInstanceExportTaskRequest, CreateInstanceExportTaskResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateInstanceExportTaskCommand}.
  */
 export interface CreateInstanceExportTaskCommandInput extends CreateInstanceExportTaskRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateInstanceExportTaskCommand}.
  */
 export interface CreateInstanceExportTaskCommandOutput extends CreateInstanceExportTaskResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Exports a running or stopped instance to an Amazon S3 bucket.</p>
  *          <p>For information about the supported operating systems, image formats, and known limitations
  *    for the types of instances you can export, see <a href="https://docs.aws.amazon.com/vm-import/latest/userguide/vmexport.html">Exporting an instance as a VM Using VM Import/Export</a>
@@ -28,6 +33,8 @@ export interface CreateInstanceExportTaskCommandOutput extends CreateInstanceExp
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateInstanceExportTaskCommandInput - {@link CreateInstanceExportTaskCommandInput}
+ * @returns {@link CreateInstanceExportTaskCommandOutput}
  * @see {@link CreateInstanceExportTaskCommandInput} for command's `input` shape.
  * @see {@link CreateInstanceExportTaskCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -37,11 +44,20 @@ export interface CreateInstanceExportTaskCommandOutput extends CreateInstanceExp
 export declare class CreateInstanceExportTaskCommand extends $Command<CreateInstanceExportTaskCommandInput, CreateInstanceExportTaskCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateInstanceExportTaskCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateInstanceExportTaskCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateInstanceExportTaskCommandInput, CreateInstanceExportTaskCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateInternetGatewayRequest, CreateInternetGatewayResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateInternetGatewayCommand}.
  */
 export interface CreateInternetGatewayCommandInput extends CreateInternetGatewayRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateInternetGatewayCommand}.
  */
 export interface CreateInternetGatewayCommandOutput extends CreateInternetGatewayResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates an internet gateway for use with a VPC. After creating the internet gateway,
  * 			you attach it to a VPC using <a>AttachInternetGateway</a>.</p>
  *          <p>For more information about your VPC and internet gateway, see the <a href="https://docs.aws.amazon.com/vpc/latest/userguide/">Amazon Virtual Private Cloud User Guide</a>.</p>
@@ -27,6 +32,8 @@ export interface CreateInternetGatewayCommandOutput extends CreateInternetGatewa
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateInternetGatewayCommandInput - {@link CreateInternetGatewayCommandInput}
+ * @returns {@link CreateInternetGatewayCommandOutput}
  * @see {@link CreateInternetGatewayCommandInput} for command's `input` shape.
  * @see {@link CreateInternetGatewayCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -54,11 +61,20 @@ export interface CreateInternetGatewayCommandOutput extends CreateInternetGatewa
 export declare class CreateInternetGatewayCommand extends $Command<CreateInternetGatewayCommandInput, CreateInternetGatewayCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateInternetGatewayCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateInternetGatewayCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateInternetGatewayCommandInput, CreateInternetGatewayCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateIpamRequest, CreateIpamResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateIpamCommand}.
  */
 export interface CreateIpamCommandInput extends CreateIpamRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateIpamCommand}.
  */
 export interface CreateIpamCommandOutput extends CreateIpamResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Create an IPAM. Amazon VPC IP Address Manager (IPAM) is a VPC feature that you can use
  *          to automate your IP address management workflows including assigning, tracking,
  *          troubleshooting, and auditing IP addresses across Amazon Web Services Regions and accounts
@@ -30,6 +35,8 @@ export interface CreateIpamCommandOutput extends CreateIpamResult, __MetadataBea
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateIpamCommandInput - {@link CreateIpamCommandInput}
+ * @returns {@link CreateIpamCommandOutput}
  * @see {@link CreateIpamCommandInput} for command's `input` shape.
  * @see {@link CreateIpamCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -39,11 +46,20 @@ export interface CreateIpamCommandOutput extends CreateIpamResult, __MetadataBea
 export declare class CreateIpamCommand extends $Command<CreateIpamCommandInput, CreateIpamCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateIpamCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateIpamCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateIpamCommandInput, CreateIpamCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateIpamPoolRequest, CreateIpamPoolResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateIpamPoolCommand}.
  */
 export interface CreateIpamPoolCommandInput extends CreateIpamPoolRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateIpamPoolCommand}.
  */
 export interface CreateIpamPoolCommandOutput extends CreateIpamPoolResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Create an IP address pool for Amazon VPC IP Address Manager (IPAM). In IPAM, a pool is a collection of contiguous IP addresses CIDRs. Pools enable you to organize your IP addresses according to your routing and security needs. For example, if you have separate routing and security needs for development and production applications, you can create a pool for each.</p>
  *          <p>For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/ipam/create-top-ipam.html">Create a top-level pool</a> in the <i>Amazon VPC IPAM User Guide</i>.
  *       </p>
@@ -27,6 +32,8 @@ export interface CreateIpamPoolCommandOutput extends CreateIpamPoolResult, __Met
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateIpamPoolCommandInput - {@link CreateIpamPoolCommandInput}
+ * @returns {@link CreateIpamPoolCommandOutput}
  * @see {@link CreateIpamPoolCommandInput} for command's `input` shape.
  * @see {@link CreateIpamPoolCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -36,11 +43,20 @@ export interface CreateIpamPoolCommandOutput extends CreateIpamPoolResult, __Met
 export declare class CreateIpamPoolCommand extends $Command<CreateIpamPoolCommandInput, CreateIpamPoolCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateIpamPoolCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateIpamPoolCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateIpamPoolCommandInput, CreateIpamPoolCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateIpamResourceDiscoveryRequest, CreateIpamResourceDiscoveryResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateIpamResourceDiscoveryCommand}.
  */
 export interface CreateIpamResourceDiscoveryCommandInput extends CreateIpamResourceDiscoveryRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateIpamResourceDiscoveryCommand}.
  */
 export interface CreateIpamResourceDiscoveryCommandOutput extends CreateIpamResourceDiscoveryResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates an IPAM resource discovery. A resource discovery is an IPAM component that enables IPAM to manage and monitor resources that belong to the owning account.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface CreateIpamResourceDiscoveryCommandOutput extends CreateIpamReso
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateIpamResourceDiscoveryCommandInput - {@link CreateIpamResourceDiscoveryCommandInput}
+ * @returns {@link CreateIpamResourceDiscoveryCommandOutput}
  * @see {@link CreateIpamResourceDiscoveryCommandInput} for command's `input` shape.
  * @see {@link CreateIpamResourceDiscoveryCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -34,11 +41,20 @@ export interface CreateIpamResourceDiscoveryCommandOutput extends CreateIpamReso
 export declare class CreateIpamResourceDiscoveryCommand extends $Command<CreateIpamResourceDiscoveryCommandInput, CreateIpamResourceDiscoveryCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateIpamResourceDiscoveryCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateIpamResourceDiscoveryCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateIpamResourceDiscoveryCommandInput, CreateIpamResourceDiscoveryCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateIpamScopeRequest, CreateIpamScopeResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateIpamScopeCommand}.
  */
 export interface CreateIpamScopeCommandInput extends CreateIpamScopeRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateIpamScopeCommand}.
  */
 export interface CreateIpamScopeCommandOutput extends CreateIpamScopeResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Create an IPAM scope. In IPAM, a scope is the highest-level container within IPAM. An IPAM contains two default scopes. Each scope represents the IP space for a single network. The private scope is intended for all private IP address space. The public scope is intended for all public IP address space. Scopes enable you to reuse IP addresses across multiple unconnected networks without causing IP address overlap or conflict.</p>
  *          <p>For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/ipam/add-scope-ipam.html">Add a scope</a> in the <i>Amazon VPC IPAM User Guide</i>.</p>
  * @example
@@ -26,6 +31,8 @@ export interface CreateIpamScopeCommandOutput extends CreateIpamScopeResult, __M
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateIpamScopeCommandInput - {@link CreateIpamScopeCommandInput}
+ * @returns {@link CreateIpamScopeCommandOutput}
  * @see {@link CreateIpamScopeCommandInput} for command's `input` shape.
  * @see {@link CreateIpamScopeCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -35,11 +42,20 @@ export interface CreateIpamScopeCommandOutput extends CreateIpamScopeResult, __M
 export declare class CreateIpamScopeCommand extends $Command<CreateIpamScopeCommandInput, CreateIpamScopeCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateIpamScopeCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateIpamScopeCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateIpamScopeCommandInput, CreateIpamScopeCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateKeyPairRequest, KeyPair } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateKeyPairCommand}.
  */
 export interface CreateKeyPairCommandInput extends CreateKeyPairRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateKeyPairCommand}.
  */
 export interface CreateKeyPairCommandOutput extends KeyPair, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates an ED25519 or 2048-bit RSA key pair with the specified name and in the
  *             specified PEM or PPK format. Amazon EC2 stores the public key and displays the private
  *             key for you to save to a file. The private key is returned as an unencrypted PEM encoded
@@ -35,6 +40,8 @@ export interface CreateKeyPairCommandOutput extends KeyPair, __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateKeyPairCommandInput - {@link CreateKeyPairCommandInput}
+ * @returns {@link CreateKeyPairCommandOutput}
  * @see {@link CreateKeyPairCommandInput} for command's `input` shape.
  * @see {@link CreateKeyPairCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -55,11 +62,20 @@ export interface CreateKeyPairCommandOutput extends KeyPair, __MetadataBearer {
 export declare class CreateKeyPairCommand extends $Command<CreateKeyPairCommandInput, CreateKeyPairCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateKeyPairCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateKeyPairCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateKeyPairCommandInput, CreateKeyPairCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateLaunchTemplateRequest, CreateLaunchTemplateResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateLaunchTemplateCommand}.
  */
 export interface CreateLaunchTemplateCommandInput extends CreateLaunchTemplateRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateLaunchTemplateCommand}.
  */
 export interface CreateLaunchTemplateCommandOutput extends CreateLaunchTemplateResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a launch template.</p>
  *          <p>A launch template contains the parameters to launch an instance. When you launch an
  *             instance using <a>RunInstances</a>, you can specify a launch template instead
@@ -34,6 +39,8 @@ export interface CreateLaunchTemplateCommandOutput extends CreateLaunchTemplateR
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateLaunchTemplateCommandInput - {@link CreateLaunchTemplateCommandInput}
+ * @returns {@link CreateLaunchTemplateCommandOutput}
  * @see {@link CreateLaunchTemplateCommandInput} for command's `input` shape.
  * @see {@link CreateLaunchTemplateCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -90,11 +97,20 @@ export interface CreateLaunchTemplateCommandOutput extends CreateLaunchTemplateR
 export declare class CreateLaunchTemplateCommand extends $Command<CreateLaunchTemplateCommandInput, CreateLaunchTemplateCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateLaunchTemplateCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateLaunchTemplateCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLaunchTemplateCommandInput, CreateLaunchTemplateCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateLaunchTemplateVersionRequest, CreateLaunchTemplateVersionResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateLaunchTemplateVersionCommand}.
  */
 export interface CreateLaunchTemplateVersionCommandInput extends CreateLaunchTemplateVersionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateLaunchTemplateVersionCommand}.
  */
 export interface CreateLaunchTemplateVersionCommandOutput extends CreateLaunchTemplateVersionResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a new version of a launch template. You can specify an existing version of
  *             launch template from which to base the new version.</p>
  *          <p>Launch template versions are numbered in the order in which they are created. You
@@ -33,6 +38,8 @@ export interface CreateLaunchTemplateVersionCommandOutput extends CreateLaunchTe
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateLaunchTemplateVersionCommandInput - {@link CreateLaunchTemplateVersionCommandInput}
+ * @returns {@link CreateLaunchTemplateVersionCommandOutput}
  * @see {@link CreateLaunchTemplateVersionCommandInput} for command's `input` shape.
  * @see {@link CreateLaunchTemplateVersionCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -87,11 +94,20 @@ export interface CreateLaunchTemplateVersionCommandOutput extends CreateLaunchTe
 export declare class CreateLaunchTemplateVersionCommand extends $Command<CreateLaunchTemplateVersionCommandInput, CreateLaunchTemplateVersionCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateLaunchTemplateVersionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateLaunchTemplateVersionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLaunchTemplateVersionCommandInput, CreateLaunchTemplateVersionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateLocalGatewayRouteRequest, CreateLocalGatewayRouteResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateLocalGatewayRouteCommand}.
  */
 export interface CreateLocalGatewayRouteCommandInput extends CreateLocalGatewayRouteRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateLocalGatewayRouteCommand}.
  */
 export interface CreateLocalGatewayRouteCommandOutput extends CreateLocalGatewayRouteResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a static route for the specified local gateway route table. You must specify one of the
  *          following targets: </p>
  *          <ul>
@@ -38,6 +43,8 @@ export interface CreateLocalGatewayRouteCommandOutput extends CreateLocalGateway
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateLocalGatewayRouteCommandInput - {@link CreateLocalGatewayRouteCommandInput}
+ * @returns {@link CreateLocalGatewayRouteCommandOutput}
  * @see {@link CreateLocalGatewayRouteCommandInput} for command's `input` shape.
  * @see {@link CreateLocalGatewayRouteCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -47,11 +54,20 @@ export interface CreateLocalGatewayRouteCommandOutput extends CreateLocalGateway
 export declare class CreateLocalGatewayRouteCommand extends $Command<CreateLocalGatewayRouteCommandInput, CreateLocalGatewayRouteCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateLocalGatewayRouteCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateLocalGatewayRouteCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLocalGatewayRouteCommandInput, CreateLocalGatewayRouteCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

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