@aws-sdk/client-iam 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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