@aws-sdk/client-iam 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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