@aws-sdk/client-iot 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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