@aws-sdk/client-iot 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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