@aws-sdk/client-greengrass 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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