@aws-sdk/client-iot 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

package/dist-es/endpoints.js

@@ -1,5 +1,6 @@
+import { __assign, __awaiter, __generator } from "tslib";
 import { getRegionInfo } from "@aws-sdk/config-resolver";
-const regionHash = {
+var regionHash = {
     "ca-central-1": {
         variants: [
             {
@@ -57,7 +58,7 @@ const regionHash = {
         ],
     },
 };
-const partitionHash = {
+var partitionHash = {
     aws: {
         regions: [
             "af-south-1",
@@ -182,9 +183,8 @@ const partitionHash = {
         ],
     },
 };
-export const defaultRegionInfoProvider = async (region, options) => getRegionInfo(region, {
-    ...options,
-    signingService: "execute-api",
-    regionHash,
-    partitionHash,
-});
+export var defaultRegionInfoProvider = function (region, options) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2, getRegionInfo(region, __assign(__assign({}, options), { signingService: "execute-api", regionHash: regionHash, partitionHash: partitionHash }))];
+    });
+}); };

package/dist-es/models/IoTServiceException.js

@@ -1,7 +1,12 @@
+import { __extends } from "tslib";
 import { ServiceException as __ServiceException, } from "@aws-sdk/smithy-client";
-export class IoTServiceException extends __ServiceException {
-    constructor(options) {
-        super(options);
-        Object.setPrototypeOf(this, IoTServiceException.prototype);
+var IoTServiceException = (function (_super) {
+    __extends(IoTServiceException, _super);
+    function IoTServiceException(options) {
+        var _this = _super.call(this, options) || this;
+        Object.setPrototypeOf(_this, IoTServiceException.prototype);
+        return _this;
     }
-}
+    return IoTServiceException;
+}(__ServiceException));
+export { IoTServiceException };