@aws-sdk/client-direct-connect 3.296.0 → 3.297.0

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
 import { ConfirmPublicVirtualInterfaceRequest, ConfirmPublicVirtualInterfaceResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link ConfirmPublicVirtualInterfaceCommand}.
  */
 export interface ConfirmPublicVirtualInterfaceCommandInput extends ConfirmPublicVirtualInterfaceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ConfirmPublicVirtualInterfaceCommand}.
  */
 export interface ConfirmPublicVirtualInterfaceCommandOutput extends ConfirmPublicVirtualInterfaceResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Accepts ownership of a public virtual interface created by another Amazon Web Services account.</p>
  *          <p>After the virtual interface owner makes this call, the specified virtual interface is
  *       created and made available to handle traffic.</p>
@@ -27,6 +32,8 @@ export interface ConfirmPublicVirtualInterfaceCommandOutput extends ConfirmPubli
  * const response = await client.send(command);
  * ```
  *
+ * @param ConfirmPublicVirtualInterfaceCommandInput - {@link ConfirmPublicVirtualInterfaceCommandInput}
+ * @returns {@link ConfirmPublicVirtualInterfaceCommandOutput}
  * @see {@link ConfirmPublicVirtualInterfaceCommandInput} for command's `input` shape.
  * @see {@link ConfirmPublicVirtualInterfaceCommandOutput} for command's `response` shape.
  * @see {@link DirectConnectClientResolvedConfig | config} for DirectConnectClient's `config` shape.
@@ -42,11 +49,20 @@ export interface ConfirmPublicVirtualInterfaceCommandOutput extends ConfirmPubli
 export declare class ConfirmPublicVirtualInterfaceCommand extends $Command<ConfirmPublicVirtualInterfaceCommandInput, ConfirmPublicVirtualInterfaceCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: ConfirmPublicVirtualInterfaceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ConfirmPublicVirtualInterfaceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ConfirmPublicVirtualInterfaceCommandInput, ConfirmPublicVirtualInterfaceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
 import { ConfirmTransitVirtualInterfaceRequest, ConfirmTransitVirtualInterfaceResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link ConfirmTransitVirtualInterfaceCommand}.
  */
 export interface ConfirmTransitVirtualInterfaceCommandInput extends ConfirmTransitVirtualInterfaceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ConfirmTransitVirtualInterfaceCommand}.
  */
 export interface ConfirmTransitVirtualInterfaceCommandOutput extends ConfirmTransitVirtualInterfaceResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Accepts ownership of a transit virtual interface created by another Amazon Web Services account.</p>
  *          <p> After the owner of the transit virtual interface makes this call, the specified transit virtual interface is created and made available to handle traffic.</p>
  * @example
@@ -26,6 +31,8 @@ export interface ConfirmTransitVirtualInterfaceCommandOutput extends ConfirmTran
  * const response = await client.send(command);
  * ```
  *
+ * @param ConfirmTransitVirtualInterfaceCommandInput - {@link ConfirmTransitVirtualInterfaceCommandInput}
+ * @returns {@link ConfirmTransitVirtualInterfaceCommandOutput}
  * @see {@link ConfirmTransitVirtualInterfaceCommandInput} for command's `input` shape.
  * @see {@link ConfirmTransitVirtualInterfaceCommandOutput} for command's `response` shape.
  * @see {@link DirectConnectClientResolvedConfig | config} for DirectConnectClient's `config` shape.
@@ -41,11 +48,20 @@ export interface ConfirmTransitVirtualInterfaceCommandOutput extends ConfirmTran
 export declare class ConfirmTransitVirtualInterfaceCommand extends $Command<ConfirmTransitVirtualInterfaceCommandInput, ConfirmTransitVirtualInterfaceCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: ConfirmTransitVirtualInterfaceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ConfirmTransitVirtualInterfaceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ConfirmTransitVirtualInterfaceCommandInput, ConfirmTransitVirtualInterfaceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
 import { CreateBGPPeerRequest, CreateBGPPeerResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateBGPPeerCommand}.
  */
 export interface CreateBGPPeerCommandInput extends CreateBGPPeerRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateBGPPeerCommand}.
  */
 export interface CreateBGPPeerCommandOutput extends CreateBGPPeerResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a BGP peer on the specified virtual interface.</p>
  *          <p>You must create a BGP peer for the corresponding address family (IPv4/IPv6) in order to
  *       access Amazon Web Services resources that also use that address family.</p>
@@ -40,6 +45,8 @@ export interface CreateBGPPeerCommandOutput extends CreateBGPPeerResponse, __Met
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateBGPPeerCommandInput - {@link CreateBGPPeerCommandInput}
+ * @returns {@link CreateBGPPeerCommandOutput}
  * @see {@link CreateBGPPeerCommandInput} for command's `input` shape.
  * @see {@link CreateBGPPeerCommandOutput} for command's `response` shape.
  * @see {@link DirectConnectClientResolvedConfig | config} for DirectConnectClient's `config` shape.
@@ -55,11 +62,20 @@ export interface CreateBGPPeerCommandOutput extends CreateBGPPeerResponse, __Met
 export declare class CreateBGPPeerCommand extends $Command<CreateBGPPeerCommandInput, CreateBGPPeerCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: CreateBGPPeerCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateBGPPeerCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateBGPPeerCommandInput, CreateBGPPeerCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
 import { Connection, CreateConnectionRequest } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateConnectionCommand}.
  */
 export interface CreateConnectionCommandInput extends CreateConnectionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateConnectionCommand}.
  */
 export interface CreateConnectionCommandOutput extends Connection, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a connection between a customer network and a specific Direct Connect location.</p>
  *          <p>A connection links your internal network to an Direct Connect location over a standard Ethernet fiber-optic
  *       cable. One end of the cable is connected to your router, the other to an Direct Connect router.</p>
@@ -32,6 +37,8 @@ export interface CreateConnectionCommandOutput extends Connection, __MetadataBea
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateConnectionCommandInput - {@link CreateConnectionCommandInput}
+ * @returns {@link CreateConnectionCommandOutput}
  * @see {@link CreateConnectionCommandInput} for command's `input` shape.
  * @see {@link CreateConnectionCommandOutput} for command's `response` shape.
  * @see {@link DirectConnectClientResolvedConfig | config} for DirectConnectClient's `config` shape.
@@ -53,11 +60,20 @@ export interface CreateConnectionCommandOutput extends Connection, __MetadataBea
 export declare class CreateConnectionCommand extends $Command<CreateConnectionCommandInput, CreateConnectionCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: CreateConnectionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateConnectionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateConnectionCommandInput, CreateConnectionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
 import { CreateDirectConnectGatewayAssociationRequest, CreateDirectConnectGatewayAssociationResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateDirectConnectGatewayAssociationCommand}.
  */
 export interface CreateDirectConnectGatewayAssociationCommandInput extends CreateDirectConnectGatewayAssociationRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateDirectConnectGatewayAssociationCommand}.
  */
 export interface CreateDirectConnectGatewayAssociationCommandOutput extends CreateDirectConnectGatewayAssociationResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates an association between a Direct Connect gateway and a virtual private gateway. The virtual
  *       private gateway must be attached to a VPC and must not be associated with another Direct Connect gateway.</p>
  * @example
@@ -26,6 +31,8 @@ export interface CreateDirectConnectGatewayAssociationCommandOutput extends Crea
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateDirectConnectGatewayAssociationCommandInput - {@link CreateDirectConnectGatewayAssociationCommandInput}
+ * @returns {@link CreateDirectConnectGatewayAssociationCommandOutput}
  * @see {@link CreateDirectConnectGatewayAssociationCommandInput} for command's `input` shape.
  * @see {@link CreateDirectConnectGatewayAssociationCommandOutput} for command's `response` shape.
  * @see {@link DirectConnectClientResolvedConfig | config} for DirectConnectClient's `config` shape.
@@ -41,11 +48,20 @@ export interface CreateDirectConnectGatewayAssociationCommandOutput extends Crea
 export declare class CreateDirectConnectGatewayAssociationCommand extends $Command<CreateDirectConnectGatewayAssociationCommandInput, CreateDirectConnectGatewayAssociationCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: CreateDirectConnectGatewayAssociationCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateDirectConnectGatewayAssociationCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDirectConnectGatewayAssociationCommandInput, CreateDirectConnectGatewayAssociationCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
 import { CreateDirectConnectGatewayAssociationProposalRequest, CreateDirectConnectGatewayAssociationProposalResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateDirectConnectGatewayAssociationProposalCommand}.
  */
 export interface CreateDirectConnectGatewayAssociationProposalCommandInput extends CreateDirectConnectGatewayAssociationProposalRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateDirectConnectGatewayAssociationProposalCommand}.
  */
 export interface CreateDirectConnectGatewayAssociationProposalCommandOutput extends CreateDirectConnectGatewayAssociationProposalResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a proposal to associate the specified virtual private gateway or transit gateway with the specified Direct Connect gateway.</p>
  *          <p>You can associate a Direct Connect gateway and virtual private gateway or transit gateway that is owned by any Amazon Web Services account. </p>
  * @example
@@ -26,6 +31,8 @@ export interface CreateDirectConnectGatewayAssociationProposalCommandOutput exte
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateDirectConnectGatewayAssociationProposalCommandInput - {@link CreateDirectConnectGatewayAssociationProposalCommandInput}
+ * @returns {@link CreateDirectConnectGatewayAssociationProposalCommandOutput}
  * @see {@link CreateDirectConnectGatewayAssociationProposalCommandInput} for command's `input` shape.
  * @see {@link CreateDirectConnectGatewayAssociationProposalCommandOutput} for command's `response` shape.
  * @see {@link DirectConnectClientResolvedConfig | config} for DirectConnectClient's `config` shape.
@@ -41,11 +48,20 @@ export interface CreateDirectConnectGatewayAssociationProposalCommandOutput exte
 export declare class CreateDirectConnectGatewayAssociationProposalCommand extends $Command<CreateDirectConnectGatewayAssociationProposalCommandInput, CreateDirectConnectGatewayAssociationProposalCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: CreateDirectConnectGatewayAssociationProposalCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateDirectConnectGatewayAssociationProposalCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDirectConnectGatewayAssociationProposalCommandInput, CreateDirectConnectGatewayAssociationProposalCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
 import { CreateDirectConnectGatewayRequest, CreateDirectConnectGatewayResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateDirectConnectGatewayCommand}.
  */
 export interface CreateDirectConnectGatewayCommandInput extends CreateDirectConnectGatewayRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateDirectConnectGatewayCommand}.
  */
 export interface CreateDirectConnectGatewayCommandOutput extends CreateDirectConnectGatewayResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a Direct Connect gateway, which is an intermediate object that enables you to connect a set
  *       of virtual interfaces and virtual private gateways. A Direct Connect gateway is global and visible in any
  *       Amazon Web Services Region after it is created. The virtual interfaces and virtual private gateways that
@@ -30,6 +35,8 @@ export interface CreateDirectConnectGatewayCommandOutput extends CreateDirectCon
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateDirectConnectGatewayCommandInput - {@link CreateDirectConnectGatewayCommandInput}
+ * @returns {@link CreateDirectConnectGatewayCommandOutput}
  * @see {@link CreateDirectConnectGatewayCommandInput} for command's `input` shape.
  * @see {@link CreateDirectConnectGatewayCommandOutput} for command's `response` shape.
  * @see {@link DirectConnectClientResolvedConfig | config} for DirectConnectClient's `config` shape.
@@ -45,11 +52,20 @@ export interface CreateDirectConnectGatewayCommandOutput extends CreateDirectCon
 export declare class CreateDirectConnectGatewayCommand extends $Command<CreateDirectConnectGatewayCommandInput, CreateDirectConnectGatewayCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: CreateDirectConnectGatewayCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateDirectConnectGatewayCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDirectConnectGatewayCommandInput, CreateDirectConnectGatewayCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
 import { CreateInterconnectRequest, Interconnect } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateInterconnectCommand}.
  */
 export interface CreateInterconnectCommandInput extends CreateInterconnectRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateInterconnectCommand}.
  */
 export interface CreateInterconnectCommandOutput extends Interconnect, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates an interconnect between an Direct Connect Partner's network and a specific Direct Connect location.</p>
  *          <p>An interconnect is a connection that is capable of hosting other connections. The
  *       Direct Connect Partner can use an interconnect to provide Direct Connect hosted
@@ -40,6 +45,8 @@ export interface CreateInterconnectCommandOutput extends Interconnect, __Metadat
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateInterconnectCommandInput - {@link CreateInterconnectCommandInput}
+ * @returns {@link CreateInterconnectCommandOutput}
  * @see {@link CreateInterconnectCommandInput} for command's `input` shape.
  * @see {@link CreateInterconnectCommandOutput} for command's `response` shape.
  * @see {@link DirectConnectClientResolvedConfig | config} for DirectConnectClient's `config` shape.
@@ -61,11 +68,20 @@ export interface CreateInterconnectCommandOutput extends Interconnect, __Metadat
 export declare class CreateInterconnectCommand extends $Command<CreateInterconnectCommandInput, CreateInterconnectCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: CreateInterconnectCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateInterconnectCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateInterconnectCommandInput, CreateInterconnectCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
 import { CreateLagRequest, Lag } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateLagCommand}.
  */
 export interface CreateLagCommandInput extends CreateLagRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateLagCommand}.
  */
 export interface CreateLagCommandOutput extends Lag, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a link aggregation group (LAG) with the specified number of bundled
  *       physical dedicated connections between the customer network and a specific Direct Connect location.
  *       A LAG is a logical interface that uses the Link Aggregation Control Protocol
@@ -42,6 +47,8 @@ export interface CreateLagCommandOutput extends Lag, __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateLagCommandInput - {@link CreateLagCommandInput}
+ * @returns {@link CreateLagCommandOutput}
  * @see {@link CreateLagCommandInput} for command's `input` shape.
  * @see {@link CreateLagCommandOutput} for command's `response` shape.
  * @see {@link DirectConnectClientResolvedConfig | config} for DirectConnectClient's `config` shape.
@@ -63,11 +70,20 @@ export interface CreateLagCommandOutput extends Lag, __MetadataBearer {
 export declare class CreateLagCommand extends $Command<CreateLagCommandInput, CreateLagCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: CreateLagCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateLagCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLagCommandInput, CreateLagCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
 import { CreatePrivateVirtualInterfaceRequest, VirtualInterface } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreatePrivateVirtualInterfaceCommand}.
  */
 export interface CreatePrivateVirtualInterfaceCommandInput extends CreatePrivateVirtualInterfaceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreatePrivateVirtualInterfaceCommand}.
  */
 export interface CreatePrivateVirtualInterfaceCommandOutput extends VirtualInterface, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a private virtual interface. A virtual interface is the VLAN that transports Direct Connect traffic.
  *       A private virtual interface can be connected to either a Direct Connect gateway or a Virtual Private Gateway (VGW).
  *       Connecting the private virtual interface to a Direct Connect gateway enables the possibility for connecting to multiple
@@ -35,6 +40,8 @@ export interface CreatePrivateVirtualInterfaceCommandOutput extends VirtualInter
  * const response = await client.send(command);
  * ```
  *
+ * @param CreatePrivateVirtualInterfaceCommandInput - {@link CreatePrivateVirtualInterfaceCommandInput}
+ * @returns {@link CreatePrivateVirtualInterfaceCommandOutput}
  * @see {@link CreatePrivateVirtualInterfaceCommandInput} for command's `input` shape.
  * @see {@link CreatePrivateVirtualInterfaceCommandOutput} for command's `response` shape.
  * @see {@link DirectConnectClientResolvedConfig | config} for DirectConnectClient's `config` shape.
@@ -56,11 +63,20 @@ export interface CreatePrivateVirtualInterfaceCommandOutput extends VirtualInter
 export declare class CreatePrivateVirtualInterfaceCommand extends $Command<CreatePrivateVirtualInterfaceCommandInput, CreatePrivateVirtualInterfaceCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: CreatePrivateVirtualInterfaceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreatePrivateVirtualInterfaceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreatePrivateVirtualInterfaceCommandInput, CreatePrivateVirtualInterfaceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
 import { CreatePublicVirtualInterfaceRequest, VirtualInterface } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreatePublicVirtualInterfaceCommand}.
  */
 export interface CreatePublicVirtualInterfaceCommandInput extends CreatePublicVirtualInterfaceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreatePublicVirtualInterfaceCommand}.
  */
 export interface CreatePublicVirtualInterfaceCommandOutput extends VirtualInterface, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a public virtual interface. A virtual interface is the VLAN that transports Direct Connect traffic.
  *       A public virtual interface supports sending traffic to public services of Amazon Web Services such as Amazon S3.</p>
  *          <p>When creating an IPv6 public virtual interface (<code>addressFamily</code> is <code>ipv6</code>), leave the <code>customer</code>
@@ -28,6 +33,8 @@ export interface CreatePublicVirtualInterfaceCommandOutput extends VirtualInterf
  * const response = await client.send(command);
  * ```
  *
+ * @param CreatePublicVirtualInterfaceCommandInput - {@link CreatePublicVirtualInterfaceCommandInput}
+ * @returns {@link CreatePublicVirtualInterfaceCommandOutput}
  * @see {@link CreatePublicVirtualInterfaceCommandInput} for command's `input` shape.
  * @see {@link CreatePublicVirtualInterfaceCommandOutput} for command's `response` shape.
  * @see {@link DirectConnectClientResolvedConfig | config} for DirectConnectClient's `config` shape.
@@ -49,11 +56,20 @@ export interface CreatePublicVirtualInterfaceCommandOutput extends VirtualInterf
 export declare class CreatePublicVirtualInterfaceCommand extends $Command<CreatePublicVirtualInterfaceCommandInput, CreatePublicVirtualInterfaceCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: CreatePublicVirtualInterfaceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreatePublicVirtualInterfaceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreatePublicVirtualInterfaceCommandInput, CreatePublicVirtualInterfaceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
 import { CreateTransitVirtualInterfaceRequest, CreateTransitVirtualInterfaceResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateTransitVirtualInterfaceCommand}.
  */
 export interface CreateTransitVirtualInterfaceCommandInput extends CreateTransitVirtualInterfaceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateTransitVirtualInterfaceCommand}.
  */
 export interface CreateTransitVirtualInterfaceCommandOutput extends CreateTransitVirtualInterfaceResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a transit virtual interface. A transit virtual interface should be used to access one or more transit gateways associated with Direct Connect gateways. A transit virtual interface enables the connection of multiple VPCs attached to a transit gateway to a Direct Connect gateway.</p>
  *          <important>
  *             <p>If you associate your transit gateway with one or more Direct Connect gateways, the Autonomous System Number (ASN) used by the transit gateway and the Direct Connect gateway must be different. For example, if you use the default ASN 64512 for both your the transit gateway and Direct Connect gateway, the association request fails.</p>
@@ -34,6 +39,8 @@ export interface CreateTransitVirtualInterfaceCommandOutput extends CreateTransi
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateTransitVirtualInterfaceCommandInput - {@link CreateTransitVirtualInterfaceCommandInput}
+ * @returns {@link CreateTransitVirtualInterfaceCommandOutput}
  * @see {@link CreateTransitVirtualInterfaceCommandInput} for command's `input` shape.
  * @see {@link CreateTransitVirtualInterfaceCommandOutput} for command's `response` shape.
  * @see {@link DirectConnectClientResolvedConfig | config} for DirectConnectClient's `config` shape.
@@ -55,11 +62,20 @@ export interface CreateTransitVirtualInterfaceCommandOutput extends CreateTransi
 export declare class CreateTransitVirtualInterfaceCommand extends $Command<CreateTransitVirtualInterfaceCommandInput, CreateTransitVirtualInterfaceCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: CreateTransitVirtualInterfaceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateTransitVirtualInterfaceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTransitVirtualInterfaceCommandInput, CreateTransitVirtualInterfaceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }