@aws-sdk/client-direct-connect 3.35.0 → 3.38.0

package/dist-types/ts3.4/commands/DeleteDirectConnectGatewayAssociationProposalCommand.d.ts

@@ -6,29 +6,11 @@ export interface DeleteDirectConnectGatewayAssociationProposalCommandInput exten
 }
 export interface DeleteDirectConnectGatewayAssociationProposalCommandOutput extends DeleteDirectConnectGatewayAssociationProposalResult, __MetadataBearer {
 }
-/**
- * <p>Deletes the association proposal request between the specified Direct Connect gateway and virtual private gateway or transit gateway.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, DeleteDirectConnectGatewayAssociationProposalCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, DeleteDirectConnectGatewayAssociationProposalCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new DeleteDirectConnectGatewayAssociationProposalCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteDirectConnectGatewayAssociationProposalCommandInput} for command's `input` shape.
- * @see {@link DeleteDirectConnectGatewayAssociationProposalCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteDirectConnectGatewayAssociationProposalCommand extends $Command<DeleteDirectConnectGatewayAssociationProposalCommandInput, DeleteDirectConnectGatewayAssociationProposalCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: DeleteDirectConnectGatewayAssociationProposalCommandInput;
     constructor(input: DeleteDirectConnectGatewayAssociationProposalCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDirectConnectGatewayAssociationProposalCommandInput, DeleteDirectConnectGatewayAssociationProposalCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteDirectConnectGatewayCommand.d.ts

@@ -6,31 +6,11 @@ export interface DeleteDirectConnectGatewayCommandInput extends DeleteDirectConn
 }
 export interface DeleteDirectConnectGatewayCommandOutput extends DeleteDirectConnectGatewayResult, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified Direct Connect gateway. You must first delete all virtual interfaces that are
- *       attached to the Direct Connect gateway and disassociate all virtual private gateways associated
- *       with the Direct Connect gateway.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, DeleteDirectConnectGatewayCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, DeleteDirectConnectGatewayCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new DeleteDirectConnectGatewayCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteDirectConnectGatewayCommandInput} for command's `input` shape.
- * @see {@link DeleteDirectConnectGatewayCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteDirectConnectGatewayCommand extends $Command<DeleteDirectConnectGatewayCommandInput, DeleteDirectConnectGatewayCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: DeleteDirectConnectGatewayCommandInput;
     constructor(input: DeleteDirectConnectGatewayCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDirectConnectGatewayCommandInput, DeleteDirectConnectGatewayCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteInterconnectCommand.d.ts

@@ -6,33 +6,11 @@ export interface DeleteInterconnectCommandInput extends DeleteInterconnectReques
 }
 export interface DeleteInterconnectCommandOutput extends DeleteInterconnectResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified interconnect.</p>
- *          <note>
- *             <p>Intended for use
- *         by Direct Connect Partners only.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, DeleteInterconnectCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, DeleteInterconnectCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new DeleteInterconnectCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteInterconnectCommandInput} for command's `input` shape.
- * @see {@link DeleteInterconnectCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteInterconnectCommand extends $Command<DeleteInterconnectCommandInput, DeleteInterconnectCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: DeleteInterconnectCommandInput;
     constructor(input: DeleteInterconnectCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteInterconnectCommandInput, DeleteInterconnectCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteLagCommand.d.ts

@@ -6,30 +6,11 @@ export interface DeleteLagCommandInput extends DeleteLagRequest {
 }
 export interface DeleteLagCommandOutput extends Lag, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified link aggregation group (LAG). You cannot delete a LAG if it has active
- *       virtual interfaces or hosted connections.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, DeleteLagCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, DeleteLagCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new DeleteLagCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteLagCommandInput} for command's `input` shape.
- * @see {@link DeleteLagCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteLagCommand extends $Command<DeleteLagCommandInput, DeleteLagCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: DeleteLagCommandInput;
     constructor(input: DeleteLagCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteLagCommandInput, DeleteLagCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteVirtualInterfaceCommand.d.ts

@@ -6,29 +6,11 @@ export interface DeleteVirtualInterfaceCommandInput extends DeleteVirtualInterfa
 }
 export interface DeleteVirtualInterfaceCommandOutput extends DeleteVirtualInterfaceResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes a virtual interface.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, DeleteVirtualInterfaceCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, DeleteVirtualInterfaceCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new DeleteVirtualInterfaceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteVirtualInterfaceCommandInput} for command's `input` shape.
- * @see {@link DeleteVirtualInterfaceCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteVirtualInterfaceCommand extends $Command<DeleteVirtualInterfaceCommandInput, DeleteVirtualInterfaceCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: DeleteVirtualInterfaceCommandInput;
     constructor(input: DeleteVirtualInterfaceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteVirtualInterfaceCommandInput, DeleteVirtualInterfaceCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeConnectionLoaCommand.d.ts

@@ -6,36 +6,11 @@ export interface DescribeConnectionLoaCommandInput extends DescribeConnectionLoa
 }
 export interface DescribeConnectionLoaCommandOutput extends DescribeConnectionLoaResponse, __MetadataBearer {
 }
-/**
- * @deprecated
- *
- * <p>Deprecated. Use <a>DescribeLoa</a> instead.</p>
- *          <p>Gets the LOA-CFA for a connection.</p>
- *          <p>The Letter of Authorization - Connecting Facility Assignment (LOA-CFA) is a document that your APN partner or
- *       service provider uses when establishing your cross connect to Amazon Web Services at the colocation facility. For more information,
- *       see <a href="https://docs.aws.amazon.com/directconnect/latest/UserGuide/Colocation.html">Requesting Cross Connects
- *       at Direct Connect Locations</a> in the <i>Direct Connect User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, DescribeConnectionLoaCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, DescribeConnectionLoaCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new DescribeConnectionLoaCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeConnectionLoaCommandInput} for command's `input` shape.
- * @see {@link DescribeConnectionLoaCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeConnectionLoaCommand extends $Command<DescribeConnectionLoaCommandInput, DescribeConnectionLoaCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: DescribeConnectionLoaCommandInput;
     constructor(input: DescribeConnectionLoaCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeConnectionLoaCommandInput, DescribeConnectionLoaCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeConnectionsCommand.d.ts

@@ -6,29 +6,11 @@ export interface DescribeConnectionsCommandInput extends DescribeConnectionsRequ
 }
 export interface DescribeConnectionsCommandOutput extends Connections, __MetadataBearer {
 }
-/**
- * <p>Displays the specified connection or all connections in this Region.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, DescribeConnectionsCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, DescribeConnectionsCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new DescribeConnectionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeConnectionsCommandInput} for command's `input` shape.
- * @see {@link DescribeConnectionsCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeConnectionsCommand extends $Command<DescribeConnectionsCommandInput, DescribeConnectionsCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: DescribeConnectionsCommandInput;
     constructor(input: DescribeConnectionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeConnectionsCommandInput, DescribeConnectionsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeConnectionsOnInterconnectCommand.d.ts

@@ -6,35 +6,11 @@ export interface DescribeConnectionsOnInterconnectCommandInput extends DescribeC
 }
 export interface DescribeConnectionsOnInterconnectCommandOutput extends Connections, __MetadataBearer {
 }
-/**
- * @deprecated
- *
- * <p>Deprecated. Use <a>DescribeHostedConnections</a> instead.</p>
- *          <p>Lists the connections that have been provisioned on the specified interconnect.</p>
- *          <note>
- *             <p>Intended for use by Direct Connect Partners only.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, DescribeConnectionsOnInterconnectCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, DescribeConnectionsOnInterconnectCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new DescribeConnectionsOnInterconnectCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeConnectionsOnInterconnectCommandInput} for command's `input` shape.
- * @see {@link DescribeConnectionsOnInterconnectCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeConnectionsOnInterconnectCommand extends $Command<DescribeConnectionsOnInterconnectCommandInput, DescribeConnectionsOnInterconnectCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: DescribeConnectionsOnInterconnectCommandInput;
     constructor(input: DescribeConnectionsOnInterconnectCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeConnectionsOnInterconnectCommandInput, DescribeConnectionsOnInterconnectCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeCustomerMetadataCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DirectConnectClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DirectConnectClient";
+import { DescribeCustomerMetadataResponse } from "../models/models_0";
+export interface DescribeCustomerMetadataCommandInput {
+}
+export interface DescribeCustomerMetadataCommandOutput extends DescribeCustomerMetadataResponse, __MetadataBearer {
+}
+
+export declare class DescribeCustomerMetadataCommand extends $Command<DescribeCustomerMetadataCommandInput, DescribeCustomerMetadataCommandOutput, DirectConnectClientResolvedConfig> {
+    readonly input: DescribeCustomerMetadataCommandInput;
+    constructor(input: DescribeCustomerMetadataCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeCustomerMetadataCommandInput, DescribeCustomerMetadataCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DescribeDirectConnectGatewayAssociationProposalsCommand.d.ts

@@ -6,29 +6,11 @@ export interface DescribeDirectConnectGatewayAssociationProposalsCommandInput ex
 }
 export interface DescribeDirectConnectGatewayAssociationProposalsCommandOutput extends DescribeDirectConnectGatewayAssociationProposalsResult, __MetadataBearer {
 }
-/**
- * <p>Describes one or more association proposals for connection between a virtual private gateway or transit gateway and a Direct Connect gateway. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, DescribeDirectConnectGatewayAssociationProposalsCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, DescribeDirectConnectGatewayAssociationProposalsCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new DescribeDirectConnectGatewayAssociationProposalsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDirectConnectGatewayAssociationProposalsCommandInput} for command's `input` shape.
- * @see {@link DescribeDirectConnectGatewayAssociationProposalsCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeDirectConnectGatewayAssociationProposalsCommand extends $Command<DescribeDirectConnectGatewayAssociationProposalsCommandInput, DescribeDirectConnectGatewayAssociationProposalsCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: DescribeDirectConnectGatewayAssociationProposalsCommandInput;
     constructor(input: DescribeDirectConnectGatewayAssociationProposalsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDirectConnectGatewayAssociationProposalsCommandInput, DescribeDirectConnectGatewayAssociationProposalsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeDirectConnectGatewayAssociationsCommand.d.ts

@@ -6,51 +6,11 @@ export interface DescribeDirectConnectGatewayAssociationsCommandInput extends De
 }
 export interface DescribeDirectConnectGatewayAssociationsCommandOutput extends DescribeDirectConnectGatewayAssociationsResult, __MetadataBearer {
 }
-/**
- * <p>Lists the associations between your Direct Connect gateways and virtual private gateways and transit gateways. You must specify one of the following:</p>
- *          <ul>
- *             <li>
- *                <p>A Direct Connect gateway</p>
- *                <p>The response contains all virtual private gateways and transit gateways associated with the Direct Connect gateway.</p>
- *             </li>
- *             <li>
- *                <p>A virtual private gateway</p>
- *                <p>The response contains the Direct Connect gateway.</p>
- *             </li>
- *             <li>
- *                <p>A transit gateway</p>
- *                <p>The response contains the Direct Connect gateway.</p>
- *             </li>
- *             <li>
- *                <p>A Direct Connect gateway and a virtual private gateway</p>
- *                <p>The response contains the association between the Direct Connect gateway and virtual private gateway.</p>
- *             </li>
- *             <li>
- *                <p>A Direct Connect gateway and a transit gateway</p>
- *                <p>The response contains the association between the Direct Connect gateway and transit gateway.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, DescribeDirectConnectGatewayAssociationsCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, DescribeDirectConnectGatewayAssociationsCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new DescribeDirectConnectGatewayAssociationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDirectConnectGatewayAssociationsCommandInput} for command's `input` shape.
- * @see {@link DescribeDirectConnectGatewayAssociationsCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeDirectConnectGatewayAssociationsCommand extends $Command<DescribeDirectConnectGatewayAssociationsCommandInput, DescribeDirectConnectGatewayAssociationsCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: DescribeDirectConnectGatewayAssociationsCommandInput;
     constructor(input: DescribeDirectConnectGatewayAssociationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDirectConnectGatewayAssociationsCommandInput, DescribeDirectConnectGatewayAssociationsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeDirectConnectGatewayAttachmentsCommand.d.ts

@@ -6,33 +6,11 @@ export interface DescribeDirectConnectGatewayAttachmentsCommandInput extends Des
 }
 export interface DescribeDirectConnectGatewayAttachmentsCommandOutput extends DescribeDirectConnectGatewayAttachmentsResult, __MetadataBearer {
 }
-/**
- * <p>Lists the attachments between your Direct Connect gateways and virtual interfaces. You must specify
- *       a Direct Connect gateway, a virtual interface, or both. If you specify a Direct Connect gateway, the response contains
- *       all virtual interfaces attached to the Direct Connect gateway. If you specify a virtual interface, the
- *       response contains all Direct Connect gateways attached to the virtual interface. If you specify both,
- *       the response contains the attachment between the Direct Connect gateway and the virtual interface.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, DescribeDirectConnectGatewayAttachmentsCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, DescribeDirectConnectGatewayAttachmentsCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new DescribeDirectConnectGatewayAttachmentsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDirectConnectGatewayAttachmentsCommandInput} for command's `input` shape.
- * @see {@link DescribeDirectConnectGatewayAttachmentsCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeDirectConnectGatewayAttachmentsCommand extends $Command<DescribeDirectConnectGatewayAttachmentsCommandInput, DescribeDirectConnectGatewayAttachmentsCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: DescribeDirectConnectGatewayAttachmentsCommandInput;
     constructor(input: DescribeDirectConnectGatewayAttachmentsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDirectConnectGatewayAttachmentsCommandInput, DescribeDirectConnectGatewayAttachmentsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeDirectConnectGatewaysCommand.d.ts

@@ -6,29 +6,11 @@ export interface DescribeDirectConnectGatewaysCommandInput extends DescribeDirec
 }
 export interface DescribeDirectConnectGatewaysCommandOutput extends DescribeDirectConnectGatewaysResult, __MetadataBearer {
 }
-/**
- * <p>Lists all your Direct Connect gateways or only the specified Direct Connect gateway. Deleted Direct Connect gateways are not returned.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, DescribeDirectConnectGatewaysCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, DescribeDirectConnectGatewaysCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new DescribeDirectConnectGatewaysCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDirectConnectGatewaysCommandInput} for command's `input` shape.
- * @see {@link DescribeDirectConnectGatewaysCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeDirectConnectGatewaysCommand extends $Command<DescribeDirectConnectGatewaysCommandInput, DescribeDirectConnectGatewaysCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: DescribeDirectConnectGatewaysCommandInput;
     constructor(input: DescribeDirectConnectGatewaysCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDirectConnectGatewaysCommandInput, DescribeDirectConnectGatewaysCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeHostedConnectionsCommand.d.ts

@@ -6,33 +6,11 @@ export interface DescribeHostedConnectionsCommandInput extends DescribeHostedCon
 }
 export interface DescribeHostedConnectionsCommandOutput extends Connections, __MetadataBearer {
 }
-/**
- * <p>Lists the hosted connections that have been provisioned on the specified
- *       interconnect or link aggregation group (LAG).</p>
- *          <note>
- *             <p>Intended for use by Direct Connect Partners only.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, DescribeHostedConnectionsCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, DescribeHostedConnectionsCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new DescribeHostedConnectionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeHostedConnectionsCommandInput} for command's `input` shape.
- * @see {@link DescribeHostedConnectionsCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeHostedConnectionsCommand extends $Command<DescribeHostedConnectionsCommandInput, DescribeHostedConnectionsCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: DescribeHostedConnectionsCommandInput;
     constructor(input: DescribeHostedConnectionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeHostedConnectionsCommandInput, DescribeHostedConnectionsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeInterconnectLoaCommand.d.ts

@@ -6,35 +6,11 @@ export interface DescribeInterconnectLoaCommandInput extends DescribeInterconnec
 }
 export interface DescribeInterconnectLoaCommandOutput extends DescribeInterconnectLoaResponse, __MetadataBearer {
 }
-/**
- * @deprecated
- *
- * <p>Deprecated. Use <a>DescribeLoa</a> instead.</p>
- *          <p>Gets the LOA-CFA for the specified interconnect.</p>
- *          <p>The Letter of Authorization - Connecting Facility Assignment (LOA-CFA) is a document that is used when establishing your cross connect to Amazon Web Services at the colocation facility.
- *       For more information, see <a href="https://docs.aws.amazon.com/directconnect/latest/UserGuide/Colocation.html">Requesting Cross Connects at Direct Connect Locations</a>
- *       in the <i>Direct Connect User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, DescribeInterconnectLoaCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, DescribeInterconnectLoaCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new DescribeInterconnectLoaCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeInterconnectLoaCommandInput} for command's `input` shape.
- * @see {@link DescribeInterconnectLoaCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeInterconnectLoaCommand extends $Command<DescribeInterconnectLoaCommandInput, DescribeInterconnectLoaCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: DescribeInterconnectLoaCommandInput;
     constructor(input: DescribeInterconnectLoaCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeInterconnectLoaCommandInput, DescribeInterconnectLoaCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeInterconnectsCommand.d.ts

@@ -6,29 +6,11 @@ export interface DescribeInterconnectsCommandInput extends DescribeInterconnects
 }
 export interface DescribeInterconnectsCommandOutput extends Interconnects, __MetadataBearer {
 }
-/**
- * <p>Lists the interconnects owned by the account or only the specified interconnect.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, DescribeInterconnectsCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, DescribeInterconnectsCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new DescribeInterconnectsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeInterconnectsCommandInput} for command's `input` shape.
- * @see {@link DescribeInterconnectsCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeInterconnectsCommand extends $Command<DescribeInterconnectsCommandInput, DescribeInterconnectsCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: DescribeInterconnectsCommandInput;
     constructor(input: DescribeInterconnectsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeInterconnectsCommandInput, DescribeInterconnectsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeLagsCommand.d.ts

@@ -6,29 +6,11 @@ export interface DescribeLagsCommandInput extends DescribeLagsRequest {
 }
 export interface DescribeLagsCommandOutput extends Lags, __MetadataBearer {
 }
-/**
- * <p>Describes all your link aggregation groups (LAG) or the specified LAG.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, DescribeLagsCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, DescribeLagsCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new DescribeLagsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeLagsCommandInput} for command's `input` shape.
- * @see {@link DescribeLagsCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeLagsCommand extends $Command<DescribeLagsCommandInput, DescribeLagsCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: DescribeLagsCommandInput;
     constructor(input: DescribeLagsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeLagsCommandInput, DescribeLagsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeLoaCommand.d.ts

@@ -6,32 +6,11 @@ export interface DescribeLoaCommandInput extends DescribeLoaRequest {
 }
 export interface DescribeLoaCommandOutput extends Loa, __MetadataBearer {
 }
-/**
- * <p>Gets the LOA-CFA for a connection, interconnect, or link aggregation group (LAG).</p>
- *          <p>The Letter of Authorization - Connecting Facility Assignment (LOA-CFA) is a document that is used when establishing
- *       your cross connect to Amazon Web Services at the colocation facility. For more information, see <a href="https://docs.aws.amazon.com/directconnect/latest/UserGuide/Colocation.html">Requesting Cross Connects at Direct Connect Locations</a>
- *       in the <i>Direct Connect User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, DescribeLoaCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, DescribeLoaCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new DescribeLoaCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeLoaCommandInput} for command's `input` shape.
- * @see {@link DescribeLoaCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeLoaCommand extends $Command<DescribeLoaCommandInput, DescribeLoaCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: DescribeLoaCommandInput;
     constructor(input: DescribeLoaCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeLoaCommandInput, DescribeLoaCommandOutput>;
     private serialize;
     private deserialize;