@aws-sdk/client-iam 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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