@aws-sdk/client-direct-connect 3.183.0 → 3.185.0

package/dist-es/commands/AssociateVirtualInterfaceCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { AssociateVirtualInterfaceRequestFilterSensitiveLog, VirtualInterfaceFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1AssociateVirtualInterfaceCommand, serializeAws_json1_1AssociateVirtualInterfaceCommand, } from "../protocols/Aws_json1_1";
-export class AssociateVirtualInterfaceCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var AssociateVirtualInterfaceCommand = (function (_super) {
+    __extends(AssociateVirtualInterfaceCommand, _super);
+    function AssociateVirtualInterfaceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    AssociateVirtualInterfaceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DirectConnectClient";
-        const commandName = "AssociateVirtualInterfaceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DirectConnectClient";
+        var commandName = "AssociateVirtualInterfaceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: AssociateVirtualInterfaceRequestFilterSensitiveLog,
             outputFilterSensitiveLog: VirtualInterfaceFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AssociateVirtualInterfaceCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1AssociateVirtualInterfaceCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    AssociateVirtualInterfaceCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1AssociateVirtualInterfaceCommand(output, context);
-    }
-}
+    };
+    return AssociateVirtualInterfaceCommand;
+}($Command));
+export { AssociateVirtualInterfaceCommand };

package/dist-es/commands/ConfirmConnectionCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ConfirmConnectionRequestFilterSensitiveLog, ConfirmConnectionResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1ConfirmConnectionCommand, serializeAws_json1_1ConfirmConnectionCommand, } from "../protocols/Aws_json1_1";
-export class ConfirmConnectionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ConfirmConnectionCommand = (function (_super) {
+    __extends(ConfirmConnectionCommand, _super);
+    function ConfirmConnectionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ConfirmConnectionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DirectConnectClient";
-        const commandName = "ConfirmConnectionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DirectConnectClient";
+        var commandName = "ConfirmConnectionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ConfirmConnectionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ConfirmConnectionResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ConfirmConnectionCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1ConfirmConnectionCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ConfirmConnectionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1ConfirmConnectionCommand(output, context);
-    }
-}
+    };
+    return ConfirmConnectionCommand;
+}($Command));
+export { ConfirmConnectionCommand };

package/dist-es/commands/ConfirmCustomerAgreementCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ConfirmCustomerAgreementRequestFilterSensitiveLog, ConfirmCustomerAgreementResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1ConfirmCustomerAgreementCommand, serializeAws_json1_1ConfirmCustomerAgreementCommand, } from "../protocols/Aws_json1_1";
-export class ConfirmCustomerAgreementCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ConfirmCustomerAgreementCommand = (function (_super) {
+    __extends(ConfirmCustomerAgreementCommand, _super);
+    function ConfirmCustomerAgreementCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ConfirmCustomerAgreementCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DirectConnectClient";
-        const commandName = "ConfirmCustomerAgreementCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DirectConnectClient";
+        var commandName = "ConfirmCustomerAgreementCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ConfirmCustomerAgreementRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ConfirmCustomerAgreementResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ConfirmCustomerAgreementCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1ConfirmCustomerAgreementCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ConfirmCustomerAgreementCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1ConfirmCustomerAgreementCommand(output, context);
-    }
-}
+    };
+    return ConfirmCustomerAgreementCommand;
+}($Command));
+export { ConfirmCustomerAgreementCommand };

package/dist-es/commands/ConfirmPrivateVirtualInterfaceCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ConfirmPrivateVirtualInterfaceRequestFilterSensitiveLog, ConfirmPrivateVirtualInterfaceResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1ConfirmPrivateVirtualInterfaceCommand, serializeAws_json1_1ConfirmPrivateVirtualInterfaceCommand, } from "../protocols/Aws_json1_1";
-export class ConfirmPrivateVirtualInterfaceCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ConfirmPrivateVirtualInterfaceCommand = (function (_super) {
+    __extends(ConfirmPrivateVirtualInterfaceCommand, _super);
+    function ConfirmPrivateVirtualInterfaceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ConfirmPrivateVirtualInterfaceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DirectConnectClient";
-        const commandName = "ConfirmPrivateVirtualInterfaceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DirectConnectClient";
+        var commandName = "ConfirmPrivateVirtualInterfaceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ConfirmPrivateVirtualInterfaceRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ConfirmPrivateVirtualInterfaceResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ConfirmPrivateVirtualInterfaceCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1ConfirmPrivateVirtualInterfaceCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ConfirmPrivateVirtualInterfaceCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1ConfirmPrivateVirtualInterfaceCommand(output, context);
-    }
-}
+    };
+    return ConfirmPrivateVirtualInterfaceCommand;
+}($Command));
+export { ConfirmPrivateVirtualInterfaceCommand };

package/dist-es/commands/ConfirmPublicVirtualInterfaceCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ConfirmPublicVirtualInterfaceRequestFilterSensitiveLog, ConfirmPublicVirtualInterfaceResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1ConfirmPublicVirtualInterfaceCommand, serializeAws_json1_1ConfirmPublicVirtualInterfaceCommand, } from "../protocols/Aws_json1_1";
-export class ConfirmPublicVirtualInterfaceCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ConfirmPublicVirtualInterfaceCommand = (function (_super) {
+    __extends(ConfirmPublicVirtualInterfaceCommand, _super);
+    function ConfirmPublicVirtualInterfaceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ConfirmPublicVirtualInterfaceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DirectConnectClient";
-        const commandName = "ConfirmPublicVirtualInterfaceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DirectConnectClient";
+        var commandName = "ConfirmPublicVirtualInterfaceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ConfirmPublicVirtualInterfaceRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ConfirmPublicVirtualInterfaceResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ConfirmPublicVirtualInterfaceCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1ConfirmPublicVirtualInterfaceCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ConfirmPublicVirtualInterfaceCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1ConfirmPublicVirtualInterfaceCommand(output, context);
-    }
-}
+    };
+    return ConfirmPublicVirtualInterfaceCommand;
+}($Command));
+export { ConfirmPublicVirtualInterfaceCommand };

package/dist-es/commands/ConfirmTransitVirtualInterfaceCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ConfirmTransitVirtualInterfaceRequestFilterSensitiveLog, ConfirmTransitVirtualInterfaceResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1ConfirmTransitVirtualInterfaceCommand, serializeAws_json1_1ConfirmTransitVirtualInterfaceCommand, } from "../protocols/Aws_json1_1";
-export class ConfirmTransitVirtualInterfaceCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ConfirmTransitVirtualInterfaceCommand = (function (_super) {
+    __extends(ConfirmTransitVirtualInterfaceCommand, _super);
+    function ConfirmTransitVirtualInterfaceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ConfirmTransitVirtualInterfaceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DirectConnectClient";
-        const commandName = "ConfirmTransitVirtualInterfaceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DirectConnectClient";
+        var commandName = "ConfirmTransitVirtualInterfaceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ConfirmTransitVirtualInterfaceRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ConfirmTransitVirtualInterfaceResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ConfirmTransitVirtualInterfaceCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1ConfirmTransitVirtualInterfaceCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ConfirmTransitVirtualInterfaceCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1ConfirmTransitVirtualInterfaceCommand(output, context);
-    }
-}
+    };
+    return ConfirmTransitVirtualInterfaceCommand;
+}($Command));
+export { ConfirmTransitVirtualInterfaceCommand };

package/dist-es/commands/CreateBGPPeerCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateBGPPeerRequestFilterSensitiveLog, CreateBGPPeerResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateBGPPeerCommand, serializeAws_json1_1CreateBGPPeerCommand, } from "../protocols/Aws_json1_1";
-export class CreateBGPPeerCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateBGPPeerCommand = (function (_super) {
+    __extends(CreateBGPPeerCommand, _super);
+    function CreateBGPPeerCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateBGPPeerCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DirectConnectClient";
-        const commandName = "CreateBGPPeerCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: CreateBGPPeerRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateBGPPeerResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    CreateBGPPeerCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateBGPPeerCommand(output, context);
-    }
-}
+    };
+    return CreateBGPPeerCommand;
+}($Command));
+export { CreateBGPPeerCommand };

package/dist-es/commands/CreateConnectionCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ConnectionFilterSensitiveLog, CreateConnectionRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateConnectionCommand, serializeAws_json1_1CreateConnectionCommand, } from "../protocols/Aws_json1_1";
-export class CreateConnectionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateConnectionCommand = (function (_super) {
+    __extends(CreateConnectionCommand, _super);
+    function CreateConnectionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateConnectionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DirectConnectClient";
-        const commandName = "CreateConnectionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: CreateConnectionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ConnectionFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    CreateConnectionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateConnectionCommand(output, context);
-    }
-}
+    };
+    return CreateConnectionCommand;
+}($Command));
+export { CreateConnectionCommand };

package/dist-es/commands/CreateDirectConnectGatewayAssociationCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateDirectConnectGatewayAssociationRequestFilterSensitiveLog, CreateDirectConnectGatewayAssociationResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateDirectConnectGatewayAssociationCommand, serializeAws_json1_1CreateDirectConnectGatewayAssociationCommand, } from "../protocols/Aws_json1_1";
-export class CreateDirectConnectGatewayAssociationCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateDirectConnectGatewayAssociationCommand = (function (_super) {
+    __extends(CreateDirectConnectGatewayAssociationCommand, _super);
+    function CreateDirectConnectGatewayAssociationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateDirectConnectGatewayAssociationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DirectConnectClient";
-        const commandName = "CreateDirectConnectGatewayAssociationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DirectConnectClient";
+        var commandName = "CreateDirectConnectGatewayAssociationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateDirectConnectGatewayAssociationRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateDirectConnectGatewayAssociationResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateDirectConnectGatewayAssociationCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1CreateDirectConnectGatewayAssociationCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateDirectConnectGatewayAssociationCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateDirectConnectGatewayAssociationCommand(output, context);
-    }
-}
+    };
+    return CreateDirectConnectGatewayAssociationCommand;
+}($Command));
+export { CreateDirectConnectGatewayAssociationCommand };

package/dist-es/commands/CreateDirectConnectGatewayAssociationProposalCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateDirectConnectGatewayAssociationProposalRequestFilterSensitiveLog, CreateDirectConnectGatewayAssociationProposalResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateDirectConnectGatewayAssociationProposalCommand, serializeAws_json1_1CreateDirectConnectGatewayAssociationProposalCommand, } from "../protocols/Aws_json1_1";
-export class CreateDirectConnectGatewayAssociationProposalCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateDirectConnectGatewayAssociationProposalCommand = (function (_super) {
+    __extends(CreateDirectConnectGatewayAssociationProposalCommand, _super);
+    function CreateDirectConnectGatewayAssociationProposalCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateDirectConnectGatewayAssociationProposalCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DirectConnectClient";
-        const commandName = "CreateDirectConnectGatewayAssociationProposalCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "DirectConnectClient";
+        var commandName = "CreateDirectConnectGatewayAssociationProposalCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateDirectConnectGatewayAssociationProposalRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateDirectConnectGatewayAssociationProposalResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateDirectConnectGatewayAssociationProposalCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1CreateDirectConnectGatewayAssociationProposalCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateDirectConnectGatewayAssociationProposalCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateDirectConnectGatewayAssociationProposalCommand(output, context);
-    }
-}
+    };
+    return CreateDirectConnectGatewayAssociationProposalCommand;
+}($Command));
+export { CreateDirectConnectGatewayAssociationProposalCommand };