@aws-sdk/client-iot 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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