@aws-sdk/client-iam 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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