@aws-sdk/client-iot 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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