@aws-sdk/client-networkmanager 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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