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

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

@@ -0,0 +1,41 @@
+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 { DescribeInterconnectLoaRequest, DescribeInterconnectLoaResponse } from "../models/models_0";
+export interface DescribeInterconnectLoaCommandInput extends DescribeInterconnectLoaRequest {
+}
+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

@@ -0,0 +1,35 @@
+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 { DescribeInterconnectsRequest, Interconnects } from "../models/models_0";
+export interface DescribeInterconnectsCommandInput extends DescribeInterconnectsRequest {
+}
+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

@@ -0,0 +1,35 @@
+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 { DescribeLagsRequest, Lags } from "../models/models_0";
+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

@@ -0,0 +1,38 @@
+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 { DescribeLoaRequest, Loa } from "../models/models_0";
+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;
+}

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

@@ -0,0 +1,36 @@
+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 { Locations } from "../models/models_0";
+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/DescribeTagsCommand.d.ts

@@ -0,0 +1,35 @@
+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 { DescribeTagsRequest, DescribeTagsResponse } from "../models/models_0";
+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

@@ -0,0 +1,36 @@
+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 { VirtualGateways } from "../models/models_0";
+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

@@ -0,0 +1,39 @@
+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 { DescribeVirtualInterfacesRequest, VirtualInterfaces } from "../models/models_0";
+export interface DescribeVirtualInterfacesCommandInput extends DescribeVirtualInterfacesRequest {
+}
+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

@@ -0,0 +1,44 @@
+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 { Connection, DisassociateConnectionFromLagRequest } from "../models/models_0";
+export interface DisassociateConnectionFromLagCommandInput extends DisassociateConnectionFromLagRequest {
+}
+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

@@ -0,0 +1,35 @@
+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 { DisassociateMacSecKeyRequest, DisassociateMacSecKeyResponse } from "../models/models_0";
+export interface DisassociateMacSecKeyCommandInput extends DisassociateMacSecKeyRequest {
+}
+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

@@ -0,0 +1,35 @@
+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 { ListVirtualInterfaceTestHistoryRequest, ListVirtualInterfaceTestHistoryResponse } from "../models/models_0";
+export interface ListVirtualInterfaceTestHistoryCommandInput extends ListVirtualInterfaceTestHistoryRequest {
+}
+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

@@ -0,0 +1,38 @@
+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 { StartBgpFailoverTestRequest, StartBgpFailoverTestResponse } from "../models/models_0";
+export interface StartBgpFailoverTestCommandInput extends StartBgpFailoverTestRequest {
+}
+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

@@ -0,0 +1,35 @@
+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 { StopBgpFailoverTestRequest, StopBgpFailoverTestResponse } from "../models/models_0";
+export interface StopBgpFailoverTestCommandInput extends StopBgpFailoverTestRequest {
+}
+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

@@ -0,0 +1,36 @@
+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 { TagResourceRequest, TagResourceResponse } from "../models/models_0";
+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

@@ -0,0 +1,35 @@
+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 { UntagResourceRequest, UntagResourceResponse } from "../models/models_0";
+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

@@ -0,0 +1,44 @@
+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 { Connection, UpdateConnectionRequest } from "../models/models_0";
+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;
+}