@aws-sdk/client-iam 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

package/dist-es/commands/UpdateRoleCommand.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 { UpdateRoleRequestFilterSensitiveLog, UpdateRoleResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_queryUpdateRoleCommand, serializeAws_queryUpdateRoleCommand } from "../protocols/Aws_query";
-export class UpdateRoleCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateRoleCommand = (function (_super) {
+    __extends(UpdateRoleCommand, _super);
+    function UpdateRoleCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateRoleCommand.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 = "IAMClient";
-        const commandName = "UpdateRoleCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IAMClient";
+        var commandName = "UpdateRoleCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateRoleRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateRoleResponseFilterSensitiveLog,
         };
-        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);
+    };
+    UpdateRoleCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryUpdateRoleCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateRoleCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryUpdateRoleCommand(output, context);
-    }
-}
+    };
+    return UpdateRoleCommand;
+}($Command));
+export { UpdateRoleCommand };

package/dist-es/commands/UpdateRoleDescriptionCommand.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 { UpdateRoleDescriptionRequestFilterSensitiveLog, UpdateRoleDescriptionResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_queryUpdateRoleDescriptionCommand, serializeAws_queryUpdateRoleDescriptionCommand, } from "../protocols/Aws_query";
-export class UpdateRoleDescriptionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateRoleDescriptionCommand = (function (_super) {
+    __extends(UpdateRoleDescriptionCommand, _super);
+    function UpdateRoleDescriptionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateRoleDescriptionCommand.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 = "IAMClient";
-        const commandName = "UpdateRoleDescriptionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IAMClient";
+        var commandName = "UpdateRoleDescriptionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateRoleDescriptionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateRoleDescriptionResponseFilterSensitiveLog,
         };
-        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);
+    };
+    UpdateRoleDescriptionCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryUpdateRoleDescriptionCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateRoleDescriptionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryUpdateRoleDescriptionCommand(output, context);
-    }
-}
+    };
+    return UpdateRoleDescriptionCommand;
+}($Command));
+export { UpdateRoleDescriptionCommand };