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

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
 import { AllocateConnectionOnInterconnectRequest, Connection } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link AllocateConnectionOnInterconnectCommand}.
  */
 export interface AllocateConnectionOnInterconnectCommandInput extends AllocateConnectionOnInterconnectRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link AllocateConnectionOnInterconnectCommand}.
  */
 export interface AllocateConnectionOnInterconnectCommandOutput extends Connection, __MetadataBearer {
 }
 /**
+ * @public
  * @deprecated
  *
  * <p>Deprecated. Use <a>AllocateHostedConnection</a> instead.</p>
@@ -32,6 +37,8 @@ export interface AllocateConnectionOnInterconnectCommandOutput extends Connectio
  * const response = await client.send(command);
  * ```
  *
+ * @param AllocateConnectionOnInterconnectCommandInput - {@link AllocateConnectionOnInterconnectCommandInput}
+ * @returns {@link AllocateConnectionOnInterconnectCommandOutput}
  * @see {@link AllocateConnectionOnInterconnectCommandInput} for command's `input` shape.
  * @see {@link AllocateConnectionOnInterconnectCommandOutput} for command's `response` shape.
  * @see {@link DirectConnectClientResolvedConfig | config} for DirectConnectClient's `config` shape.
@@ -47,11 +54,20 @@ export interface AllocateConnectionOnInterconnectCommandOutput extends Connectio
 export declare class AllocateConnectionOnInterconnectCommand extends $Command<AllocateConnectionOnInterconnectCommandInput, AllocateConnectionOnInterconnectCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: AllocateConnectionOnInterconnectCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: AllocateConnectionOnInterconnectCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AllocateConnectionOnInterconnectCommandInput, AllocateConnectionOnInterconnectCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
 import { AllocateHostedConnectionRequest, Connection } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link AllocateHostedConnectionCommand}.
  */
 export interface AllocateHostedConnectionCommandInput extends AllocateHostedConnectionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link AllocateHostedConnectionCommand}.
  */
 export interface AllocateHostedConnectionCommandOutput extends Connection, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a hosted connection on the specified interconnect or a link aggregation group (LAG) of interconnects.</p>
  *          <p>Allocates a VLAN number and a specified amount of capacity (bandwidth) for use by a hosted connection on the specified interconnect or LAG of interconnects.
  *       Amazon Web Services polices the hosted connection for the specified capacity and the Direct Connect Partner must also police the hosted connection for the specified capacity.</p>
@@ -30,6 +35,8 @@ export interface AllocateHostedConnectionCommandOutput extends Connection, __Met
  * const response = await client.send(command);
  * ```
  *
+ * @param AllocateHostedConnectionCommandInput - {@link AllocateHostedConnectionCommandInput}
+ * @returns {@link AllocateHostedConnectionCommandOutput}
  * @see {@link AllocateHostedConnectionCommandInput} for command's `input` shape.
  * @see {@link AllocateHostedConnectionCommandOutput} for command's `response` shape.
  * @see {@link DirectConnectClientResolvedConfig | config} for DirectConnectClient's `config` shape.
@@ -51,11 +58,20 @@ export interface AllocateHostedConnectionCommandOutput extends Connection, __Met
 export declare class AllocateHostedConnectionCommand extends $Command<AllocateHostedConnectionCommandInput, AllocateHostedConnectionCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: AllocateHostedConnectionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: AllocateHostedConnectionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AllocateHostedConnectionCommandInput, AllocateHostedConnectionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
 import { AllocatePrivateVirtualInterfaceRequest, VirtualInterface } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link AllocatePrivateVirtualInterfaceCommand}.
  */
 export interface AllocatePrivateVirtualInterfaceCommandInput extends AllocatePrivateVirtualInterfaceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link AllocatePrivateVirtualInterfaceCommand}.
  */
 export interface AllocatePrivateVirtualInterfaceCommandOutput extends VirtualInterface, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Provisions a private virtual interface to be owned by the specified Amazon Web Services account.</p>
  *          <p>Virtual interfaces created using this action must be confirmed by the owner using <a>ConfirmPrivateVirtualInterface</a>.
  *       Until then, the virtual interface is in the <code>Confirming</code> state and is not available to handle traffic.</p>
@@ -27,6 +32,8 @@ export interface AllocatePrivateVirtualInterfaceCommandOutput extends VirtualInt
  * const response = await client.send(command);
  * ```
  *
+ * @param AllocatePrivateVirtualInterfaceCommandInput - {@link AllocatePrivateVirtualInterfaceCommandInput}
+ * @returns {@link AllocatePrivateVirtualInterfaceCommandOutput}
  * @see {@link AllocatePrivateVirtualInterfaceCommandInput} for command's `input` shape.
  * @see {@link AllocatePrivateVirtualInterfaceCommandOutput} for command's `response` shape.
  * @see {@link DirectConnectClientResolvedConfig | config} for DirectConnectClient's `config` shape.
@@ -48,11 +55,20 @@ export interface AllocatePrivateVirtualInterfaceCommandOutput extends VirtualInt
 export declare class AllocatePrivateVirtualInterfaceCommand extends $Command<AllocatePrivateVirtualInterfaceCommandInput, AllocatePrivateVirtualInterfaceCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: AllocatePrivateVirtualInterfaceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: AllocatePrivateVirtualInterfaceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AllocatePrivateVirtualInterfaceCommandInput, AllocatePrivateVirtualInterfaceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
 import { AllocatePublicVirtualInterfaceRequest, VirtualInterface } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link AllocatePublicVirtualInterfaceCommand}.
  */
 export interface AllocatePublicVirtualInterfaceCommandInput extends AllocatePublicVirtualInterfaceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link AllocatePublicVirtualInterfaceCommand}.
  */
 export interface AllocatePublicVirtualInterfaceCommandOutput extends VirtualInterface, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Provisions a public virtual interface to be owned by the specified Amazon Web Services account.</p>
  *          <p>The owner of a connection calls this function to provision a public virtual interface to be owned by the specified Amazon Web Services account.</p>
  *          <p>Virtual interfaces created using this function must be confirmed by the owner using <a>ConfirmPublicVirtualInterface</a>.
@@ -30,6 +35,8 @@ export interface AllocatePublicVirtualInterfaceCommandOutput extends VirtualInte
  * const response = await client.send(command);
  * ```
  *
+ * @param AllocatePublicVirtualInterfaceCommandInput - {@link AllocatePublicVirtualInterfaceCommandInput}
+ * @returns {@link AllocatePublicVirtualInterfaceCommandOutput}
  * @see {@link AllocatePublicVirtualInterfaceCommandInput} for command's `input` shape.
  * @see {@link AllocatePublicVirtualInterfaceCommandOutput} for command's `response` shape.
  * @see {@link DirectConnectClientResolvedConfig | config} for DirectConnectClient's `config` shape.
@@ -51,11 +58,20 @@ export interface AllocatePublicVirtualInterfaceCommandOutput extends VirtualInte
 export declare class AllocatePublicVirtualInterfaceCommand extends $Command<AllocatePublicVirtualInterfaceCommandInput, AllocatePublicVirtualInterfaceCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: AllocatePublicVirtualInterfaceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: AllocatePublicVirtualInterfaceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AllocatePublicVirtualInterfaceCommandInput, AllocatePublicVirtualInterfaceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
 import { AllocateTransitVirtualInterfaceRequest, AllocateTransitVirtualInterfaceResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link AllocateTransitVirtualInterfaceCommand}.
  */
 export interface AllocateTransitVirtualInterfaceCommandInput extends AllocateTransitVirtualInterfaceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link AllocateTransitVirtualInterfaceCommand}.
  */
 export interface AllocateTransitVirtualInterfaceCommandOutput extends AllocateTransitVirtualInterfaceResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Provisions a transit virtual interface to be owned by the specified Amazon Web Services account. Use this type of interface to connect a transit gateway to your Direct Connect gateway.</p>
  *          <p>The owner of a connection provisions a transit virtual interface to be owned by the specified Amazon Web Services account.</p>
  *          <p>After you create a transit virtual interface, it must be confirmed by the owner using <a>ConfirmTransitVirtualInterface</a>. Until this step has been completed, the transit virtual interface is in the <code>requested</code> state and is not available to handle traffic.</p>
@@ -27,6 +32,8 @@ export interface AllocateTransitVirtualInterfaceCommandOutput extends AllocateTr
  * const response = await client.send(command);
  * ```
  *
+ * @param AllocateTransitVirtualInterfaceCommandInput - {@link AllocateTransitVirtualInterfaceCommandInput}
+ * @returns {@link AllocateTransitVirtualInterfaceCommandOutput}
  * @see {@link AllocateTransitVirtualInterfaceCommandInput} for command's `input` shape.
  * @see {@link AllocateTransitVirtualInterfaceCommandOutput} for command's `response` shape.
  * @see {@link DirectConnectClientResolvedConfig | config} for DirectConnectClient's `config` shape.
@@ -48,11 +55,20 @@ export interface AllocateTransitVirtualInterfaceCommandOutput extends AllocateTr
 export declare class AllocateTransitVirtualInterfaceCommand extends $Command<AllocateTransitVirtualInterfaceCommandInput, AllocateTransitVirtualInterfaceCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: AllocateTransitVirtualInterfaceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: AllocateTransitVirtualInterfaceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AllocateTransitVirtualInterfaceCommandInput, AllocateTransitVirtualInterfaceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
 import { AssociateConnectionWithLagRequest, Connection } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link AssociateConnectionWithLagCommand}.
  */
 export interface AssociateConnectionWithLagCommandInput extends AssociateConnectionWithLagRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link AssociateConnectionWithLagCommand}.
  */
 export interface AssociateConnectionWithLagCommandOutput extends Connection, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Associates an existing connection with a link aggregation group (LAG). The connection
  *       is interrupted and re-established as a member of the LAG (connectivity to Amazon Web Services is
  *       interrupted). The connection must be hosted on the same Direct Connect endpoint as the LAG, and its
@@ -38,6 +43,8 @@ export interface AssociateConnectionWithLagCommandOutput extends Connection, __M
  * const response = await client.send(command);
  * ```
  *
+ * @param AssociateConnectionWithLagCommandInput - {@link AssociateConnectionWithLagCommandInput}
+ * @returns {@link AssociateConnectionWithLagCommandOutput}
  * @see {@link AssociateConnectionWithLagCommandInput} for command's `input` shape.
  * @see {@link AssociateConnectionWithLagCommandOutput} for command's `response` shape.
  * @see {@link DirectConnectClientResolvedConfig | config} for DirectConnectClient's `config` shape.
@@ -53,11 +60,20 @@ export interface AssociateConnectionWithLagCommandOutput extends Connection, __M
 export declare class AssociateConnectionWithLagCommand extends $Command<AssociateConnectionWithLagCommandInput, AssociateConnectionWithLagCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: AssociateConnectionWithLagCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: AssociateConnectionWithLagCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateConnectionWithLagCommandInput, AssociateConnectionWithLagCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
 import { AssociateHostedConnectionRequest, Connection } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link AssociateHostedConnectionCommand}.
  */
 export interface AssociateHostedConnectionCommandInput extends AssociateHostedConnectionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link AssociateHostedConnectionCommand}.
  */
 export interface AssociateHostedConnectionCommandOutput extends Connection, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Associates a hosted connection and its virtual interfaces with a link aggregation
  *       group (LAG) or interconnect. If the target interconnect or LAG has an existing hosted
  *       connection with a conflicting VLAN number or IP address, the operation fails. This
@@ -32,6 +37,8 @@ export interface AssociateHostedConnectionCommandOutput extends Connection, __Me
  * const response = await client.send(command);
  * ```
  *
+ * @param AssociateHostedConnectionCommandInput - {@link AssociateHostedConnectionCommandInput}
+ * @returns {@link AssociateHostedConnectionCommandOutput}
  * @see {@link AssociateHostedConnectionCommandInput} for command's `input` shape.
  * @see {@link AssociateHostedConnectionCommandOutput} for command's `response` shape.
  * @see {@link DirectConnectClientResolvedConfig | config} for DirectConnectClient's `config` shape.
@@ -47,11 +54,20 @@ export interface AssociateHostedConnectionCommandOutput extends Connection, __Me
 export declare class AssociateHostedConnectionCommand extends $Command<AssociateHostedConnectionCommandInput, AssociateHostedConnectionCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: AssociateHostedConnectionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: AssociateHostedConnectionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateHostedConnectionCommandInput, AssociateHostedConnectionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
 import { AssociateMacSecKeyRequest, AssociateMacSecKeyResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link AssociateMacSecKeyCommand}.
  */
 export interface AssociateMacSecKeyCommandInput extends AssociateMacSecKeyRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link AssociateMacSecKeyCommand}.
  */
 export interface AssociateMacSecKeyCommandOutput extends AssociateMacSecKeyResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Associates a MAC Security (MACsec) Connection Key Name (CKN)/ Connectivity Association Key (CAK) pair with an Direct Connect dedicated connection.</p>
  *          <p>You must supply either the <code>secretARN,</code> or the CKN/CAK (<code>ckn</code> and <code>cak</code>) pair in the request.</p>
  *          <p>For information about MAC Security (MACsec) key considerations, see  <a href="https://docs.aws.amazon.com/directconnect/latest/UserGuide/direct-connect-mac-sec-getting-started.html#mac-sec-key-consideration">MACsec pre-shared CKN/CAK key considerations </a> in the <i>Direct Connect User Guide</i>.</p>
@@ -27,6 +32,8 @@ export interface AssociateMacSecKeyCommandOutput extends AssociateMacSecKeyRespo
  * const response = await client.send(command);
  * ```
  *
+ * @param AssociateMacSecKeyCommandInput - {@link AssociateMacSecKeyCommandInput}
+ * @returns {@link AssociateMacSecKeyCommandOutput}
  * @see {@link AssociateMacSecKeyCommandInput} for command's `input` shape.
  * @see {@link AssociateMacSecKeyCommandOutput} for command's `response` shape.
  * @see {@link DirectConnectClientResolvedConfig | config} for DirectConnectClient's `config` shape.
@@ -42,11 +49,20 @@ export interface AssociateMacSecKeyCommandOutput extends AssociateMacSecKeyRespo
 export declare class AssociateMacSecKeyCommand extends $Command<AssociateMacSecKeyCommandInput, AssociateMacSecKeyCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: AssociateMacSecKeyCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: AssociateMacSecKeyCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateMacSecKeyCommandInput, AssociateMacSecKeyCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
 import { AssociateVirtualInterfaceRequest, VirtualInterface } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link AssociateVirtualInterfaceCommand}.
  */
 export interface AssociateVirtualInterfaceCommandInput extends AssociateVirtualInterfaceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link AssociateVirtualInterfaceCommand}.
  */
 export interface AssociateVirtualInterfaceCommandOutput extends VirtualInterface, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Associates a virtual interface with a specified link aggregation group (LAG) or
  *       connection. Connectivity to Amazon Web Services is temporarily interrupted as the virtual interface is
  *       being migrated. If the target connection or LAG has an associated virtual interface with
@@ -34,6 +39,8 @@ export interface AssociateVirtualInterfaceCommandOutput extends VirtualInterface
  * const response = await client.send(command);
  * ```
  *
+ * @param AssociateVirtualInterfaceCommandInput - {@link AssociateVirtualInterfaceCommandInput}
+ * @returns {@link AssociateVirtualInterfaceCommandOutput}
  * @see {@link AssociateVirtualInterfaceCommandInput} for command's `input` shape.
  * @see {@link AssociateVirtualInterfaceCommandOutput} for command's `response` shape.
  * @see {@link DirectConnectClientResolvedConfig | config} for DirectConnectClient's `config` shape.
@@ -49,11 +56,20 @@ export interface AssociateVirtualInterfaceCommandOutput extends VirtualInterface
 export declare class AssociateVirtualInterfaceCommand extends $Command<AssociateVirtualInterfaceCommandInput, AssociateVirtualInterfaceCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: AssociateVirtualInterfaceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: AssociateVirtualInterfaceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateVirtualInterfaceCommandInput, AssociateVirtualInterfaceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
 import { ConfirmConnectionRequest, ConfirmConnectionResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link ConfirmConnectionCommand}.
  */
 export interface ConfirmConnectionCommandInput extends ConfirmConnectionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ConfirmConnectionCommand}.
  */
 export interface ConfirmConnectionCommandOutput extends ConfirmConnectionResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Confirms the creation of the specified hosted connection on an interconnect.</p>
  *          <p>Upon creation, the hosted connection is initially in the <code>Ordering</code> state, and
  *       remains in this state until the owner confirms creation of the hosted connection.</p>
@@ -27,6 +32,8 @@ export interface ConfirmConnectionCommandOutput extends ConfirmConnectionRespons
  * const response = await client.send(command);
  * ```
  *
+ * @param ConfirmConnectionCommandInput - {@link ConfirmConnectionCommandInput}
+ * @returns {@link ConfirmConnectionCommandOutput}
  * @see {@link ConfirmConnectionCommandInput} for command's `input` shape.
  * @see {@link ConfirmConnectionCommandOutput} for command's `response` shape.
  * @see {@link DirectConnectClientResolvedConfig | config} for DirectConnectClient's `config` shape.
@@ -42,11 +49,20 @@ export interface ConfirmConnectionCommandOutput extends ConfirmConnectionRespons
 export declare class ConfirmConnectionCommand extends $Command<ConfirmConnectionCommandInput, ConfirmConnectionCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: ConfirmConnectionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ConfirmConnectionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ConfirmConnectionCommandInput, ConfirmConnectionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
 import { ConfirmCustomerAgreementRequest, ConfirmCustomerAgreementResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link ConfirmCustomerAgreementCommand}.
  */
 export interface ConfirmCustomerAgreementCommandInput extends ConfirmCustomerAgreementRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ConfirmCustomerAgreementCommand}.
  */
 export interface ConfirmCustomerAgreementCommandOutput extends ConfirmCustomerAgreementResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>
  *       The confirmation of the terms of agreement when creating the connection/link aggregation group (LAG).
  *     </p>
@@ -27,6 +32,8 @@ export interface ConfirmCustomerAgreementCommandOutput extends ConfirmCustomerAg
  * const response = await client.send(command);
  * ```
  *
+ * @param ConfirmCustomerAgreementCommandInput - {@link ConfirmCustomerAgreementCommandInput}
+ * @returns {@link ConfirmCustomerAgreementCommandOutput}
  * @see {@link ConfirmCustomerAgreementCommandInput} for command's `input` shape.
  * @see {@link ConfirmCustomerAgreementCommandOutput} for command's `response` shape.
  * @see {@link DirectConnectClientResolvedConfig | config} for DirectConnectClient's `config` shape.
@@ -42,11 +49,20 @@ export interface ConfirmCustomerAgreementCommandOutput extends ConfirmCustomerAg
 export declare class ConfirmCustomerAgreementCommand extends $Command<ConfirmCustomerAgreementCommandInput, ConfirmCustomerAgreementCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: ConfirmCustomerAgreementCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ConfirmCustomerAgreementCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ConfirmCustomerAgreementCommandInput, ConfirmCustomerAgreementCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
 import { ConfirmPrivateVirtualInterfaceRequest, ConfirmPrivateVirtualInterfaceResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link ConfirmPrivateVirtualInterfaceCommand}.
  */
 export interface ConfirmPrivateVirtualInterfaceCommandInput extends ConfirmPrivateVirtualInterfaceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ConfirmPrivateVirtualInterfaceCommand}.
  */
 export interface ConfirmPrivateVirtualInterfaceCommandOutput extends ConfirmPrivateVirtualInterfaceResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Accepts ownership of a private virtual interface created by another Amazon Web Services account.</p>
  *          <p>After the virtual interface owner makes this call, the virtual interface is
  *       created and attached to the specified virtual private gateway or Direct Connect gateway, and is
@@ -28,6 +33,8 @@ export interface ConfirmPrivateVirtualInterfaceCommandOutput extends ConfirmPriv
  * const response = await client.send(command);
  * ```
  *
+ * @param ConfirmPrivateVirtualInterfaceCommandInput - {@link ConfirmPrivateVirtualInterfaceCommandInput}
+ * @returns {@link ConfirmPrivateVirtualInterfaceCommandOutput}
  * @see {@link ConfirmPrivateVirtualInterfaceCommandInput} for command's `input` shape.
  * @see {@link ConfirmPrivateVirtualInterfaceCommandOutput} for command's `response` shape.
  * @see {@link DirectConnectClientResolvedConfig | config} for DirectConnectClient's `config` shape.
@@ -43,11 +50,20 @@ export interface ConfirmPrivateVirtualInterfaceCommandOutput extends ConfirmPriv
 export declare class ConfirmPrivateVirtualInterfaceCommand extends $Command<ConfirmPrivateVirtualInterfaceCommandInput, ConfirmPrivateVirtualInterfaceCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: ConfirmPrivateVirtualInterfaceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ConfirmPrivateVirtualInterfaceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ConfirmPrivateVirtualInterfaceCommandInput, ConfirmPrivateVirtualInterfaceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }