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

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

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

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

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

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

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

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

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

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

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