@aws-sdk/client-iot-events 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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