@aws-sdk/client-iot 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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