@aws-sdk/client-iam 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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