@aws-sdk/client-networkmanager 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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