@aws-sdk/client-ec2 3.295.0 → 3.297.0

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateVpcEndpointServiceConfigurationRequest, CreateVpcEndpointServiceConfigurationResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateVpcEndpointServiceConfigurationCommand}.
  */
 export interface CreateVpcEndpointServiceConfigurationCommandInput extends CreateVpcEndpointServiceConfigurationRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateVpcEndpointServiceConfigurationCommand}.
  */
 export interface CreateVpcEndpointServiceConfigurationCommandOutput extends CreateVpcEndpointServiceConfigurationResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a VPC endpoint service to which service consumers (Amazon Web Services accounts,
  *             users, and IAM roles) can connect.</p>
  *          <p>Before you create an endpoint service, you must create one of the following for your service:</p>
@@ -41,6 +46,8 @@ export interface CreateVpcEndpointServiceConfigurationCommandOutput extends Crea
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateVpcEndpointServiceConfigurationCommandInput - {@link CreateVpcEndpointServiceConfigurationCommandInput}
+ * @returns {@link CreateVpcEndpointServiceConfigurationCommandOutput}
  * @see {@link CreateVpcEndpointServiceConfigurationCommandInput} for command's `input` shape.
  * @see {@link CreateVpcEndpointServiceConfigurationCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -50,11 +57,20 @@ export interface CreateVpcEndpointServiceConfigurationCommandOutput extends Crea
 export declare class CreateVpcEndpointServiceConfigurationCommand extends $Command<CreateVpcEndpointServiceConfigurationCommandInput, CreateVpcEndpointServiceConfigurationCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateVpcEndpointServiceConfigurationCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateVpcEndpointServiceConfigurationCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateVpcEndpointServiceConfigurationCommandInput, CreateVpcEndpointServiceConfigurationCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateVpcPeeringConnectionRequest, CreateVpcPeeringConnectionResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateVpcPeeringConnectionCommand}.
  */
 export interface CreateVpcPeeringConnectionCommandInput extends CreateVpcPeeringConnectionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateVpcPeeringConnectionCommand}.
  */
 export interface CreateVpcPeeringConnectionCommandOutput extends CreateVpcPeeringConnectionResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Requests a VPC peering connection between two VPCs: a requester VPC that you own and
  * 		  an accepter VPC with which to create the connection. The accepter VPC can belong to
  * 		  another Amazon Web Services account and can be in a different Region to the requester VPC.
@@ -37,6 +42,8 @@ export interface CreateVpcPeeringConnectionCommandOutput extends CreateVpcPeerin
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateVpcPeeringConnectionCommandInput - {@link CreateVpcPeeringConnectionCommandInput}
+ * @returns {@link CreateVpcPeeringConnectionCommandOutput}
  * @see {@link CreateVpcPeeringConnectionCommandInput} for command's `input` shape.
  * @see {@link CreateVpcPeeringConnectionCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -46,11 +53,20 @@ export interface CreateVpcPeeringConnectionCommandOutput extends CreateVpcPeerin
 export declare class CreateVpcPeeringConnectionCommand extends $Command<CreateVpcPeeringConnectionCommandInput, CreateVpcPeeringConnectionCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateVpcPeeringConnectionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateVpcPeeringConnectionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateVpcPeeringConnectionCommandInput, CreateVpcPeeringConnectionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateVpnConnectionRequest, CreateVpnConnectionResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateVpnConnectionCommand}.
  */
 export interface CreateVpnConnectionCommandInput extends CreateVpnConnectionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateVpnConnectionCommand}.
  */
 export interface CreateVpnConnectionCommandOutput extends CreateVpnConnectionResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a VPN connection between an existing virtual private gateway or transit
  *             gateway and a customer gateway. The supported connection type is
  *             <code>ipsec.1</code>.</p>
@@ -41,6 +46,8 @@ export interface CreateVpnConnectionCommandOutput extends CreateVpnConnectionRes
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateVpnConnectionCommandInput - {@link CreateVpnConnectionCommandInput}
+ * @returns {@link CreateVpnConnectionCommandOutput}
  * @see {@link CreateVpnConnectionCommandInput} for command's `input` shape.
  * @see {@link CreateVpnConnectionCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -50,11 +57,20 @@ export interface CreateVpnConnectionCommandOutput extends CreateVpnConnectionRes
 export declare class CreateVpnConnectionCommand extends $Command<CreateVpnConnectionCommandInput, CreateVpnConnectionCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateVpnConnectionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateVpnConnectionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateVpnConnectionCommandInput, CreateVpnConnectionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateVpnConnectionRouteRequest } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateVpnConnectionRouteCommand}.
  */
 export interface CreateVpnConnectionRouteCommandInput extends CreateVpnConnectionRouteRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateVpnConnectionRouteCommand}.
  */
 export interface CreateVpnConnectionRouteCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a static route associated with a VPN connection between an existing virtual
  *             private gateway and a VPN customer gateway. The static route allows traffic to be routed
  *             from the virtual private gateway to the VPN customer gateway.</p>
@@ -29,6 +34,8 @@ export interface CreateVpnConnectionRouteCommandOutput extends __MetadataBearer
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateVpnConnectionRouteCommandInput - {@link CreateVpnConnectionRouteCommandInput}
+ * @returns {@link CreateVpnConnectionRouteCommandOutput}
  * @see {@link CreateVpnConnectionRouteCommandInput} for command's `input` shape.
  * @see {@link CreateVpnConnectionRouteCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -38,11 +45,20 @@ export interface CreateVpnConnectionRouteCommandOutput extends __MetadataBearer
 export declare class CreateVpnConnectionRouteCommand extends $Command<CreateVpnConnectionRouteCommandInput, CreateVpnConnectionRouteCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateVpnConnectionRouteCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateVpnConnectionRouteCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateVpnConnectionRouteCommandInput, CreateVpnConnectionRouteCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { CreateVpnGatewayRequest, CreateVpnGatewayResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link CreateVpnGatewayCommand}.
  */
 export interface CreateVpnGatewayCommandInput extends CreateVpnGatewayRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateVpnGatewayCommand}.
  */
 export interface CreateVpnGatewayCommandOutput extends CreateVpnGatewayResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a virtual private gateway. A virtual private gateway is the endpoint on the
  *             VPC side of your VPN connection. You can create a virtual private gateway before
  *             creating the VPC itself.</p>
@@ -29,6 +34,8 @@ export interface CreateVpnGatewayCommandOutput extends CreateVpnGatewayResult, _
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateVpnGatewayCommandInput - {@link CreateVpnGatewayCommandInput}
+ * @returns {@link CreateVpnGatewayCommandOutput}
  * @see {@link CreateVpnGatewayCommandInput} for command's `input` shape.
  * @see {@link CreateVpnGatewayCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -38,11 +45,20 @@ export interface CreateVpnGatewayCommandOutput extends CreateVpnGatewayResult, _
 export declare class CreateVpnGatewayCommand extends $Command<CreateVpnGatewayCommandInput, CreateVpnGatewayCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateVpnGatewayCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateVpnGatewayCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateVpnGatewayCommandInput, CreateVpnGatewayCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { DeleteCarrierGatewayRequest, DeleteCarrierGatewayResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link DeleteCarrierGatewayCommand}.
  */
 export interface DeleteCarrierGatewayCommandInput extends DeleteCarrierGatewayRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteCarrierGatewayCommand}.
  */
 export interface DeleteCarrierGatewayCommandOutput extends DeleteCarrierGatewayResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes a carrier gateway.</p>
  *          <important>
  *             <p>If you do not delete the route that contains the carrier gateway as the
@@ -30,6 +35,8 @@ export interface DeleteCarrierGatewayCommandOutput extends DeleteCarrierGatewayR
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteCarrierGatewayCommandInput - {@link DeleteCarrierGatewayCommandInput}
+ * @returns {@link DeleteCarrierGatewayCommandOutput}
  * @see {@link DeleteCarrierGatewayCommandInput} for command's `input` shape.
  * @see {@link DeleteCarrierGatewayCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -39,11 +46,20 @@ export interface DeleteCarrierGatewayCommandOutput extends DeleteCarrierGatewayR
 export declare class DeleteCarrierGatewayCommand extends $Command<DeleteCarrierGatewayCommandInput, DeleteCarrierGatewayCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteCarrierGatewayCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteCarrierGatewayCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteCarrierGatewayCommandInput, DeleteCarrierGatewayCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { DeleteClientVpnEndpointRequest, DeleteClientVpnEndpointResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link DeleteClientVpnEndpointCommand}.
  */
 export interface DeleteClientVpnEndpointCommandInput extends DeleteClientVpnEndpointRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteClientVpnEndpointCommand}.
  */
 export interface DeleteClientVpnEndpointCommandOutput extends DeleteClientVpnEndpointResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the specified Client VPN endpoint. You must disassociate all target networks before you
  * 			can delete a Client VPN endpoint.</p>
  * @example
@@ -26,6 +31,8 @@ export interface DeleteClientVpnEndpointCommandOutput extends DeleteClientVpnEnd
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteClientVpnEndpointCommandInput - {@link DeleteClientVpnEndpointCommandInput}
+ * @returns {@link DeleteClientVpnEndpointCommandOutput}
  * @see {@link DeleteClientVpnEndpointCommandInput} for command's `input` shape.
  * @see {@link DeleteClientVpnEndpointCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -35,11 +42,20 @@ export interface DeleteClientVpnEndpointCommandOutput extends DeleteClientVpnEnd
 export declare class DeleteClientVpnEndpointCommand extends $Command<DeleteClientVpnEndpointCommandInput, DeleteClientVpnEndpointCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteClientVpnEndpointCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteClientVpnEndpointCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteClientVpnEndpointCommandInput, DeleteClientVpnEndpointCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { DeleteClientVpnRouteRequest, DeleteClientVpnRouteResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link DeleteClientVpnRouteCommand}.
  */
 export interface DeleteClientVpnRouteCommandInput extends DeleteClientVpnRouteRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteClientVpnRouteCommand}.
  */
 export interface DeleteClientVpnRouteCommandOutput extends DeleteClientVpnRouteResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes a route from a Client VPN endpoint. You can only delete routes that you manually added using
  * 			the <b>CreateClientVpnRoute</b> action. You cannot delete routes that were
  * 			automatically added when associating a subnet. To remove routes that have been automatically added,
@@ -28,6 +33,8 @@ export interface DeleteClientVpnRouteCommandOutput extends DeleteClientVpnRouteR
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteClientVpnRouteCommandInput - {@link DeleteClientVpnRouteCommandInput}
+ * @returns {@link DeleteClientVpnRouteCommandOutput}
  * @see {@link DeleteClientVpnRouteCommandInput} for command's `input` shape.
  * @see {@link DeleteClientVpnRouteCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -37,11 +44,20 @@ export interface DeleteClientVpnRouteCommandOutput extends DeleteClientVpnRouteR
 export declare class DeleteClientVpnRouteCommand extends $Command<DeleteClientVpnRouteCommandInput, DeleteClientVpnRouteCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteClientVpnRouteCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteClientVpnRouteCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteClientVpnRouteCommandInput, DeleteClientVpnRouteCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

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

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { DeleteCoipPoolRequest, DeleteCoipPoolResult } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link DeleteCoipPoolCommand}.
  */
 export interface DeleteCoipPoolCommandInput extends DeleteCoipPoolRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteCoipPoolCommand}.
  */
 export interface DeleteCoipPoolCommandOutput extends DeleteCoipPoolResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes 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 DeleteCoipPoolCommandOutput extends DeleteCoipPoolResult, __Met
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteCoipPoolCommandInput - {@link DeleteCoipPoolCommandInput}
+ * @returns {@link DeleteCoipPoolCommandOutput}
  * @see {@link DeleteCoipPoolCommandInput} for command's `input` shape.
  * @see {@link DeleteCoipPoolCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -34,11 +41,20 @@ export interface DeleteCoipPoolCommandOutput extends DeleteCoipPoolResult, __Met
 export declare class DeleteCoipPoolCommand extends $Command<DeleteCoipPoolCommandInput, DeleteCoipPoolCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteCoipPoolCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteCoipPoolCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteCoipPoolCommandInput, DeleteCoipPoolCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { DeleteCustomerGatewayRequest } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link DeleteCustomerGatewayCommand}.
  */
 export interface DeleteCustomerGatewayCommandInput extends DeleteCustomerGatewayRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteCustomerGatewayCommand}.
  */
 export interface DeleteCustomerGatewayCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the specified customer gateway. You must delete the VPN connection before you
  *             can delete the customer gateway.</p>
  * @example
@@ -26,6 +31,8 @@ export interface DeleteCustomerGatewayCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteCustomerGatewayCommandInput - {@link DeleteCustomerGatewayCommandInput}
+ * @returns {@link DeleteCustomerGatewayCommandOutput}
  * @see {@link DeleteCustomerGatewayCommandInput} for command's `input` shape.
  * @see {@link DeleteCustomerGatewayCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -46,11 +53,20 @@ export interface DeleteCustomerGatewayCommandOutput extends __MetadataBearer {
 export declare class DeleteCustomerGatewayCommand extends $Command<DeleteCustomerGatewayCommandInput, DeleteCustomerGatewayCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteCustomerGatewayCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteCustomerGatewayCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteCustomerGatewayCommandInput, DeleteCustomerGatewayCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { EC2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EC2Client";
 import { DeleteDhcpOptionsRequest } from "../models/models_2";
 /**
+ * @public
+ *
  * The input for {@link DeleteDhcpOptionsCommand}.
  */
 export interface DeleteDhcpOptionsCommandInput extends DeleteDhcpOptionsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteDhcpOptionsCommand}.
  */
 export interface DeleteDhcpOptionsCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the specified set of DHCP options. You must disassociate the set of DHCP options before you can delete it. You can disassociate the set of DHCP options by associating either a new set of options or the default set of options with the VPC.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteDhcpOptionsCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteDhcpOptionsCommandInput - {@link DeleteDhcpOptionsCommandInput}
+ * @returns {@link DeleteDhcpOptionsCommandOutput}
  * @see {@link DeleteDhcpOptionsCommandInput} for command's `input` shape.
  * @see {@link DeleteDhcpOptionsCommandOutput} for command's `response` shape.
  * @see {@link EC2ClientResolvedConfig | config} for EC2Client's `config` shape.
@@ -45,11 +52,20 @@ export interface DeleteDhcpOptionsCommandOutput extends __MetadataBearer {
 export declare class DeleteDhcpOptionsCommand extends $Command<DeleteDhcpOptionsCommandInput, DeleteDhcpOptionsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeleteDhcpOptionsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteDhcpOptionsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDhcpOptionsCommandInput, DeleteDhcpOptionsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

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