@aws-sdk/client-ec2 3.296.0 → 3.298.0

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

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

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateLocalGatewayRouteTableVpcAssociationRequest, CreateLocalGatewayRouteTableVpcAssociationResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateLocalGatewayRouteTableVpcAssociationCommand}.
  */
 export interface CreateLocalGatewayRouteTableVpcAssociationCommandInput extends CreateLocalGatewayRouteTableVpcAssociationRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateLocalGatewayRouteTableVpcAssociationCommand}.
  */
 export interface CreateLocalGatewayRouteTableVpcAssociationCommandOutput extends CreateLocalGatewayRouteTableVpcAssociationResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Associates the specified VPC with the specified local gateway route table.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface CreateLocalGatewayRouteTableVpcAssociationCommandOutput extends
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateLocalGatewayRouteTableVpcAssociationCommandInput - {@link CreateLocalGatewayRouteTableVpcAssociationCommandInput}
+ * @returns {@link CreateLocalGatewayRouteTableVpcAssociationCommandOutput}
  * @see {@link CreateLocalGatewayRouteTableVpcAssociationCommandInput} for command's `input` shape.
  * @see {@link CreateLocalGatewayRouteTableVpcAssociationCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -34,11 +41,20 @@ export interface CreateLocalGatewayRouteTableVpcAssociationCommandOutput extends
 export declare class CreateLocalGatewayRouteTableVpcAssociationCommand extends $Command<CreateLocalGatewayRouteTableVpcAssociationCommandInput, CreateLocalGatewayRouteTableVpcAssociationCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateLocalGatewayRouteTableVpcAssociationCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateLocalGatewayRouteTableVpcAssociationCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLocalGatewayRouteTableVpcAssociationCommandInput, CreateLocalGatewayRouteTableVpcAssociationCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateManagedPrefixListRequest, CreateManagedPrefixListResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateManagedPrefixListCommand}.
  */
 export interface CreateManagedPrefixListCommandInput extends CreateManagedPrefixListRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateManagedPrefixListCommand}.
  */
 export interface CreateManagedPrefixListCommandOutput extends CreateManagedPrefixListResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a managed prefix list. You can specify one or more entries for the prefix list.
  *             Each entry consists of a CIDR block and an optional description.</p>
  * @example
@@ -26,6 +31,8 @@ export interface CreateManagedPrefixListCommandOutput extends CreateManagedPrefi
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateManagedPrefixListCommandInput - {@link CreateManagedPrefixListCommandInput}
+ * @returns {@link CreateManagedPrefixListCommandOutput}
  * @see {@link CreateManagedPrefixListCommandInput} for command's `input` shape.
  * @see {@link CreateManagedPrefixListCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -35,11 +42,20 @@ export interface CreateManagedPrefixListCommandOutput extends CreateManagedPrefi
 export declare class CreateManagedPrefixListCommand extends $Command<CreateManagedPrefixListCommandInput, CreateManagedPrefixListCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateManagedPrefixListCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateManagedPrefixListCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateManagedPrefixListCommandInput, CreateManagedPrefixListCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateNatGatewayRequest, CreateNatGatewayResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateNatGatewayCommand}.
  */
 export interface CreateNatGatewayCommandInput extends CreateNatGatewayRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateNatGatewayCommand}.
  */
 export interface CreateNatGatewayCommandOutput extends CreateNatGatewayResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a NAT gateway in the specified subnet. This action creates a network interface
  *           in the specified subnet with a private IP address from the IP address range of the
  *           subnet. You can create either a public NAT gateway or a private NAT gateway.</p>
@@ -34,6 +39,8 @@ export interface CreateNatGatewayCommandOutput extends CreateNatGatewayResult, _
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateNatGatewayCommandInput - {@link CreateNatGatewayCommandInput}
+ * @returns {@link CreateNatGatewayCommandOutput}
  * @see {@link CreateNatGatewayCommandInput} for command's `input` shape.
  * @see {@link CreateNatGatewayCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -71,11 +78,20 @@ export interface CreateNatGatewayCommandOutput extends CreateNatGatewayResult, _
 export declare class CreateNatGatewayCommand extends $Command<CreateNatGatewayCommandInput, CreateNatGatewayCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateNatGatewayCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateNatGatewayCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateNatGatewayCommandInput, CreateNatGatewayCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateNetworkAclRequest, CreateNetworkAclResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateNetworkAclCommand}.
  */
 export interface CreateNetworkAclCommandInput extends CreateNetworkAclRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateNetworkAclCommand}.
  */
 export interface CreateNetworkAclCommandOutput extends CreateNetworkAclResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a network ACL in a VPC. Network ACLs provide an optional layer of security (in addition to security groups) for the instances in your VPC.</p>
  *          <p>For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_ACLs.html">Network ACLs</a> in the
  * 				<i>Amazon Virtual Private Cloud User Guide</i>.</p>
@@ -27,6 +32,8 @@ export interface CreateNetworkAclCommandOutput extends CreateNetworkAclResult, _
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateNetworkAclCommandInput - {@link CreateNetworkAclCommandInput}
+ * @returns {@link CreateNetworkAclCommandOutput}
  * @see {@link CreateNetworkAclCommandInput} for command's `input` shape.
  * @see {@link CreateNetworkAclCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -74,11 +81,20 @@ export interface CreateNetworkAclCommandOutput extends CreateNetworkAclResult, _
 export declare class CreateNetworkAclCommand extends $Command<CreateNetworkAclCommandInput, CreateNetworkAclCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateNetworkAclCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateNetworkAclCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateNetworkAclCommandInput, CreateNetworkAclCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateNetworkAclEntryRequest } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateNetworkAclEntryCommand}.
  */
 export interface CreateNetworkAclEntryCommandInput extends CreateNetworkAclEntryRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateNetworkAclEntryCommand}.
  */
 export interface CreateNetworkAclEntryCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates an entry (a rule) in a network ACL with the specified rule number. Each network ACL has a set of numbered ingress rules
  * 		        and a separate set of numbered egress rules. When determining whether a packet should be allowed in or out of a subnet associated
  * 		        with the ACL, we process the entries in the ACL according to the rule numbers, in ascending order. Each network ACL has a set of
@@ -32,6 +37,8 @@ export interface CreateNetworkAclEntryCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateNetworkAclEntryCommandInput - {@link CreateNetworkAclEntryCommandInput}
+ * @returns {@link CreateNetworkAclEntryCommandOutput}
  * @see {@link CreateNetworkAclEntryCommandInput} for command's `input` shape.
  * @see {@link CreateNetworkAclEntryCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -61,11 +68,20 @@ export interface CreateNetworkAclEntryCommandOutput extends __MetadataBearer {
 export declare class CreateNetworkAclEntryCommand extends $Command<CreateNetworkAclEntryCommandInput, CreateNetworkAclEntryCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateNetworkAclEntryCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateNetworkAclEntryCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateNetworkAclEntryCommandInput, CreateNetworkAclEntryCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateNetworkInsightsAccessScopeRequest, CreateNetworkInsightsAccessScopeResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateNetworkInsightsAccessScopeCommand}.
  */
 export interface CreateNetworkInsightsAccessScopeCommandInput extends CreateNetworkInsightsAccessScopeRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateNetworkInsightsAccessScopeCommand}.
  */
 export interface CreateNetworkInsightsAccessScopeCommandOutput extends CreateNetworkInsightsAccessScopeResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a Network Access Scope.</p>
  *          <p>Amazon Web Services Network Access Analyzer enables cloud networking and cloud operations teams
  *          to verify that their networks on Amazon Web Services conform to their network security and governance
@@ -28,6 +33,8 @@ export interface CreateNetworkInsightsAccessScopeCommandOutput extends CreateNet
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateNetworkInsightsAccessScopeCommandInput - {@link CreateNetworkInsightsAccessScopeCommandInput}
+ * @returns {@link CreateNetworkInsightsAccessScopeCommandOutput}
  * @see {@link CreateNetworkInsightsAccessScopeCommandInput} for command's `input` shape.
  * @see {@link CreateNetworkInsightsAccessScopeCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -37,11 +44,20 @@ export interface CreateNetworkInsightsAccessScopeCommandOutput extends CreateNet
 export declare class CreateNetworkInsightsAccessScopeCommand extends $Command<CreateNetworkInsightsAccessScopeCommandInput, CreateNetworkInsightsAccessScopeCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateNetworkInsightsAccessScopeCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateNetworkInsightsAccessScopeCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateNetworkInsightsAccessScopeCommandInput, CreateNetworkInsightsAccessScopeCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateNetworkInsightsPathRequest, CreateNetworkInsightsPathResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateNetworkInsightsPathCommand}.
  */
 export interface CreateNetworkInsightsPathCommandInput extends CreateNetworkInsightsPathRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateNetworkInsightsPathCommand}.
  */
 export interface CreateNetworkInsightsPathCommandOutput extends CreateNetworkInsightsPathResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a path to analyze for reachability.</p>
  *          <p>Reachability Analyzer enables you to analyze and debug network reachability between
  *           two resources in your virtual private cloud (VPC). For more information, see the
@@ -28,6 +33,8 @@ export interface CreateNetworkInsightsPathCommandOutput extends CreateNetworkIns
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateNetworkInsightsPathCommandInput - {@link CreateNetworkInsightsPathCommandInput}
+ * @returns {@link CreateNetworkInsightsPathCommandOutput}
  * @see {@link CreateNetworkInsightsPathCommandInput} for command's `input` shape.
  * @see {@link CreateNetworkInsightsPathCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -37,11 +44,20 @@ export interface CreateNetworkInsightsPathCommandOutput extends CreateNetworkIns
 export declare class CreateNetworkInsightsPathCommand extends $Command<CreateNetworkInsightsPathCommandInput, CreateNetworkInsightsPathCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateNetworkInsightsPathCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateNetworkInsightsPathCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateNetworkInsightsPathCommandInput, CreateNetworkInsightsPathCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateNetworkInterfaceRequest, CreateNetworkInterfaceResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateNetworkInterfaceCommand}.
  */
 export interface CreateNetworkInterfaceCommandInput extends CreateNetworkInterfaceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateNetworkInterfaceCommand}.
  */
 export interface CreateNetworkInterfaceCommandOutput extends CreateNetworkInterfaceResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a network interface in the specified subnet.</p>
  *          <p>The number of IP addresses you can assign to a network interface varies by instance
  *             type. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html#AvailableIpPerENI">IP Addresses Per ENI Per
@@ -30,6 +35,8 @@ export interface CreateNetworkInterfaceCommandOutput extends CreateNetworkInterf
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateNetworkInterfaceCommandInput - {@link CreateNetworkInterfaceCommandInput}
+ * @returns {@link CreateNetworkInterfaceCommandOutput}
  * @see {@link CreateNetworkInterfaceCommandInput} for command's `input` shape.
  * @see {@link CreateNetworkInterfaceCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -85,11 +92,20 @@ export interface CreateNetworkInterfaceCommandOutput extends CreateNetworkInterf
 export declare class CreateNetworkInterfaceCommand extends $Command<CreateNetworkInterfaceCommandInput, CreateNetworkInterfaceCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateNetworkInterfaceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateNetworkInterfaceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateNetworkInterfaceCommandInput, CreateNetworkInterfaceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateNetworkInterfacePermissionRequest, CreateNetworkInterfacePermissionResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreateNetworkInterfacePermissionCommand}.
  */
 export interface CreateNetworkInterfacePermissionCommandInput extends CreateNetworkInterfacePermissionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateNetworkInterfacePermissionCommand}.
  */
 export interface CreateNetworkInterfacePermissionCommandOutput extends CreateNetworkInterfacePermissionResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Grants an Amazon Web Services-authorized account permission to attach the specified network interface to
  *             an instance in their account.</p>
  *          <p>You can grant permission to a single Amazon Web Services account only, and only one account at a time.</p>
@@ -27,6 +32,8 @@ export interface CreateNetworkInterfacePermissionCommandOutput extends CreateNet
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateNetworkInterfacePermissionCommandInput - {@link CreateNetworkInterfacePermissionCommandInput}
+ * @returns {@link CreateNetworkInterfacePermissionCommandOutput}
  * @see {@link CreateNetworkInterfacePermissionCommandInput} for command's `input` shape.
  * @see {@link CreateNetworkInterfacePermissionCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -36,11 +43,20 @@ export interface CreateNetworkInterfacePermissionCommandOutput extends CreateNet
 export declare class CreateNetworkInterfacePermissionCommand extends $Command<CreateNetworkInterfacePermissionCommandInput, CreateNetworkInterfacePermissionCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateNetworkInterfacePermissionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateNetworkInterfacePermissionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateNetworkInterfacePermissionCommandInput, CreateNetworkInterfacePermissionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreatePlacementGroupRequest, CreatePlacementGroupResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreatePlacementGroupCommand}.
  */
 export interface CreatePlacementGroupCommandInput extends CreatePlacementGroupRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreatePlacementGroupCommand}.
  */
 export interface CreatePlacementGroupCommandOutput extends CreatePlacementGroupResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a placement group in which to launch instances. The strategy of the placement
  *             group determines how the instances are organized within the group. </p>
  *          <p>A <code>cluster</code> placement group is a logical grouping of instances within a
@@ -34,6 +39,8 @@ export interface CreatePlacementGroupCommandOutput extends CreatePlacementGroupR
  * const response = await client.send(command);
  * ```
  *
+ * @param CreatePlacementGroupCommandInput - {@link CreatePlacementGroupCommandInput}
+ * @returns {@link CreatePlacementGroupCommandOutput}
  * @see {@link CreatePlacementGroupCommandInput} for command's `input` shape.
  * @see {@link CreatePlacementGroupCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -55,11 +62,20 @@ export interface CreatePlacementGroupCommandOutput extends CreatePlacementGroupR
 export declare class CreatePlacementGroupCommand extends $Command<CreatePlacementGroupCommandInput, CreatePlacementGroupCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreatePlacementGroupCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreatePlacementGroupCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreatePlacementGroupCommandInput, CreatePlacementGroupCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreatePublicIpv4PoolRequest, CreatePublicIpv4PoolResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link CreatePublicIpv4PoolCommand}.
  */
 export interface CreatePublicIpv4PoolCommandInput extends CreatePublicIpv4PoolRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreatePublicIpv4PoolCommand}.
  */
 export interface CreatePublicIpv4PoolCommandOutput extends CreatePublicIpv4PoolResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a public IPv4 address pool. A public IPv4 pool is an EC2 IP address pool required for the public IPv4 CIDRs that you own and bring to Amazon Web Services to manage with IPAM. IPv6 addresses you bring to Amazon Web Services, however, use IPAM pools only. To monitor the status of pool creation, use <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribePublicIpv4Pools.html">DescribePublicIpv4Pools</a>.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface CreatePublicIpv4PoolCommandOutput extends CreatePublicIpv4PoolR
  * const response = await client.send(command);
  * ```
  *
+ * @param CreatePublicIpv4PoolCommandInput - {@link CreatePublicIpv4PoolCommandInput}
+ * @returns {@link CreatePublicIpv4PoolCommandOutput}
  * @see {@link CreatePublicIpv4PoolCommandInput} for command's `input` shape.
  * @see {@link CreatePublicIpv4PoolCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -34,11 +41,20 @@ export interface CreatePublicIpv4PoolCommandOutput extends CreatePublicIpv4PoolR
 export declare class CreatePublicIpv4PoolCommand extends $Command<CreatePublicIpv4PoolCommandInput, CreatePublicIpv4PoolCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreatePublicIpv4PoolCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreatePublicIpv4PoolCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreatePublicIpv4PoolCommandInput, CreatePublicIpv4PoolCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }