@aws-sdk/client-networkmanager 3.183.0 → 3.186.0

package/dist-es/commands/DescribeGlobalNetworksCommand.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 { DescribeGlobalNetworksRequestFilterSensitiveLog, DescribeGlobalNetworksResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DescribeGlobalNetworksCommand, serializeAws_restJson1DescribeGlobalNetworksCommand, } from "../protocols/Aws_restJson1";
-export class DescribeGlobalNetworksCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeGlobalNetworksCommand = (function (_super) {
+    __extends(DescribeGlobalNetworksCommand, _super);
+    function DescribeGlobalNetworksCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeGlobalNetworksCommand.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 = "NetworkManagerClient";
-        const commandName = "DescribeGlobalNetworksCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "NetworkManagerClient";
+        var commandName = "DescribeGlobalNetworksCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeGlobalNetworksRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeGlobalNetworksResponseFilterSensitiveLog,
         };
-        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);
+    };
+    DescribeGlobalNetworksCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DescribeGlobalNetworksCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeGlobalNetworksCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DescribeGlobalNetworksCommand(output, context);
-    }
-}
+    };
+    return DescribeGlobalNetworksCommand;
+}($Command));
+export { DescribeGlobalNetworksCommand };

package/dist-es/commands/DisassociateConnectPeerCommand.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 { DisassociateConnectPeerRequestFilterSensitiveLog, DisassociateConnectPeerResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DisassociateConnectPeerCommand, serializeAws_restJson1DisassociateConnectPeerCommand, } from "../protocols/Aws_restJson1";
-export class DisassociateConnectPeerCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DisassociateConnectPeerCommand = (function (_super) {
+    __extends(DisassociateConnectPeerCommand, _super);
+    function DisassociateConnectPeerCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DisassociateConnectPeerCommand.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 = "NetworkManagerClient";
-        const commandName = "DisassociateConnectPeerCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "NetworkManagerClient";
+        var commandName = "DisassociateConnectPeerCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DisassociateConnectPeerRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DisassociateConnectPeerResponseFilterSensitiveLog,
         };
-        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);
+    };
+    DisassociateConnectPeerCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DisassociateConnectPeerCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DisassociateConnectPeerCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DisassociateConnectPeerCommand(output, context);
-    }
-}
+    };
+    return DisassociateConnectPeerCommand;
+}($Command));
+export { DisassociateConnectPeerCommand };

package/dist-es/commands/DisassociateCustomerGatewayCommand.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 { DisassociateCustomerGatewayRequestFilterSensitiveLog, DisassociateCustomerGatewayResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DisassociateCustomerGatewayCommand, serializeAws_restJson1DisassociateCustomerGatewayCommand, } from "../protocols/Aws_restJson1";
-export class DisassociateCustomerGatewayCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DisassociateCustomerGatewayCommand = (function (_super) {
+    __extends(DisassociateCustomerGatewayCommand, _super);
+    function DisassociateCustomerGatewayCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DisassociateCustomerGatewayCommand.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 = "NetworkManagerClient";
-        const commandName = "DisassociateCustomerGatewayCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "NetworkManagerClient";
+        var commandName = "DisassociateCustomerGatewayCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DisassociateCustomerGatewayRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DisassociateCustomerGatewayResponseFilterSensitiveLog,
         };
-        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);
+    };
+    DisassociateCustomerGatewayCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DisassociateCustomerGatewayCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DisassociateCustomerGatewayCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DisassociateCustomerGatewayCommand(output, context);
-    }
-}
+    };
+    return DisassociateCustomerGatewayCommand;
+}($Command));
+export { DisassociateCustomerGatewayCommand };

package/dist-es/commands/DisassociateLinkCommand.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 { DisassociateLinkRequestFilterSensitiveLog, DisassociateLinkResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DisassociateLinkCommand, serializeAws_restJson1DisassociateLinkCommand, } from "../protocols/Aws_restJson1";
-export class DisassociateLinkCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DisassociateLinkCommand = (function (_super) {
+    __extends(DisassociateLinkCommand, _super);
+    function DisassociateLinkCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DisassociateLinkCommand.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 = "NetworkManagerClient";
-        const commandName = "DisassociateLinkCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "NetworkManagerClient";
+        var commandName = "DisassociateLinkCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DisassociateLinkRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DisassociateLinkResponseFilterSensitiveLog,
         };
-        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);
+    };
+    DisassociateLinkCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DisassociateLinkCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DisassociateLinkCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DisassociateLinkCommand(output, context);
-    }
-}
+    };
+    return DisassociateLinkCommand;
+}($Command));
+export { DisassociateLinkCommand };

package/dist-es/commands/DisassociateTransitGatewayConnectPeerCommand.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 { DisassociateTransitGatewayConnectPeerRequestFilterSensitiveLog, DisassociateTransitGatewayConnectPeerResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DisassociateTransitGatewayConnectPeerCommand, serializeAws_restJson1DisassociateTransitGatewayConnectPeerCommand, } from "../protocols/Aws_restJson1";
-export class DisassociateTransitGatewayConnectPeerCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DisassociateTransitGatewayConnectPeerCommand = (function (_super) {
+    __extends(DisassociateTransitGatewayConnectPeerCommand, _super);
+    function DisassociateTransitGatewayConnectPeerCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DisassociateTransitGatewayConnectPeerCommand.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 = "NetworkManagerClient";
-        const commandName = "DisassociateTransitGatewayConnectPeerCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "NetworkManagerClient";
+        var commandName = "DisassociateTransitGatewayConnectPeerCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DisassociateTransitGatewayConnectPeerRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DisassociateTransitGatewayConnectPeerResponseFilterSensitiveLog,
         };
-        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);
+    };
+    DisassociateTransitGatewayConnectPeerCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DisassociateTransitGatewayConnectPeerCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DisassociateTransitGatewayConnectPeerCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DisassociateTransitGatewayConnectPeerCommand(output, context);
-    }
-}
+    };
+    return DisassociateTransitGatewayConnectPeerCommand;
+}($Command));
+export { DisassociateTransitGatewayConnectPeerCommand };

package/dist-es/commands/ExecuteCoreNetworkChangeSetCommand.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 { ExecuteCoreNetworkChangeSetRequestFilterSensitiveLog, ExecuteCoreNetworkChangeSetResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ExecuteCoreNetworkChangeSetCommand, serializeAws_restJson1ExecuteCoreNetworkChangeSetCommand, } from "../protocols/Aws_restJson1";
-export class ExecuteCoreNetworkChangeSetCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ExecuteCoreNetworkChangeSetCommand = (function (_super) {
+    __extends(ExecuteCoreNetworkChangeSetCommand, _super);
+    function ExecuteCoreNetworkChangeSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ExecuteCoreNetworkChangeSetCommand.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 = "NetworkManagerClient";
-        const commandName = "ExecuteCoreNetworkChangeSetCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "NetworkManagerClient";
+        var commandName = "ExecuteCoreNetworkChangeSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ExecuteCoreNetworkChangeSetRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ExecuteCoreNetworkChangeSetResponseFilterSensitiveLog,
         };
-        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);
+    };
+    ExecuteCoreNetworkChangeSetCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ExecuteCoreNetworkChangeSetCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ExecuteCoreNetworkChangeSetCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ExecuteCoreNetworkChangeSetCommand(output, context);
-    }
-}
+    };
+    return ExecuteCoreNetworkChangeSetCommand;
+}($Command));
+export { ExecuteCoreNetworkChangeSetCommand };

package/dist-es/commands/GetConnectAttachmentCommand.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 { GetConnectAttachmentRequestFilterSensitiveLog, GetConnectAttachmentResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetConnectAttachmentCommand, serializeAws_restJson1GetConnectAttachmentCommand, } from "../protocols/Aws_restJson1";
-export class GetConnectAttachmentCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetConnectAttachmentCommand = (function (_super) {
+    __extends(GetConnectAttachmentCommand, _super);
+    function GetConnectAttachmentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetConnectAttachmentCommand.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 = "NetworkManagerClient";
-        const commandName = "GetConnectAttachmentCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "NetworkManagerClient";
+        var commandName = "GetConnectAttachmentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetConnectAttachmentRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetConnectAttachmentResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetConnectAttachmentCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetConnectAttachmentCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetConnectAttachmentCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetConnectAttachmentCommand(output, context);
-    }
-}
+    };
+    return GetConnectAttachmentCommand;
+}($Command));
+export { GetConnectAttachmentCommand };

package/dist-es/commands/GetConnectPeerAssociationsCommand.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 { GetConnectPeerAssociationsRequestFilterSensitiveLog, GetConnectPeerAssociationsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetConnectPeerAssociationsCommand, serializeAws_restJson1GetConnectPeerAssociationsCommand, } from "../protocols/Aws_restJson1";
-export class GetConnectPeerAssociationsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetConnectPeerAssociationsCommand = (function (_super) {
+    __extends(GetConnectPeerAssociationsCommand, _super);
+    function GetConnectPeerAssociationsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetConnectPeerAssociationsCommand.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 = "NetworkManagerClient";
-        const commandName = "GetConnectPeerAssociationsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "NetworkManagerClient";
+        var commandName = "GetConnectPeerAssociationsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetConnectPeerAssociationsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetConnectPeerAssociationsResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetConnectPeerAssociationsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetConnectPeerAssociationsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetConnectPeerAssociationsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetConnectPeerAssociationsCommand(output, context);
-    }
-}
+    };
+    return GetConnectPeerAssociationsCommand;
+}($Command));
+export { GetConnectPeerAssociationsCommand };

package/dist-es/commands/GetConnectPeerCommand.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 { GetConnectPeerRequestFilterSensitiveLog, GetConnectPeerResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetConnectPeerCommand, serializeAws_restJson1GetConnectPeerCommand, } from "../protocols/Aws_restJson1";
-export class GetConnectPeerCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetConnectPeerCommand = (function (_super) {
+    __extends(GetConnectPeerCommand, _super);
+    function GetConnectPeerCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetConnectPeerCommand.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 = "NetworkManagerClient";
-        const commandName = "GetConnectPeerCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "NetworkManagerClient";
+        var commandName = "GetConnectPeerCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetConnectPeerRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetConnectPeerResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetConnectPeerCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetConnectPeerCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetConnectPeerCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetConnectPeerCommand(output, context);
-    }
-}
+    };
+    return GetConnectPeerCommand;
+}($Command));
+export { GetConnectPeerCommand };

package/dist-es/commands/GetConnectionsCommand.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 { GetConnectionsRequestFilterSensitiveLog, GetConnectionsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetConnectionsCommand, serializeAws_restJson1GetConnectionsCommand, } from "../protocols/Aws_restJson1";
-export class GetConnectionsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetConnectionsCommand = (function (_super) {
+    __extends(GetConnectionsCommand, _super);
+    function GetConnectionsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetConnectionsCommand.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 = "NetworkManagerClient";
-        const commandName = "GetConnectionsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "NetworkManagerClient";
+        var commandName = "GetConnectionsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetConnectionsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetConnectionsResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetConnectionsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetConnectionsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetConnectionsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetConnectionsCommand(output, context);
-    }
-}
+    };
+    return GetConnectionsCommand;
+}($Command));
+export { GetConnectionsCommand };