@aws-sdk/client-iot 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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