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

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

@@ -6,30 +6,11 @@ export interface DescribeLocationsCommandInput {
 }
 export interface DescribeLocationsCommandOutput extends Locations, __MetadataBearer {
 }
-/**
- * <p>Lists the Direct Connect locations in the current Region. These are the locations that can be selected when calling
- *       <a>CreateConnection</a> or <a>CreateInterconnect</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, DescribeLocationsCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, DescribeLocationsCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new DescribeLocationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeLocationsCommandInput} for command's `input` shape.
- * @see {@link DescribeLocationsCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeLocationsCommand extends $Command<DescribeLocationsCommandInput, DescribeLocationsCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: DescribeLocationsCommandInput;
     constructor(input: DescribeLocationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeLocationsCommandInput, DescribeLocationsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeRouterConfigurationCommand.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 { DescribeRouterConfigurationRequest, DescribeRouterConfigurationResponse } from "../models/models_0";
+export interface DescribeRouterConfigurationCommandInput extends DescribeRouterConfigurationRequest {
+}
+export interface DescribeRouterConfigurationCommandOutput extends DescribeRouterConfigurationResponse, __MetadataBearer {
+}
+
+export declare class DescribeRouterConfigurationCommand extends $Command<DescribeRouterConfigurationCommandInput, DescribeRouterConfigurationCommandOutput, DirectConnectClientResolvedConfig> {
+    readonly input: DescribeRouterConfigurationCommandInput;
+    constructor(input: DescribeRouterConfigurationCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeRouterConfigurationCommandInput, DescribeRouterConfigurationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

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

@@ -6,30 +6,11 @@ export interface DescribeVirtualGatewaysCommandInput {
 }
 export interface DescribeVirtualGatewaysCommandOutput extends VirtualGateways, __MetadataBearer {
 }
-/**
- * <p>Lists the virtual private gateways owned by the account.</p>
- *          <p>You can create one or more Direct Connect private virtual interfaces linked to a virtual private gateway.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, DescribeVirtualGatewaysCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, DescribeVirtualGatewaysCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new DescribeVirtualGatewaysCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeVirtualGatewaysCommandInput} for command's `input` shape.
- * @see {@link DescribeVirtualGatewaysCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeVirtualGatewaysCommand extends $Command<DescribeVirtualGatewaysCommandInput, DescribeVirtualGatewaysCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: DescribeVirtualGatewaysCommandInput;
     constructor(input: DescribeVirtualGatewaysCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeVirtualGatewaysCommandInput, DescribeVirtualGatewaysCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DescribeVirtualInterfacesCommandInput extends DescribeVirtualIn
 }
 export interface DescribeVirtualInterfacesCommandOutput extends VirtualInterfaces, __MetadataBearer {
 }
-/**
- * <p>Displays all virtual interfaces for an account. Virtual interfaces deleted fewer
- *       than 15 minutes before you make the request are also returned. If you specify a
- *       connection ID, only the virtual interfaces associated with the connection are returned.
- *       If you specify a virtual interface ID, then only a single virtual interface is returned.</p>
- *          <p>A virtual interface (VLAN) transmits the traffic between the Direct Connect location and the customer network.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, DescribeVirtualInterfacesCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, DescribeVirtualInterfacesCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new DescribeVirtualInterfacesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeVirtualInterfacesCommandInput} for command's `input` shape.
- * @see {@link DescribeVirtualInterfacesCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeVirtualInterfacesCommand extends $Command<DescribeVirtualInterfacesCommandInput, DescribeVirtualInterfacesCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: DescribeVirtualInterfacesCommandInput;
     constructor(input: DescribeVirtualInterfacesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeVirtualInterfacesCommandInput, DescribeVirtualInterfacesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,38 +6,11 @@ export interface DisassociateConnectionFromLagCommandInput extends DisassociateC
 }
 export interface DisassociateConnectionFromLagCommandOutput extends Connection, __MetadataBearer {
 }
-/**
- * <p>Disassociates a connection from a link aggregation group (LAG). The connection is
- *       interrupted and re-established as a standalone connection (the connection is not
- *       deleted; to delete the connection, use the <a>DeleteConnection</a> request).
- *       If the LAG has associated virtual interfaces or hosted connections, they remain
- *       associated with the LAG. A disassociated connection owned by an Direct Connect Partner is
- *       automatically converted to an interconnect.</p>
- *          <p>If disassociating the connection would cause the LAG to fall below its setting for
- *       minimum number of operational connections, the request fails, except when it's the last
- *       member of the LAG. If all connections are disassociated, the LAG continues to exist as
- *       an empty LAG with no physical connections. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, DisassociateConnectionFromLagCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, DisassociateConnectionFromLagCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new DisassociateConnectionFromLagCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisassociateConnectionFromLagCommandInput} for command's `input` shape.
- * @see {@link DisassociateConnectionFromLagCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisassociateConnectionFromLagCommand extends $Command<DisassociateConnectionFromLagCommandInput, DisassociateConnectionFromLagCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: DisassociateConnectionFromLagCommandInput;
     constructor(input: DisassociateConnectionFromLagCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateConnectionFromLagCommandInput, DisassociateConnectionFromLagCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DisassociateMacSecKeyCommandInput extends DisassociateMacSecKey
 }
 export interface DisassociateMacSecKeyCommandOutput extends DisassociateMacSecKeyResponse, __MetadataBearer {
 }
-/**
- * <p>Removes the association between a MAC Security (MACsec) security key and an Direct Connect dedicated connection.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, DisassociateMacSecKeyCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, DisassociateMacSecKeyCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new DisassociateMacSecKeyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisassociateMacSecKeyCommandInput} for command's `input` shape.
- * @see {@link DisassociateMacSecKeyCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisassociateMacSecKeyCommand extends $Command<DisassociateMacSecKeyCommandInput, DisassociateMacSecKeyCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: DisassociateMacSecKeyCommandInput;
     constructor(input: DisassociateMacSecKeyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateMacSecKeyCommandInput, DisassociateMacSecKeyCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,32 +6,11 @@ export interface StartBgpFailoverTestCommandInput extends StartBgpFailoverTestRe
 }
 export interface StartBgpFailoverTestCommandOutput extends StartBgpFailoverTestResponse, __MetadataBearer {
 }
-/**
- * <p>Starts the virtual interface failover test that verifies your configuration meets your resiliency requirements by placing the BGP peering session in the DOWN state. You can then send traffic to verify that there are no outages.</p>
- *          <p>You can run the test on public, private, transit, and hosted virtual interfaces.</p>
- *          <p>You can use <a href="https://docs.aws.amazon.com/directconnect/latest/APIReference/API_ListVirtualInterfaceTestHistory.html">ListVirtualInterfaceTestHistory</a> to view the virtual interface test history.</p>
- *          <p>If you need to stop the test before the test interval completes, use <a href="https://docs.aws.amazon.com/directconnect/latest/APIReference/API_StopBgpFailoverTest.html">StopBgpFailoverTest</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, StartBgpFailoverTestCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, StartBgpFailoverTestCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new StartBgpFailoverTestCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartBgpFailoverTestCommandInput} for command's `input` shape.
- * @see {@link StartBgpFailoverTestCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartBgpFailoverTestCommand extends $Command<StartBgpFailoverTestCommandInput, StartBgpFailoverTestCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: StartBgpFailoverTestCommandInput;
     constructor(input: StartBgpFailoverTestCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartBgpFailoverTestCommandInput, StartBgpFailoverTestCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,30 +6,11 @@ export interface TagResourceCommandInput extends TagResourceRequest {
 }
 export interface TagResourceCommandOutput extends TagResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Adds the specified tags to the specified Direct Connect resource. Each resource can have a maximum of 50 tags.</p>
- *          <p>Each tag consists of a key and an optional value. If a tag with the same key is already associated with the resource, this action updates its value.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, TagResourceCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, TagResourceCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new TagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TagResourceCommandInput} for command's `input` shape.
- * @see {@link TagResourceCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: TagResourceCommandInput;
     constructor(input: TagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,38 +6,11 @@ export interface UpdateConnectionCommandInput extends UpdateConnectionRequest {
 }
 export interface UpdateConnectionCommandOutput extends Connection, __MetadataBearer {
 }
-/**
- * <p>Updates the Direct Connect dedicated connection configuration.</p>
- *          <p>You can update the following parameters for a connection:</p>
- *          <ul>
- *             <li>
- *                <p>The connection name</p>
- *             </li>
- *             <li>
- *                <p>The connection's MAC Security (MACsec) encryption mode.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, UpdateConnectionCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, UpdateConnectionCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new UpdateConnectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateConnectionCommandInput} for command's `input` shape.
- * @see {@link UpdateConnectionCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateConnectionCommand extends $Command<UpdateConnectionCommandInput, UpdateConnectionCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: UpdateConnectionCommandInput;
     constructor(input: UpdateConnectionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateConnectionCommandInput, UpdateConnectionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface UpdateDirectConnectGatewayAssociationCommandInput extends Updat
 }
 export interface UpdateDirectConnectGatewayAssociationCommandOutput extends UpdateDirectConnectGatewayAssociationResult, __MetadataBearer {
 }
-/**
- * <p>Updates the specified attributes of the Direct Connect gateway association.</p>
- *          <p>Add or remove prefixes from the association.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, UpdateDirectConnectGatewayAssociationCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, UpdateDirectConnectGatewayAssociationCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new UpdateDirectConnectGatewayAssociationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateDirectConnectGatewayAssociationCommandInput} for command's `input` shape.
- * @see {@link UpdateDirectConnectGatewayAssociationCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateDirectConnectGatewayAssociationCommand extends $Command<UpdateDirectConnectGatewayAssociationCommandInput, UpdateDirectConnectGatewayAssociationCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: UpdateDirectConnectGatewayAssociationCommandInput;
     constructor(input: UpdateDirectConnectGatewayAssociationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateDirectConnectGatewayAssociationCommandInput, UpdateDirectConnectGatewayAssociationCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateDirectConnectGatewayCommand.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 { UpdateDirectConnectGatewayRequest, UpdateDirectConnectGatewayResponse } from "../models/models_0";
+export interface UpdateDirectConnectGatewayCommandInput extends UpdateDirectConnectGatewayRequest {
+}
+export interface UpdateDirectConnectGatewayCommandOutput extends UpdateDirectConnectGatewayResponse, __MetadataBearer {
+}
+
+export declare class UpdateDirectConnectGatewayCommand extends $Command<UpdateDirectConnectGatewayCommandInput, UpdateDirectConnectGatewayCommandOutput, DirectConnectClientResolvedConfig> {
+    readonly input: UpdateDirectConnectGatewayCommandInput;
+    constructor(input: UpdateDirectConnectGatewayCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateDirectConnectGatewayCommandInput, UpdateDirectConnectGatewayCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -6,51 +6,11 @@ export interface UpdateLagCommandInput extends UpdateLagRequest {
 }
 export interface UpdateLagCommandOutput extends Lag, __MetadataBearer {
 }
-/**
- * <p>Updates the attributes of the specified link aggregation group (LAG).</p>
- *          <p>You can update the following LAG attributes:</p>
- *          <ul>
- *             <li>
- *                <p>The name of the LAG.</p>
- *             </li>
- *             <li>
- *                <p>The value for the minimum number of connections that must be operational
- *           for the LAG itself to be operational. </p>
- *             </li>
- *             <li>
- *                <p>The LAG's MACsec encryption mode.</p>
- *                <p>Amazon Web Services assigns this value to each connection which is part of the LAG.</p>
- *             </li>
- *             <li>
- *                <p>The tags</p>
- *             </li>
- *          </ul>
- *          <note>
- *             <p>If you adjust the threshold value for the minimum number of operational connections, ensure
- *       that the new value does not cause the LAG to fall below the threshold and become
- *       non-operational.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, UpdateLagCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, UpdateLagCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new UpdateLagCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateLagCommandInput} for command's `input` shape.
- * @see {@link UpdateLagCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateLagCommand extends $Command<UpdateLagCommandInput, UpdateLagCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: UpdateLagCommandInput;
     constructor(input: UpdateLagCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateLagCommandInput, UpdateLagCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface UpdateVirtualInterfaceAttributesCommandInput extends UpdateVirt
 }
 export interface UpdateVirtualInterfaceAttributesCommandOutput extends VirtualInterface, __MetadataBearer {
 }
-/**
- * <p>Updates the specified attributes of the specified virtual private interface.</p>
- *          <p>Setting the MTU of a virtual interface to 9001 (jumbo frames) can cause an update to
- *       the underlying physical connection if it wasn't updated to support jumbo frames. Updating
- *       the connection disrupts network connectivity for all virtual interfaces associated with
- *       the connection for up to 30 seconds. To check whether your connection supports jumbo
- *       frames, call <a>DescribeConnections</a>. To check whether your virtual q
- *       interface supports jumbo frames, call <a>DescribeVirtualInterfaces</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, UpdateVirtualInterfaceAttributesCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, UpdateVirtualInterfaceAttributesCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new UpdateVirtualInterfaceAttributesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateVirtualInterfaceAttributesCommandInput} for command's `input` shape.
- * @see {@link UpdateVirtualInterfaceAttributesCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateVirtualInterfaceAttributesCommand extends $Command<UpdateVirtualInterfaceAttributesCommandInput, UpdateVirtualInterfaceAttributesCommandOutput, DirectConnectClientResolvedConfig> {
     readonly input: UpdateVirtualInterfaceAttributesCommandInput;
     constructor(input: UpdateVirtualInterfaceAttributesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateVirtualInterfaceAttributesCommandInput, UpdateVirtualInterfaceAttributesCommandOutput>;
     private serialize;
     private deserialize;