@aws-sdk/client-greengrass 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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