@aws-sdk/client-direct-connect 3.32.0 → 3.36.0

package/{dist/es → dist-es}/commands/ConfirmConnectionCommand.js

@@ -1,42 +1,15 @@
 import { __extends } from "tslib";
-import { ConfirmConnectionRequest, ConfirmConnectionResponse } from "../models/models_0";
-import { deserializeAws_json1_1ConfirmConnectionCommand, serializeAws_json1_1ConfirmConnectionCommand, } from "../protocols/Aws_json1_1";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-/**
- * <p>Confirms the creation of the specified hosted connection on an interconnect.</p>
- *          <p>Upon creation, the hosted connection is initially in the <code>Ordering</code> state, and
- *       remains in this state until the owner confirms creation of the hosted connection.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, ConfirmConnectionCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, ConfirmConnectionCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new ConfirmConnectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ConfirmConnectionCommandInput} for command's `input` shape.
- * @see {@link ConfirmConnectionCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
-var ConfirmConnectionCommand = /** @class */ (function (_super) {
+import { ConfirmConnectionRequest, ConfirmConnectionResponse } from "../models/models_0";
+import { deserializeAws_json1_1ConfirmConnectionCommand, serializeAws_json1_1ConfirmConnectionCommand, } from "../protocols/Aws_json1_1";
+var ConfirmConnectionCommand = (function (_super) {
     __extends(ConfirmConnectionCommand, _super);
-    // Start section: command_properties
-    // End section: command_properties
     function ConfirmConnectionCommand(input) {
-        var _this = 
-        // Start section: command_constructor
-        _super.call(this) || this;
+        var _this = _super.call(this) || this;
         _this.input = input;
         return _this;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     ConfirmConnectionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         var stack = clientStack.concat(this.middlewareStack);
@@ -64,4 +37,3 @@ var ConfirmConnectionCommand = /** @class */ (function (_super) {
     return ConfirmConnectionCommand;
 }($Command));
 export { ConfirmConnectionCommand };
-//# sourceMappingURL=ConfirmConnectionCommand.js.map

package/{dist/es → dist-es}/commands/ConfirmPrivateVirtualInterfaceCommand.js

@@ -1,43 +1,15 @@
 import { __extends } from "tslib";
-import { ConfirmPrivateVirtualInterfaceRequest, ConfirmPrivateVirtualInterfaceResponse } from "../models/models_0";
-import { deserializeAws_json1_1ConfirmPrivateVirtualInterfaceCommand, serializeAws_json1_1ConfirmPrivateVirtualInterfaceCommand, } from "../protocols/Aws_json1_1";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-/**
- * <p>Accepts ownership of a private virtual interface created by another account.</p>
- *          <p>After the virtual interface owner makes this call, the virtual interface is
- *       created and attached to the specified virtual private gateway or Direct Connect gateway, and is
- *       made available to handle traffic.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, ConfirmPrivateVirtualInterfaceCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, ConfirmPrivateVirtualInterfaceCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new ConfirmPrivateVirtualInterfaceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ConfirmPrivateVirtualInterfaceCommandInput} for command's `input` shape.
- * @see {@link ConfirmPrivateVirtualInterfaceCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
-var ConfirmPrivateVirtualInterfaceCommand = /** @class */ (function (_super) {
+import { ConfirmPrivateVirtualInterfaceRequest, ConfirmPrivateVirtualInterfaceResponse } from "../models/models_0";
+import { deserializeAws_json1_1ConfirmPrivateVirtualInterfaceCommand, serializeAws_json1_1ConfirmPrivateVirtualInterfaceCommand, } from "../protocols/Aws_json1_1";
+var ConfirmPrivateVirtualInterfaceCommand = (function (_super) {
     __extends(ConfirmPrivateVirtualInterfaceCommand, _super);
-    // Start section: command_properties
-    // End section: command_properties
     function ConfirmPrivateVirtualInterfaceCommand(input) {
-        var _this = 
-        // Start section: command_constructor
-        _super.call(this) || this;
+        var _this = _super.call(this) || this;
         _this.input = input;
         return _this;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     ConfirmPrivateVirtualInterfaceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         var stack = clientStack.concat(this.middlewareStack);
@@ -65,4 +37,3 @@ var ConfirmPrivateVirtualInterfaceCommand = /** @class */ (function (_super) {
     return ConfirmPrivateVirtualInterfaceCommand;
 }($Command));
 export { ConfirmPrivateVirtualInterfaceCommand };
-//# sourceMappingURL=ConfirmPrivateVirtualInterfaceCommand.js.map

package/{dist/es → dist-es}/commands/ConfirmPublicVirtualInterfaceCommand.js

@@ -1,42 +1,15 @@
 import { __extends } from "tslib";
-import { ConfirmPublicVirtualInterfaceRequest, ConfirmPublicVirtualInterfaceResponse } from "../models/models_0";
-import { deserializeAws_json1_1ConfirmPublicVirtualInterfaceCommand, serializeAws_json1_1ConfirmPublicVirtualInterfaceCommand, } from "../protocols/Aws_json1_1";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-/**
- * <p>Accepts ownership of a public virtual interface created by another account.</p>
- *          <p>After the virtual interface owner makes this call, the specified virtual interface is
- *       created and made available to handle traffic.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, ConfirmPublicVirtualInterfaceCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, ConfirmPublicVirtualInterfaceCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new ConfirmPublicVirtualInterfaceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ConfirmPublicVirtualInterfaceCommandInput} for command's `input` shape.
- * @see {@link ConfirmPublicVirtualInterfaceCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
-var ConfirmPublicVirtualInterfaceCommand = /** @class */ (function (_super) {
+import { ConfirmPublicVirtualInterfaceRequest, ConfirmPublicVirtualInterfaceResponse } from "../models/models_0";
+import { deserializeAws_json1_1ConfirmPublicVirtualInterfaceCommand, serializeAws_json1_1ConfirmPublicVirtualInterfaceCommand, } from "../protocols/Aws_json1_1";
+var ConfirmPublicVirtualInterfaceCommand = (function (_super) {
     __extends(ConfirmPublicVirtualInterfaceCommand, _super);
-    // Start section: command_properties
-    // End section: command_properties
     function ConfirmPublicVirtualInterfaceCommand(input) {
-        var _this = 
-        // Start section: command_constructor
-        _super.call(this) || this;
+        var _this = _super.call(this) || this;
         _this.input = input;
         return _this;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     ConfirmPublicVirtualInterfaceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         var stack = clientStack.concat(this.middlewareStack);
@@ -64,4 +37,3 @@ var ConfirmPublicVirtualInterfaceCommand = /** @class */ (function (_super) {
     return ConfirmPublicVirtualInterfaceCommand;
 }($Command));
 export { ConfirmPublicVirtualInterfaceCommand };
-//# sourceMappingURL=ConfirmPublicVirtualInterfaceCommand.js.map

package/{dist/es → dist-es}/commands/ConfirmTransitVirtualInterfaceCommand.js

@@ -1,42 +1,15 @@
 import { __extends } from "tslib";
-import { ConfirmTransitVirtualInterfaceRequest, ConfirmTransitVirtualInterfaceResponse } from "../models/models_0";
-import { deserializeAws_json1_1ConfirmTransitVirtualInterfaceCommand, serializeAws_json1_1ConfirmTransitVirtualInterfaceCommand, } from "../protocols/Aws_json1_1";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-/**
- * <p>Accepts ownership of a transit virtual interface created by another account.</p>
- *
- *          <p> After the owner of the transit virtual interface makes this call, the specified transit virtual interface is created and made available to handle traffic.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, ConfirmTransitVirtualInterfaceCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, ConfirmTransitVirtualInterfaceCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new ConfirmTransitVirtualInterfaceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ConfirmTransitVirtualInterfaceCommandInput} for command's `input` shape.
- * @see {@link ConfirmTransitVirtualInterfaceCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
-var ConfirmTransitVirtualInterfaceCommand = /** @class */ (function (_super) {
+import { ConfirmTransitVirtualInterfaceRequest, ConfirmTransitVirtualInterfaceResponse } from "../models/models_0";
+import { deserializeAws_json1_1ConfirmTransitVirtualInterfaceCommand, serializeAws_json1_1ConfirmTransitVirtualInterfaceCommand, } from "../protocols/Aws_json1_1";
+var ConfirmTransitVirtualInterfaceCommand = (function (_super) {
     __extends(ConfirmTransitVirtualInterfaceCommand, _super);
-    // Start section: command_properties
-    // End section: command_properties
     function ConfirmTransitVirtualInterfaceCommand(input) {
-        var _this = 
-        // Start section: command_constructor
-        _super.call(this) || this;
+        var _this = _super.call(this) || this;
         _this.input = input;
         return _this;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     ConfirmTransitVirtualInterfaceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         var stack = clientStack.concat(this.middlewareStack);
@@ -64,4 +37,3 @@ var ConfirmTransitVirtualInterfaceCommand = /** @class */ (function (_super) {
     return ConfirmTransitVirtualInterfaceCommand;
 }($Command));
 export { ConfirmTransitVirtualInterfaceCommand };
-//# sourceMappingURL=ConfirmTransitVirtualInterfaceCommand.js.map

package/dist-es/commands/CreateBGPPeerCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateBGPPeerRequest, CreateBGPPeerResponse } from "../models/models_0";
+import { deserializeAws_json1_1CreateBGPPeerCommand, serializeAws_json1_1CreateBGPPeerCommand, } from "../protocols/Aws_json1_1";
+var CreateBGPPeerCommand = (function (_super) {
+    __extends(CreateBGPPeerCommand, _super);
+    function CreateBGPPeerCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateBGPPeerCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DirectConnectClient";
+        var commandName = "CreateBGPPeerCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateBGPPeerRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateBGPPeerResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateBGPPeerCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateBGPPeerCommand(input, context);
+    };
+    CreateBGPPeerCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateBGPPeerCommand(output, context);
+    };
+    return CreateBGPPeerCommand;
+}($Command));
+export { CreateBGPPeerCommand };

package/dist-es/commands/CreateConnectionCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Connection, CreateConnectionRequest } from "../models/models_0";
+import { deserializeAws_json1_1CreateConnectionCommand, serializeAws_json1_1CreateConnectionCommand, } from "../protocols/Aws_json1_1";
+var CreateConnectionCommand = (function (_super) {
+    __extends(CreateConnectionCommand, _super);
+    function CreateConnectionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateConnectionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DirectConnectClient";
+        var commandName = "CreateConnectionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateConnectionRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: Connection.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateConnectionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateConnectionCommand(input, context);
+    };
+    CreateConnectionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateConnectionCommand(output, context);
+    };
+    return CreateConnectionCommand;
+}($Command));
+export { CreateConnectionCommand };

package/{dist/es → dist-es}/commands/CreateDirectConnectGatewayAssociationCommand.js

@@ -1,41 +1,15 @@
 import { __extends } from "tslib";
-import { CreateDirectConnectGatewayAssociationRequest, CreateDirectConnectGatewayAssociationResult, } from "../models/models_0";
-import { deserializeAws_json1_1CreateDirectConnectGatewayAssociationCommand, serializeAws_json1_1CreateDirectConnectGatewayAssociationCommand, } from "../protocols/Aws_json1_1";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-/**
- * <p>Creates an association between a Direct Connect gateway and a virtual private gateway. The virtual
- *       private gateway must be attached to a VPC and must not be associated with another Direct Connect gateway.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, CreateDirectConnectGatewayAssociationCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, CreateDirectConnectGatewayAssociationCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new CreateDirectConnectGatewayAssociationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateDirectConnectGatewayAssociationCommandInput} for command's `input` shape.
- * @see {@link CreateDirectConnectGatewayAssociationCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
-var CreateDirectConnectGatewayAssociationCommand = /** @class */ (function (_super) {
+import { CreateDirectConnectGatewayAssociationRequest, CreateDirectConnectGatewayAssociationResult, } from "../models/models_0";
+import { deserializeAws_json1_1CreateDirectConnectGatewayAssociationCommand, serializeAws_json1_1CreateDirectConnectGatewayAssociationCommand, } from "../protocols/Aws_json1_1";
+var CreateDirectConnectGatewayAssociationCommand = (function (_super) {
     __extends(CreateDirectConnectGatewayAssociationCommand, _super);
-    // Start section: command_properties
-    // End section: command_properties
     function CreateDirectConnectGatewayAssociationCommand(input) {
-        var _this = 
-        // Start section: command_constructor
-        _super.call(this) || this;
+        var _this = _super.call(this) || this;
         _this.input = input;
         return _this;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     CreateDirectConnectGatewayAssociationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         var stack = clientStack.concat(this.middlewareStack);
@@ -63,4 +37,3 @@ var CreateDirectConnectGatewayAssociationCommand = /** @class */ (function (_sup
     return CreateDirectConnectGatewayAssociationCommand;
 }($Command));
 export { CreateDirectConnectGatewayAssociationCommand };
-//# sourceMappingURL=CreateDirectConnectGatewayAssociationCommand.js.map

package/{dist/es → dist-es}/commands/CreateDirectConnectGatewayAssociationProposalCommand.js

@@ -1,41 +1,15 @@
 import { __extends } from "tslib";
-import { CreateDirectConnectGatewayAssociationProposalRequest, CreateDirectConnectGatewayAssociationProposalResult, } from "../models/models_0";
-import { deserializeAws_json1_1CreateDirectConnectGatewayAssociationProposalCommand, serializeAws_json1_1CreateDirectConnectGatewayAssociationProposalCommand, } from "../protocols/Aws_json1_1";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-/**
- * <p>Creates a proposal to associate the specified virtual private gateway or transit gateway with the specified Direct Connect gateway.</p>
- *          <p>You can associate a Direct Connect gateway and virtual private gateway or transit gateway that is owned by any account. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, CreateDirectConnectGatewayAssociationProposalCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, CreateDirectConnectGatewayAssociationProposalCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new CreateDirectConnectGatewayAssociationProposalCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateDirectConnectGatewayAssociationProposalCommandInput} for command's `input` shape.
- * @see {@link CreateDirectConnectGatewayAssociationProposalCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
-var CreateDirectConnectGatewayAssociationProposalCommand = /** @class */ (function (_super) {
+import { CreateDirectConnectGatewayAssociationProposalRequest, CreateDirectConnectGatewayAssociationProposalResult, } from "../models/models_0";
+import { deserializeAws_json1_1CreateDirectConnectGatewayAssociationProposalCommand, serializeAws_json1_1CreateDirectConnectGatewayAssociationProposalCommand, } from "../protocols/Aws_json1_1";
+var CreateDirectConnectGatewayAssociationProposalCommand = (function (_super) {
     __extends(CreateDirectConnectGatewayAssociationProposalCommand, _super);
-    // Start section: command_properties
-    // End section: command_properties
     function CreateDirectConnectGatewayAssociationProposalCommand(input) {
-        var _this = 
-        // Start section: command_constructor
-        _super.call(this) || this;
+        var _this = _super.call(this) || this;
         _this.input = input;
         return _this;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     CreateDirectConnectGatewayAssociationProposalCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         var stack = clientStack.concat(this.middlewareStack);
@@ -63,4 +37,3 @@ var CreateDirectConnectGatewayAssociationProposalCommand = /** @class */ (functi
     return CreateDirectConnectGatewayAssociationProposalCommand;
 }($Command));
 export { CreateDirectConnectGatewayAssociationProposalCommand };
-//# sourceMappingURL=CreateDirectConnectGatewayAssociationProposalCommand.js.map

package/{dist/es → dist-es}/commands/CreateDirectConnectGatewayCommand.js

@@ -1,45 +1,15 @@
 import { __extends } from "tslib";
-import { CreateDirectConnectGatewayRequest, CreateDirectConnectGatewayResult } from "../models/models_0";
-import { deserializeAws_json1_1CreateDirectConnectGatewayCommand, serializeAws_json1_1CreateDirectConnectGatewayCommand, } from "../protocols/Aws_json1_1";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-/**
- * <p>Creates a Direct Connect gateway, which is an intermediate object that enables you to connect a set
- *       of virtual interfaces and virtual private gateways. A Direct Connect gateway is global and visible in any
- *       Region after it is created. The virtual interfaces and virtual private gateways that
- *       are connected through a Direct Connect gateway can be in different Regions. This enables you to
- *       connect to a VPC in any Region, regardless of the Region in which the virtual interfaces
- *       are located, and pass traffic between them.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, CreateDirectConnectGatewayCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, CreateDirectConnectGatewayCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new CreateDirectConnectGatewayCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateDirectConnectGatewayCommandInput} for command's `input` shape.
- * @see {@link CreateDirectConnectGatewayCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
-var CreateDirectConnectGatewayCommand = /** @class */ (function (_super) {
+import { CreateDirectConnectGatewayRequest, CreateDirectConnectGatewayResult } from "../models/models_0";
+import { deserializeAws_json1_1CreateDirectConnectGatewayCommand, serializeAws_json1_1CreateDirectConnectGatewayCommand, } from "../protocols/Aws_json1_1";
+var CreateDirectConnectGatewayCommand = (function (_super) {
     __extends(CreateDirectConnectGatewayCommand, _super);
-    // Start section: command_properties
-    // End section: command_properties
     function CreateDirectConnectGatewayCommand(input) {
-        var _this = 
-        // Start section: command_constructor
-        _super.call(this) || this;
+        var _this = _super.call(this) || this;
         _this.input = input;
         return _this;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     CreateDirectConnectGatewayCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         var stack = clientStack.concat(this.middlewareStack);
@@ -67,4 +37,3 @@ var CreateDirectConnectGatewayCommand = /** @class */ (function (_super) {
     return CreateDirectConnectGatewayCommand;
 }($Command));
 export { CreateDirectConnectGatewayCommand };
-//# sourceMappingURL=CreateDirectConnectGatewayCommand.js.map

package/dist-es/commands/CreateInterconnectCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateInterconnectRequest, Interconnect } from "../models/models_0";
+import { deserializeAws_json1_1CreateInterconnectCommand, serializeAws_json1_1CreateInterconnectCommand, } from "../protocols/Aws_json1_1";
+var CreateInterconnectCommand = (function (_super) {
+    __extends(CreateInterconnectCommand, _super);
+    function CreateInterconnectCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateInterconnectCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DirectConnectClient";
+        var commandName = "CreateInterconnectCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateInterconnectRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: Interconnect.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateInterconnectCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateInterconnectCommand(input, context);
+    };
+    CreateInterconnectCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateInterconnectCommand(output, context);
+    };
+    return CreateInterconnectCommand;
+}($Command));
+export { CreateInterconnectCommand };

package/dist-es/commands/CreateLagCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateLagRequest, Lag } from "../models/models_0";
+import { deserializeAws_json1_1CreateLagCommand, serializeAws_json1_1CreateLagCommand } from "../protocols/Aws_json1_1";
+var CreateLagCommand = (function (_super) {
+    __extends(CreateLagCommand, _super);
+    function CreateLagCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateLagCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DirectConnectClient";
+        var commandName = "CreateLagCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateLagRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: Lag.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateLagCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateLagCommand(input, context);
+    };
+    CreateLagCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateLagCommand(output, context);
+    };
+    return CreateLagCommand;
+}($Command));
+export { CreateLagCommand };

package/dist-es/commands/CreatePrivateVirtualInterfaceCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreatePrivateVirtualInterfaceRequest, VirtualInterface } from "../models/models_0";
+import { deserializeAws_json1_1CreatePrivateVirtualInterfaceCommand, serializeAws_json1_1CreatePrivateVirtualInterfaceCommand, } from "../protocols/Aws_json1_1";
+var CreatePrivateVirtualInterfaceCommand = (function (_super) {
+    __extends(CreatePrivateVirtualInterfaceCommand, _super);
+    function CreatePrivateVirtualInterfaceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreatePrivateVirtualInterfaceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DirectConnectClient";
+        var commandName = "CreatePrivateVirtualInterfaceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreatePrivateVirtualInterfaceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: VirtualInterface.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreatePrivateVirtualInterfaceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreatePrivateVirtualInterfaceCommand(input, context);
+    };
+    CreatePrivateVirtualInterfaceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreatePrivateVirtualInterfaceCommand(output, context);
+    };
+    return CreatePrivateVirtualInterfaceCommand;
+}($Command));
+export { CreatePrivateVirtualInterfaceCommand };

package/{dist/es → dist-es}/commands/CreatePublicVirtualInterfaceCommand.js

@@ -1,43 +1,15 @@
 import { __extends } from "tslib";
-import { CreatePublicVirtualInterfaceRequest, VirtualInterface } from "../models/models_0";
-import { deserializeAws_json1_1CreatePublicVirtualInterfaceCommand, serializeAws_json1_1CreatePublicVirtualInterfaceCommand, } from "../protocols/Aws_json1_1";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-/**
- * <p>Creates a public virtual interface. A virtual interface is the VLAN that transports Direct Connect traffic.
- *       A public virtual interface supports sending traffic to public services of Amazon Web Services such as Amazon S3.</p>
- *          <p>When creating an IPv6 public virtual interface (<code>addressFamily</code> is <code>ipv6</code>), leave the <code>customer</code>
- *       and <code>amazon</code> address fields blank to use auto-assigned IPv6 space. Custom IPv6 addresses are not supported.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DirectConnectClient, CreatePublicVirtualInterfaceCommand } from "@aws-sdk/client-direct-connect"; // ES Modules import
- * // const { DirectConnectClient, CreatePublicVirtualInterfaceCommand } = require("@aws-sdk/client-direct-connect"); // CommonJS import
- * const client = new DirectConnectClient(config);
- * const command = new CreatePublicVirtualInterfaceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreatePublicVirtualInterfaceCommandInput} for command's `input` shape.
- * @see {@link CreatePublicVirtualInterfaceCommandOutput} for command's `response` shape.
- * @see {@link DirectConnectClientResolvedConfig | config} for command's `input` shape.
- *
- */
-var CreatePublicVirtualInterfaceCommand = /** @class */ (function (_super) {
+import { CreatePublicVirtualInterfaceRequest, VirtualInterface } from "../models/models_0";
+import { deserializeAws_json1_1CreatePublicVirtualInterfaceCommand, serializeAws_json1_1CreatePublicVirtualInterfaceCommand, } from "../protocols/Aws_json1_1";
+var CreatePublicVirtualInterfaceCommand = (function (_super) {
     __extends(CreatePublicVirtualInterfaceCommand, _super);
-    // Start section: command_properties
-    // End section: command_properties
     function CreatePublicVirtualInterfaceCommand(input) {
-        var _this = 
-        // Start section: command_constructor
-        _super.call(this) || this;
+        var _this = _super.call(this) || this;
         _this.input = input;
         return _this;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     CreatePublicVirtualInterfaceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         var stack = clientStack.concat(this.middlewareStack);
@@ -65,4 +37,3 @@ var CreatePublicVirtualInterfaceCommand = /** @class */ (function (_super) {
     return CreatePublicVirtualInterfaceCommand;
 }($Command));
 export { CreatePublicVirtualInterfaceCommand };
-//# sourceMappingURL=CreatePublicVirtualInterfaceCommand.js.map