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

package/dist-types/DirectConnectClient.d.ts

@@ -0,0 +1,196 @@
+import { EndpointsInputConfig, EndpointsResolvedConfig, RegionInputConfig, RegionResolvedConfig } from "@aws-sdk/config-resolver";
+import { HostHeaderInputConfig, HostHeaderResolvedConfig } from "@aws-sdk/middleware-host-header";
+import { RetryInputConfig, RetryResolvedConfig } from "@aws-sdk/middleware-retry";
+import { AwsAuthInputConfig, AwsAuthResolvedConfig } from "@aws-sdk/middleware-signing";
+import { UserAgentInputConfig, UserAgentResolvedConfig } from "@aws-sdk/middleware-user-agent";
+import { HttpHandler as __HttpHandler } from "@aws-sdk/protocol-http";
+import { Client as __Client, SmithyConfiguration as __SmithyConfiguration, SmithyResolvedConfiguration as __SmithyResolvedConfiguration } from "@aws-sdk/smithy-client";
+import { Credentials as __Credentials, Decoder as __Decoder, Encoder as __Encoder, HashConstructor as __HashConstructor, HttpHandlerOptions as __HttpHandlerOptions, Logger as __Logger, Provider as __Provider, Provider, RegionInfoProvider, StreamCollector as __StreamCollector, UrlParser as __UrlParser, UserAgent as __UserAgent } from "@aws-sdk/types";
+import { AcceptDirectConnectGatewayAssociationProposalCommandInput, AcceptDirectConnectGatewayAssociationProposalCommandOutput } from "./commands/AcceptDirectConnectGatewayAssociationProposalCommand";
+import { AllocateConnectionOnInterconnectCommandInput, AllocateConnectionOnInterconnectCommandOutput } from "./commands/AllocateConnectionOnInterconnectCommand";
+import { AllocateHostedConnectionCommandInput, AllocateHostedConnectionCommandOutput } from "./commands/AllocateHostedConnectionCommand";
+import { AllocatePrivateVirtualInterfaceCommandInput, AllocatePrivateVirtualInterfaceCommandOutput } from "./commands/AllocatePrivateVirtualInterfaceCommand";
+import { AllocatePublicVirtualInterfaceCommandInput, AllocatePublicVirtualInterfaceCommandOutput } from "./commands/AllocatePublicVirtualInterfaceCommand";
+import { AllocateTransitVirtualInterfaceCommandInput, AllocateTransitVirtualInterfaceCommandOutput } from "./commands/AllocateTransitVirtualInterfaceCommand";
+import { AssociateConnectionWithLagCommandInput, AssociateConnectionWithLagCommandOutput } from "./commands/AssociateConnectionWithLagCommand";
+import { AssociateHostedConnectionCommandInput, AssociateHostedConnectionCommandOutput } from "./commands/AssociateHostedConnectionCommand";
+import { AssociateMacSecKeyCommandInput, AssociateMacSecKeyCommandOutput } from "./commands/AssociateMacSecKeyCommand";
+import { AssociateVirtualInterfaceCommandInput, AssociateVirtualInterfaceCommandOutput } from "./commands/AssociateVirtualInterfaceCommand";
+import { ConfirmConnectionCommandInput, ConfirmConnectionCommandOutput } from "./commands/ConfirmConnectionCommand";
+import { ConfirmPrivateVirtualInterfaceCommandInput, ConfirmPrivateVirtualInterfaceCommandOutput } from "./commands/ConfirmPrivateVirtualInterfaceCommand";
+import { ConfirmPublicVirtualInterfaceCommandInput, ConfirmPublicVirtualInterfaceCommandOutput } from "./commands/ConfirmPublicVirtualInterfaceCommand";
+import { ConfirmTransitVirtualInterfaceCommandInput, ConfirmTransitVirtualInterfaceCommandOutput } from "./commands/ConfirmTransitVirtualInterfaceCommand";
+import { CreateBGPPeerCommandInput, CreateBGPPeerCommandOutput } from "./commands/CreateBGPPeerCommand";
+import { CreateConnectionCommandInput, CreateConnectionCommandOutput } from "./commands/CreateConnectionCommand";
+import { CreateDirectConnectGatewayAssociationCommandInput, CreateDirectConnectGatewayAssociationCommandOutput } from "./commands/CreateDirectConnectGatewayAssociationCommand";
+import { CreateDirectConnectGatewayAssociationProposalCommandInput, CreateDirectConnectGatewayAssociationProposalCommandOutput } from "./commands/CreateDirectConnectGatewayAssociationProposalCommand";
+import { CreateDirectConnectGatewayCommandInput, CreateDirectConnectGatewayCommandOutput } from "./commands/CreateDirectConnectGatewayCommand";
+import { CreateInterconnectCommandInput, CreateInterconnectCommandOutput } from "./commands/CreateInterconnectCommand";
+import { CreateLagCommandInput, CreateLagCommandOutput } from "./commands/CreateLagCommand";
+import { CreatePrivateVirtualInterfaceCommandInput, CreatePrivateVirtualInterfaceCommandOutput } from "./commands/CreatePrivateVirtualInterfaceCommand";
+import { CreatePublicVirtualInterfaceCommandInput, CreatePublicVirtualInterfaceCommandOutput } from "./commands/CreatePublicVirtualInterfaceCommand";
+import { CreateTransitVirtualInterfaceCommandInput, CreateTransitVirtualInterfaceCommandOutput } from "./commands/CreateTransitVirtualInterfaceCommand";
+import { DeleteBGPPeerCommandInput, DeleteBGPPeerCommandOutput } from "./commands/DeleteBGPPeerCommand";
+import { DeleteConnectionCommandInput, DeleteConnectionCommandOutput } from "./commands/DeleteConnectionCommand";
+import { DeleteDirectConnectGatewayAssociationCommandInput, DeleteDirectConnectGatewayAssociationCommandOutput } from "./commands/DeleteDirectConnectGatewayAssociationCommand";
+import { DeleteDirectConnectGatewayAssociationProposalCommandInput, DeleteDirectConnectGatewayAssociationProposalCommandOutput } from "./commands/DeleteDirectConnectGatewayAssociationProposalCommand";
+import { DeleteDirectConnectGatewayCommandInput, DeleteDirectConnectGatewayCommandOutput } from "./commands/DeleteDirectConnectGatewayCommand";
+import { DeleteInterconnectCommandInput, DeleteInterconnectCommandOutput } from "./commands/DeleteInterconnectCommand";
+import { DeleteLagCommandInput, DeleteLagCommandOutput } from "./commands/DeleteLagCommand";
+import { DeleteVirtualInterfaceCommandInput, DeleteVirtualInterfaceCommandOutput } from "./commands/DeleteVirtualInterfaceCommand";
+import { DescribeConnectionLoaCommandInput, DescribeConnectionLoaCommandOutput } from "./commands/DescribeConnectionLoaCommand";
+import { DescribeConnectionsCommandInput, DescribeConnectionsCommandOutput } from "./commands/DescribeConnectionsCommand";
+import { DescribeConnectionsOnInterconnectCommandInput, DescribeConnectionsOnInterconnectCommandOutput } from "./commands/DescribeConnectionsOnInterconnectCommand";
+import { DescribeDirectConnectGatewayAssociationProposalsCommandInput, DescribeDirectConnectGatewayAssociationProposalsCommandOutput } from "./commands/DescribeDirectConnectGatewayAssociationProposalsCommand";
+import { DescribeDirectConnectGatewayAssociationsCommandInput, DescribeDirectConnectGatewayAssociationsCommandOutput } from "./commands/DescribeDirectConnectGatewayAssociationsCommand";
+import { DescribeDirectConnectGatewayAttachmentsCommandInput, DescribeDirectConnectGatewayAttachmentsCommandOutput } from "./commands/DescribeDirectConnectGatewayAttachmentsCommand";
+import { DescribeDirectConnectGatewaysCommandInput, DescribeDirectConnectGatewaysCommandOutput } from "./commands/DescribeDirectConnectGatewaysCommand";
+import { DescribeHostedConnectionsCommandInput, DescribeHostedConnectionsCommandOutput } from "./commands/DescribeHostedConnectionsCommand";
+import { DescribeInterconnectLoaCommandInput, DescribeInterconnectLoaCommandOutput } from "./commands/DescribeInterconnectLoaCommand";
+import { DescribeInterconnectsCommandInput, DescribeInterconnectsCommandOutput } from "./commands/DescribeInterconnectsCommand";
+import { DescribeLagsCommandInput, DescribeLagsCommandOutput } from "./commands/DescribeLagsCommand";
+import { DescribeLoaCommandInput, DescribeLoaCommandOutput } from "./commands/DescribeLoaCommand";
+import { DescribeLocationsCommandInput, DescribeLocationsCommandOutput } from "./commands/DescribeLocationsCommand";
+import { DescribeTagsCommandInput, DescribeTagsCommandOutput } from "./commands/DescribeTagsCommand";
+import { DescribeVirtualGatewaysCommandInput, DescribeVirtualGatewaysCommandOutput } from "./commands/DescribeVirtualGatewaysCommand";
+import { DescribeVirtualInterfacesCommandInput, DescribeVirtualInterfacesCommandOutput } from "./commands/DescribeVirtualInterfacesCommand";
+import { DisassociateConnectionFromLagCommandInput, DisassociateConnectionFromLagCommandOutput } from "./commands/DisassociateConnectionFromLagCommand";
+import { DisassociateMacSecKeyCommandInput, DisassociateMacSecKeyCommandOutput } from "./commands/DisassociateMacSecKeyCommand";
+import { ListVirtualInterfaceTestHistoryCommandInput, ListVirtualInterfaceTestHistoryCommandOutput } from "./commands/ListVirtualInterfaceTestHistoryCommand";
+import { StartBgpFailoverTestCommandInput, StartBgpFailoverTestCommandOutput } from "./commands/StartBgpFailoverTestCommand";
+import { StopBgpFailoverTestCommandInput, StopBgpFailoverTestCommandOutput } from "./commands/StopBgpFailoverTestCommand";
+import { TagResourceCommandInput, TagResourceCommandOutput } from "./commands/TagResourceCommand";
+import { UntagResourceCommandInput, UntagResourceCommandOutput } from "./commands/UntagResourceCommand";
+import { UpdateConnectionCommandInput, UpdateConnectionCommandOutput } from "./commands/UpdateConnectionCommand";
+import { UpdateDirectConnectGatewayAssociationCommandInput, UpdateDirectConnectGatewayAssociationCommandOutput } from "./commands/UpdateDirectConnectGatewayAssociationCommand";
+import { UpdateLagCommandInput, UpdateLagCommandOutput } from "./commands/UpdateLagCommand";
+import { UpdateVirtualInterfaceAttributesCommandInput, UpdateVirtualInterfaceAttributesCommandOutput } from "./commands/UpdateVirtualInterfaceAttributesCommand";
+export declare type ServiceInputTypes = AcceptDirectConnectGatewayAssociationProposalCommandInput | AllocateConnectionOnInterconnectCommandInput | AllocateHostedConnectionCommandInput | AllocatePrivateVirtualInterfaceCommandInput | AllocatePublicVirtualInterfaceCommandInput | AllocateTransitVirtualInterfaceCommandInput | AssociateConnectionWithLagCommandInput | AssociateHostedConnectionCommandInput | AssociateMacSecKeyCommandInput | AssociateVirtualInterfaceCommandInput | ConfirmConnectionCommandInput | ConfirmPrivateVirtualInterfaceCommandInput | ConfirmPublicVirtualInterfaceCommandInput | ConfirmTransitVirtualInterfaceCommandInput | CreateBGPPeerCommandInput | CreateConnectionCommandInput | CreateDirectConnectGatewayAssociationCommandInput | CreateDirectConnectGatewayAssociationProposalCommandInput | CreateDirectConnectGatewayCommandInput | CreateInterconnectCommandInput | CreateLagCommandInput | CreatePrivateVirtualInterfaceCommandInput | CreatePublicVirtualInterfaceCommandInput | CreateTransitVirtualInterfaceCommandInput | DeleteBGPPeerCommandInput | DeleteConnectionCommandInput | DeleteDirectConnectGatewayAssociationCommandInput | DeleteDirectConnectGatewayAssociationProposalCommandInput | DeleteDirectConnectGatewayCommandInput | DeleteInterconnectCommandInput | DeleteLagCommandInput | DeleteVirtualInterfaceCommandInput | DescribeConnectionLoaCommandInput | DescribeConnectionsCommandInput | DescribeConnectionsOnInterconnectCommandInput | DescribeDirectConnectGatewayAssociationProposalsCommandInput | DescribeDirectConnectGatewayAssociationsCommandInput | DescribeDirectConnectGatewayAttachmentsCommandInput | DescribeDirectConnectGatewaysCommandInput | DescribeHostedConnectionsCommandInput | DescribeInterconnectLoaCommandInput | DescribeInterconnectsCommandInput | DescribeLagsCommandInput | DescribeLoaCommandInput | DescribeLocationsCommandInput | DescribeTagsCommandInput | DescribeVirtualGatewaysCommandInput | DescribeVirtualInterfacesCommandInput | DisassociateConnectionFromLagCommandInput | DisassociateMacSecKeyCommandInput | ListVirtualInterfaceTestHistoryCommandInput | StartBgpFailoverTestCommandInput | StopBgpFailoverTestCommandInput | TagResourceCommandInput | UntagResourceCommandInput | UpdateConnectionCommandInput | UpdateDirectConnectGatewayAssociationCommandInput | UpdateLagCommandInput | UpdateVirtualInterfaceAttributesCommandInput;
+export declare type ServiceOutputTypes = AcceptDirectConnectGatewayAssociationProposalCommandOutput | AllocateConnectionOnInterconnectCommandOutput | AllocateHostedConnectionCommandOutput | AllocatePrivateVirtualInterfaceCommandOutput | AllocatePublicVirtualInterfaceCommandOutput | AllocateTransitVirtualInterfaceCommandOutput | AssociateConnectionWithLagCommandOutput | AssociateHostedConnectionCommandOutput | AssociateMacSecKeyCommandOutput | AssociateVirtualInterfaceCommandOutput | ConfirmConnectionCommandOutput | ConfirmPrivateVirtualInterfaceCommandOutput | ConfirmPublicVirtualInterfaceCommandOutput | ConfirmTransitVirtualInterfaceCommandOutput | CreateBGPPeerCommandOutput | CreateConnectionCommandOutput | CreateDirectConnectGatewayAssociationCommandOutput | CreateDirectConnectGatewayAssociationProposalCommandOutput | CreateDirectConnectGatewayCommandOutput | CreateInterconnectCommandOutput | CreateLagCommandOutput | CreatePrivateVirtualInterfaceCommandOutput | CreatePublicVirtualInterfaceCommandOutput | CreateTransitVirtualInterfaceCommandOutput | DeleteBGPPeerCommandOutput | DeleteConnectionCommandOutput | DeleteDirectConnectGatewayAssociationCommandOutput | DeleteDirectConnectGatewayAssociationProposalCommandOutput | DeleteDirectConnectGatewayCommandOutput | DeleteInterconnectCommandOutput | DeleteLagCommandOutput | DeleteVirtualInterfaceCommandOutput | DescribeConnectionLoaCommandOutput | DescribeConnectionsCommandOutput | DescribeConnectionsOnInterconnectCommandOutput | DescribeDirectConnectGatewayAssociationProposalsCommandOutput | DescribeDirectConnectGatewayAssociationsCommandOutput | DescribeDirectConnectGatewayAttachmentsCommandOutput | DescribeDirectConnectGatewaysCommandOutput | DescribeHostedConnectionsCommandOutput | DescribeInterconnectLoaCommandOutput | DescribeInterconnectsCommandOutput | DescribeLagsCommandOutput | DescribeLoaCommandOutput | DescribeLocationsCommandOutput | DescribeTagsCommandOutput | DescribeVirtualGatewaysCommandOutput | DescribeVirtualInterfacesCommandOutput | DisassociateConnectionFromLagCommandOutput | DisassociateMacSecKeyCommandOutput | ListVirtualInterfaceTestHistoryCommandOutput | StartBgpFailoverTestCommandOutput | StopBgpFailoverTestCommandOutput | TagResourceCommandOutput | UntagResourceCommandOutput | UpdateConnectionCommandOutput | UpdateDirectConnectGatewayAssociationCommandOutput | UpdateLagCommandOutput | UpdateVirtualInterfaceAttributesCommandOutput;
+export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
+    /**
+     * The HTTP handler to use. Fetch in browser and Https in Nodejs.
+     */
+    requestHandler?: __HttpHandler;
+    /**
+     * A constructor for a class implementing the {@link __Hash} interface
+     * that computes the SHA-256 HMAC or checksum of a string or binary buffer.
+     * @internal
+     */
+    sha256?: __HashConstructor;
+    /**
+     * The function that will be used to convert strings into HTTP endpoints.
+     * @internal
+     */
+    urlParser?: __UrlParser;
+    /**
+     * A function that can calculate the length of a request body.
+     * @internal
+     */
+    bodyLengthChecker?: (body: any) => number | undefined;
+    /**
+     * A function that converts a stream into an array of bytes.
+     * @internal
+     */
+    streamCollector?: __StreamCollector;
+    /**
+     * The function that will be used to convert a base64-encoded string to a byte array.
+     * @internal
+     */
+    base64Decoder?: __Decoder;
+    /**
+     * The function that will be used to convert binary data to a base64-encoded string.
+     * @internal
+     */
+    base64Encoder?: __Encoder;
+    /**
+     * The function that will be used to convert a UTF8-encoded string to a byte array.
+     * @internal
+     */
+    utf8Decoder?: __Decoder;
+    /**
+     * The function that will be used to convert binary data to a UTF-8 encoded string.
+     * @internal
+     */
+    utf8Encoder?: __Encoder;
+    /**
+     * The runtime environment.
+     * @internal
+     */
+    runtime?: string;
+    /**
+     * Disable dyanamically changing the endpoint of the client based on the hostPrefix
+     * trait of an operation.
+     */
+    disableHostPrefix?: boolean;
+    /**
+     * Value for how many times a request will be made at most in case of retry.
+     */
+    maxAttempts?: number | __Provider<number>;
+    /**
+     * Specifies which retry algorithm to use.
+     */
+    retryMode?: string | __Provider<string>;
+    /**
+     * Optional logger for logging debug/info/warn/error.
+     */
+    logger?: __Logger;
+    /**
+     * Unique service identifier.
+     * @internal
+     */
+    serviceId?: string;
+    /**
+     * The AWS region to which this client will send requests
+     */
+    region?: string | __Provider<string>;
+    /**
+     * Default credentials provider; Not available in browser runtime.
+     * @internal
+     */
+    credentialDefaultProvider?: (input: any) => __Provider<__Credentials>;
+    /**
+     * Fetch related hostname, signing name or signing region with given region.
+     * @internal
+     */
+    regionInfoProvider?: RegionInfoProvider;
+    /**
+     * The provider populating default tracking information to be sent with `user-agent`, `x-amz-user-agent` header
+     * @internal
+     */
+    defaultUserAgentProvider?: Provider<__UserAgent>;
+}
+declare type DirectConnectClientConfigType = Partial<__SmithyConfiguration<__HttpHandlerOptions>> & ClientDefaults & RegionInputConfig & EndpointsInputConfig & RetryInputConfig & HostHeaderInputConfig & AwsAuthInputConfig & UserAgentInputConfig;
+/**
+ * The configuration interface of DirectConnectClient class constructor that set the region, credentials and other options.
+ */
+export interface DirectConnectClientConfig extends DirectConnectClientConfigType {
+}
+declare type DirectConnectClientResolvedConfigType = __SmithyResolvedConfiguration<__HttpHandlerOptions> & Required<ClientDefaults> & RegionResolvedConfig & EndpointsResolvedConfig & RetryResolvedConfig & HostHeaderResolvedConfig & AwsAuthResolvedConfig & UserAgentResolvedConfig;
+/**
+ * The resolved configuration interface of DirectConnectClient class. This is resolved and normalized from the {@link DirectConnectClientConfig | constructor configuration interface}.
+ */
+export interface DirectConnectClientResolvedConfig extends DirectConnectClientResolvedConfigType {
+}
+/**
+ * <p>Direct Connect links your internal network to an Direct Connect location over a standard Ethernet fiber-optic cable.
+ *       One end of the cable is connected to your router, the other to an Direct Connect router. With this connection
+ *       in place, you can create virtual interfaces directly to the Cloud (for example, to Amazon EC2
+ *       and Amazon S3) and to Amazon VPC, bypassing Internet service providers in your network path. A
+ *       connection provides access to all Regions except the China (Beijing) and (China) Ningxia Regions.
+ *       Amazon Web Services resources in the China Regions can only be accessed through locations associated with those Regions.</p>
+ */
+export declare class DirectConnectClient extends __Client<__HttpHandlerOptions, ServiceInputTypes, ServiceOutputTypes, DirectConnectClientResolvedConfig> {
+    /**
+     * The resolved configuration of DirectConnectClient class. This is resolved and normalized from the {@link DirectConnectClientConfig | constructor configuration interface}.
+     */
+    readonly config: DirectConnectClientResolvedConfig;
+    constructor(configuration: DirectConnectClientConfig);
+    /**
+     * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+     * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+     * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+     */
+    destroy(): void;
+}
+export {};

package/dist-types/commands/AcceptDirectConnectGatewayAssociationProposalCommand.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 { AcceptDirectConnectGatewayAssociationProposalRequest, AcceptDirectConnectGatewayAssociationProposalResult } from "../models/models_0";
+export interface AcceptDirectConnectGatewayAssociationProposalCommandInput extends AcceptDirectConnectGatewayAssociationProposalRequest {
+}
+export interface AcceptDirectConnectGatewayAssociationProposalCommandOutput extends AcceptDirectConnectGatewayAssociationProposalResult, __MetadataBearer {
+}
+/**
+ * <p>Accepts a proposal request to attach a virtual private gateway or transit gateway to a Direct Connect gateway.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DirectConnectClient, AcceptDirectConnectGatewayAssociationProposalCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
+ * // const { DirectConnectClient, AcceptDirectConnectGatewayAssociationProposalCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
+ * const client = new DirectConnectClient(config);
+ * const command = new AcceptDirectConnectGatewayAssociationProposalCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link AcceptDirectConnectGatewayAssociationProposalCommandInput} for command's `input` shape.
+ * @see {@link AcceptDirectConnectGatewayAssociationProposalCommandOutput} for command's `response` shape.
+ * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class AcceptDirectConnectGatewayAssociationProposalCommand extends $Command<AcceptDirectConnectGatewayAssociationProposalCommandInput, AcceptDirectConnectGatewayAssociationProposalCommandOutput, DirectConnectClientResolvedConfig> {
+    readonly input: AcceptDirectConnectGatewayAssociationProposalCommandInput;
+    constructor(input: AcceptDirectConnectGatewayAssociationProposalCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AcceptDirectConnectGatewayAssociationProposalCommandInput, AcceptDirectConnectGatewayAssociationProposalCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,42 @@
+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 { AllocateConnectionOnInterconnectRequest, Connection } from "../models/models_0";
+export interface AllocateConnectionOnInterconnectCommandInput extends AllocateConnectionOnInterconnectRequest {
+}
+export interface AllocateConnectionOnInterconnectCommandOutput extends Connection, __MetadataBearer {
+}
+/**
+ * @deprecated
+ *
+ * <p>Deprecated. Use <a>AllocateHostedConnection</a> instead.</p>
+ *          <p>Creates a hosted connection on an interconnect.</p>
+ *          <p>Allocates a VLAN number and a specified amount of bandwidth for use by a hosted connection 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, AllocateConnectionOnInterconnectCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
+ * // const { DirectConnectClient, AllocateConnectionOnInterconnectCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
+ * const client = new DirectConnectClient(config);
+ * const command = new AllocateConnectionOnInterconnectCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link AllocateConnectionOnInterconnectCommandInput} for command's `input` shape.
+ * @see {@link AllocateConnectionOnInterconnectCommandOutput} for command's `response` shape.
+ * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class AllocateConnectionOnInterconnectCommand extends $Command<AllocateConnectionOnInterconnectCommandInput, AllocateConnectionOnInterconnectCommandOutput, DirectConnectClientResolvedConfig> {
+    readonly input: AllocateConnectionOnInterconnectCommandInput;
+    constructor(input: AllocateConnectionOnInterconnectCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AllocateConnectionOnInterconnectCommandInput, AllocateConnectionOnInterconnectCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,40 @@
+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 { AllocateHostedConnectionRequest, Connection } from "../models/models_0";
+export interface AllocateHostedConnectionCommandInput extends AllocateHostedConnectionRequest {
+}
+export interface AllocateHostedConnectionCommandOutput extends Connection, __MetadataBearer {
+}
+/**
+ * <p>Creates a hosted connection on the specified interconnect or a link aggregation group (LAG) of interconnects.</p>
+ *          <p>Allocates a VLAN number and a specified amount of capacity (bandwidth) for use by a hosted connection on the specified interconnect or LAG of interconnects.
+ *       Amazon Web Services polices the hosted connection for the specified capacity and the Direct Connect Partner must also police the hosted connection for the specified capacity.</p>
+ *          <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, AllocateHostedConnectionCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
+ * // const { DirectConnectClient, AllocateHostedConnectionCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
+ * const client = new DirectConnectClient(config);
+ * const command = new AllocateHostedConnectionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link AllocateHostedConnectionCommandInput} for command's `input` shape.
+ * @see {@link AllocateHostedConnectionCommandOutput} for command's `response` shape.
+ * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class AllocateHostedConnectionCommand extends $Command<AllocateHostedConnectionCommandInput, AllocateHostedConnectionCommandOutput, DirectConnectClientResolvedConfig> {
+    readonly input: AllocateHostedConnectionCommandInput;
+    constructor(input: AllocateHostedConnectionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AllocateHostedConnectionCommandInput, AllocateHostedConnectionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,37 @@
+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 { AllocatePrivateVirtualInterfaceRequest, VirtualInterface } from "../models/models_0";
+export interface AllocatePrivateVirtualInterfaceCommandInput extends AllocatePrivateVirtualInterfaceRequest {
+}
+export interface AllocatePrivateVirtualInterfaceCommandOutput extends VirtualInterface, __MetadataBearer {
+}
+/**
+ * <p>Provisions a private virtual interface to be owned by the specified account.</p>
+ *          <p>Virtual interfaces created using this action must be confirmed by the owner using <a>ConfirmPrivateVirtualInterface</a>.
+ *       Until then, the virtual interface is in the <code>Confirming</code> state and is not available to handle traffic.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DirectConnectClient, AllocatePrivateVirtualInterfaceCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
+ * // const { DirectConnectClient, AllocatePrivateVirtualInterfaceCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
+ * const client = new DirectConnectClient(config);
+ * const command = new AllocatePrivateVirtualInterfaceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link AllocatePrivateVirtualInterfaceCommandInput} for command's `input` shape.
+ * @see {@link AllocatePrivateVirtualInterfaceCommandOutput} for command's `response` shape.
+ * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class AllocatePrivateVirtualInterfaceCommand extends $Command<AllocatePrivateVirtualInterfaceCommandInput, AllocatePrivateVirtualInterfaceCommandOutput, DirectConnectClientResolvedConfig> {
+    readonly input: AllocatePrivateVirtualInterfaceCommandInput;
+    constructor(input: AllocatePrivateVirtualInterfaceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AllocatePrivateVirtualInterfaceCommandInput, AllocatePrivateVirtualInterfaceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,40 @@
+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 { AllocatePublicVirtualInterfaceRequest, VirtualInterface } from "../models/models_0";
+export interface AllocatePublicVirtualInterfaceCommandInput extends AllocatePublicVirtualInterfaceRequest {
+}
+export interface AllocatePublicVirtualInterfaceCommandOutput extends VirtualInterface, __MetadataBearer {
+}
+/**
+ * <p>Provisions a public virtual interface to be owned by the specified account.</p>
+ *          <p>The owner of a connection calls this function to provision a public virtual interface to be owned by the specified account.</p>
+ *          <p>Virtual interfaces created using this function must be confirmed by the owner using <a>ConfirmPublicVirtualInterface</a>.
+ *       Until this step has been completed, the virtual interface is in the <code>confirming</code> state and is not available to handle traffic.</p>
+ *          <p>When creating an IPv6 public virtual interface, omit the Amazon address and customer address. IPv6 addresses are automatically assigned from
+ *       the Amazon pool of IPv6 addresses; you cannot specify custom IPv6 addresses.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DirectConnectClient, AllocatePublicVirtualInterfaceCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
+ * // const { DirectConnectClient, AllocatePublicVirtualInterfaceCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
+ * const client = new DirectConnectClient(config);
+ * const command = new AllocatePublicVirtualInterfaceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link AllocatePublicVirtualInterfaceCommandInput} for command's `input` shape.
+ * @see {@link AllocatePublicVirtualInterfaceCommandOutput} for command's `response` shape.
+ * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class AllocatePublicVirtualInterfaceCommand extends $Command<AllocatePublicVirtualInterfaceCommandInput, AllocatePublicVirtualInterfaceCommandOutput, DirectConnectClientResolvedConfig> {
+    readonly input: AllocatePublicVirtualInterfaceCommandInput;
+    constructor(input: AllocatePublicVirtualInterfaceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AllocatePublicVirtualInterfaceCommandInput, AllocatePublicVirtualInterfaceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,37 @@
+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 { AllocateTransitVirtualInterfaceRequest, AllocateTransitVirtualInterfaceResult } from "../models/models_0";
+export interface AllocateTransitVirtualInterfaceCommandInput extends AllocateTransitVirtualInterfaceRequest {
+}
+export interface AllocateTransitVirtualInterfaceCommandOutput extends AllocateTransitVirtualInterfaceResult, __MetadataBearer {
+}
+/**
+ * <p>Provisions a transit virtual interface to be owned by the specified account. Use this type of interface to connect a transit gateway to your Direct Connect gateway.</p>
+ *          <p>The owner of a connection provisions a transit virtual interface to be owned by the specified account.</p>
+ *          <p>After you create a transit virtual interface, it must be confirmed by the owner using <a>ConfirmTransitVirtualInterface</a>. Until this step has been completed, the transit virtual interface is in the <code>requested</code> state and is not available to handle traffic.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DirectConnectClient, AllocateTransitVirtualInterfaceCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
+ * // const { DirectConnectClient, AllocateTransitVirtualInterfaceCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
+ * const client = new DirectConnectClient(config);
+ * const command = new AllocateTransitVirtualInterfaceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link AllocateTransitVirtualInterfaceCommandInput} for command's `input` shape.
+ * @see {@link AllocateTransitVirtualInterfaceCommandOutput} for command's `response` shape.
+ * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class AllocateTransitVirtualInterfaceCommand extends $Command<AllocateTransitVirtualInterfaceCommandInput, AllocateTransitVirtualInterfaceCommandOutput, DirectConnectClientResolvedConfig> {
+    readonly input: AllocateTransitVirtualInterfaceCommandInput;
+    constructor(input: AllocateTransitVirtualInterfaceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AllocateTransitVirtualInterfaceCommandInput, AllocateTransitVirtualInterfaceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,48 @@
+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 { AssociateConnectionWithLagRequest, Connection } from "../models/models_0";
+export interface AssociateConnectionWithLagCommandInput extends AssociateConnectionWithLagRequest {
+}
+export interface AssociateConnectionWithLagCommandOutput extends Connection, __MetadataBearer {
+}
+/**
+ * <p>Associates an existing connection with a link aggregation group (LAG). The connection
+ *       is interrupted and re-established as a member of the LAG (connectivity to Amazon Web Services is
+ *       interrupted). The connection must be hosted on the same Direct Connect endpoint as the LAG, and its
+ *       bandwidth must match the bandwidth for the LAG. You can re-associate a connection that's
+ *       currently associated with a different LAG; however, if removing the connection would cause
+ *       the original LAG to fall below its setting for minimum number of operational connections,
+ *       the request fails.</p>
+ *          <p>Any virtual interfaces that are directly associated with the connection are
+ *       automatically re-associated with the LAG. If the connection was originally associated
+ *       with a different LAG, the virtual interfaces remain associated with the original
+ *       LAG.</p>
+ *          <p>For interconnects, any hosted connections are automatically re-associated with the
+ *       LAG. If the interconnect was originally associated with a different LAG, the hosted
+ *       connections remain associated with the original LAG.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DirectConnectClient, AssociateConnectionWithLagCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
+ * // const { DirectConnectClient, AssociateConnectionWithLagCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
+ * const client = new DirectConnectClient(config);
+ * const command = new AssociateConnectionWithLagCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link AssociateConnectionWithLagCommandInput} for command's `input` shape.
+ * @see {@link AssociateConnectionWithLagCommandOutput} for command's `response` shape.
+ * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class AssociateConnectionWithLagCommand extends $Command<AssociateConnectionWithLagCommandInput, AssociateConnectionWithLagCommandOutput, DirectConnectClientResolvedConfig> {
+    readonly input: AssociateConnectionWithLagCommandInput;
+    constructor(input: AssociateConnectionWithLagCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateConnectionWithLagCommandInput, AssociateConnectionWithLagCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,42 @@
+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 { AssociateHostedConnectionRequest, Connection } from "../models/models_0";
+export interface AssociateHostedConnectionCommandInput extends AssociateHostedConnectionRequest {
+}
+export interface AssociateHostedConnectionCommandOutput extends Connection, __MetadataBearer {
+}
+/**
+ * <p>Associates a hosted connection and its virtual interfaces with a link aggregation
+ *       group (LAG) or interconnect. If the target interconnect or LAG has an existing hosted
+ *       connection with a conflicting VLAN number or IP address, the operation fails. This
+ *       action temporarily interrupts the hosted connection's connectivity to Amazon Web Services
+ *       as it is being migrated.</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, AssociateHostedConnectionCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
+ * // const { DirectConnectClient, AssociateHostedConnectionCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
+ * const client = new DirectConnectClient(config);
+ * const command = new AssociateHostedConnectionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link AssociateHostedConnectionCommandInput} for command's `input` shape.
+ * @see {@link AssociateHostedConnectionCommandOutput} for command's `response` shape.
+ * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class AssociateHostedConnectionCommand extends $Command<AssociateHostedConnectionCommandInput, AssociateHostedConnectionCommandOutput, DirectConnectClientResolvedConfig> {
+    readonly input: AssociateHostedConnectionCommandInput;
+    constructor(input: AssociateHostedConnectionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateHostedConnectionCommandInput, AssociateHostedConnectionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,37 @@
+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 { AssociateMacSecKeyRequest, AssociateMacSecKeyResponse } from "../models/models_0";
+export interface AssociateMacSecKeyCommandInput extends AssociateMacSecKeyRequest {
+}
+export interface AssociateMacSecKeyCommandOutput extends AssociateMacSecKeyResponse, __MetadataBearer {
+}
+/**
+ * <p>Associates a MAC Security (MACsec) Connection Key Name (CKN)/ Connectivity Association Key (CAK) pair with an Direct Connect dedicated connection.</p>
+ *          <p>You must supply either the <code>secretARN,</code> or the CKN/CAK (<code>ckn</code> and <code>cak</code>) pair in the request.</p>
+ *          <p>For information about MAC Security (MACsec) key considerations, see  <a href="https://docs.aws.amazon.com/directconnect/latest/UserGuide/direct-connect-mac-sec-getting-started.html#mac-sec-key-consideration">MACsec pre-shared CKN/CAK key considerations </a> in the <i>Direct Connect User Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DirectConnectClient, AssociateMacSecKeyCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
+ * // const { DirectConnectClient, AssociateMacSecKeyCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
+ * const client = new DirectConnectClient(config);
+ * const command = new AssociateMacSecKeyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link AssociateMacSecKeyCommandInput} for command's `input` shape.
+ * @see {@link AssociateMacSecKeyCommandOutput} for command's `response` shape.
+ * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class AssociateMacSecKeyCommand extends $Command<AssociateMacSecKeyCommandInput, AssociateMacSecKeyCommandOutput, DirectConnectClientResolvedConfig> {
+    readonly input: AssociateMacSecKeyCommandInput;
+    constructor(input: AssociateMacSecKeyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateMacSecKeyCommandInput, AssociateMacSecKeyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/AssociateVirtualInterfaceCommand.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 { AssociateVirtualInterfaceRequest, VirtualInterface } from "../models/models_0";
+export interface AssociateVirtualInterfaceCommandInput extends AssociateVirtualInterfaceRequest {
+}
+export interface AssociateVirtualInterfaceCommandOutput extends VirtualInterface, __MetadataBearer {
+}
+/**
+ * <p>Associates a virtual interface with a specified link aggregation group (LAG) or
+ *       connection. Connectivity to Amazon Web Services is temporarily interrupted as the virtual interface is
+ *       being migrated. If the target connection or LAG has an associated virtual interface with
+ *       a conflicting VLAN number or a conflicting IP address, the operation fails.</p>
+ *          <p>Virtual interfaces associated with a hosted connection cannot be associated with a
+ *       LAG; hosted connections must be migrated along with their virtual interfaces using <a>AssociateHostedConnection</a>.</p>
+ *          <p>To reassociate a virtual interface to a new connection or LAG, the requester
+ *       must own either the virtual interface itself or the connection to which the virtual
+ *       interface is currently associated. Additionally, the requester must own the connection
+ *       or LAG for the association.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DirectConnectClient, AssociateVirtualInterfaceCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
+ * // const { DirectConnectClient, AssociateVirtualInterfaceCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
+ * const client = new DirectConnectClient(config);
+ * const command = new AssociateVirtualInterfaceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link AssociateVirtualInterfaceCommandInput} for command's `input` shape.
+ * @see {@link AssociateVirtualInterfaceCommandOutput} for command's `response` shape.
+ * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class AssociateVirtualInterfaceCommand extends $Command<AssociateVirtualInterfaceCommandInput, AssociateVirtualInterfaceCommandOutput, DirectConnectClientResolvedConfig> {
+    readonly input: AssociateVirtualInterfaceCommandInput;
+    constructor(input: AssociateVirtualInterfaceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DirectConnectClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateVirtualInterfaceCommandInput, AssociateVirtualInterfaceCommandOutput>;
+    private serialize;
+    private deserialize;
+}