@aws-sdk/client-greengrass 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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