@aws-sdk/client-iam 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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