@aws-sdk/client-sts 3.33.0 → 3.36.1

package/dist-es/commands/AssumeRoleWithSAMLCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { AssumeRoleWithSAMLRequest, AssumeRoleWithSAMLResponse } from "../models/models_0";
+import { deserializeAws_queryAssumeRoleWithSAMLCommand, serializeAws_queryAssumeRoleWithSAMLCommand, } from "../protocols/Aws_query";
+var AssumeRoleWithSAMLCommand = (function (_super) {
+    __extends(AssumeRoleWithSAMLCommand, _super);
+    function AssumeRoleWithSAMLCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    AssumeRoleWithSAMLCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "STSClient";
+        var commandName = "AssumeRoleWithSAMLCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: AssumeRoleWithSAMLRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: AssumeRoleWithSAMLResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AssumeRoleWithSAMLCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryAssumeRoleWithSAMLCommand(input, context);
+    };
+    AssumeRoleWithSAMLCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryAssumeRoleWithSAMLCommand(output, context);
+    };
+    return AssumeRoleWithSAMLCommand;
+}($Command));
+export { AssumeRoleWithSAMLCommand };

package/dist-es/commands/AssumeRoleWithWebIdentityCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { AssumeRoleWithWebIdentityRequest, AssumeRoleWithWebIdentityResponse } from "../models/models_0";
+import { deserializeAws_queryAssumeRoleWithWebIdentityCommand, serializeAws_queryAssumeRoleWithWebIdentityCommand, } from "../protocols/Aws_query";
+var AssumeRoleWithWebIdentityCommand = (function (_super) {
+    __extends(AssumeRoleWithWebIdentityCommand, _super);
+    function AssumeRoleWithWebIdentityCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    AssumeRoleWithWebIdentityCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "STSClient";
+        var commandName = "AssumeRoleWithWebIdentityCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: AssumeRoleWithWebIdentityRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: AssumeRoleWithWebIdentityResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AssumeRoleWithWebIdentityCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryAssumeRoleWithWebIdentityCommand(input, context);
+    };
+    AssumeRoleWithWebIdentityCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryAssumeRoleWithWebIdentityCommand(output, context);
+    };
+    return AssumeRoleWithWebIdentityCommand;
+}($Command));
+export { AssumeRoleWithWebIdentityCommand };

package/dist-es/commands/DecodeAuthorizationMessageCommand.js

@@ -0,0 +1,41 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { getAwsAuthPlugin } from "@aws-sdk/middleware-signing";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DecodeAuthorizationMessageRequest, DecodeAuthorizationMessageResponse } from "../models/models_0";
+import { deserializeAws_queryDecodeAuthorizationMessageCommand, serializeAws_queryDecodeAuthorizationMessageCommand, } from "../protocols/Aws_query";
+var DecodeAuthorizationMessageCommand = (function (_super) {
+    __extends(DecodeAuthorizationMessageCommand, _super);
+    function DecodeAuthorizationMessageCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DecodeAuthorizationMessageCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getAwsAuthPlugin(configuration));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "STSClient";
+        var commandName = "DecodeAuthorizationMessageCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DecodeAuthorizationMessageRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DecodeAuthorizationMessageResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DecodeAuthorizationMessageCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryDecodeAuthorizationMessageCommand(input, context);
+    };
+    DecodeAuthorizationMessageCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryDecodeAuthorizationMessageCommand(output, context);
+    };
+    return DecodeAuthorizationMessageCommand;
+}($Command));
+export { DecodeAuthorizationMessageCommand };

package/dist-es/commands/GetAccessKeyInfoCommand.js

@@ -0,0 +1,41 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { getAwsAuthPlugin } from "@aws-sdk/middleware-signing";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetAccessKeyInfoRequest, GetAccessKeyInfoResponse } from "../models/models_0";
+import { deserializeAws_queryGetAccessKeyInfoCommand, serializeAws_queryGetAccessKeyInfoCommand, } from "../protocols/Aws_query";
+var GetAccessKeyInfoCommand = (function (_super) {
+    __extends(GetAccessKeyInfoCommand, _super);
+    function GetAccessKeyInfoCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetAccessKeyInfoCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getAwsAuthPlugin(configuration));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "STSClient";
+        var commandName = "GetAccessKeyInfoCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetAccessKeyInfoRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetAccessKeyInfoResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetAccessKeyInfoCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryGetAccessKeyInfoCommand(input, context);
+    };
+    GetAccessKeyInfoCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryGetAccessKeyInfoCommand(output, context);
+    };
+    return GetAccessKeyInfoCommand;
+}($Command));
+export { GetAccessKeyInfoCommand };

package/{dist/es → dist-es}/commands/GetCallerIdentityCommand.js

@@ -1,50 +1,16 @@
 import { __extends } from "tslib";
-import { GetCallerIdentityRequest, GetCallerIdentityResponse } from "../models/models_0";
-import { deserializeAws_queryGetCallerIdentityCommand, serializeAws_queryGetCallerIdentityCommand, } from "../protocols/Aws_query";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { getAwsAuthPlugin } from "@aws-sdk/middleware-signing";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-/**
- * <p>Returns details about the IAM user or role whose credentials are used to call the
- *             operation.</p>
- *         <note>
- *             <p>No permissions are required to perform this operation. If an administrator adds a
- *                 policy to your IAM user or role that explicitly denies access to the
- *                     <code>sts:GetCallerIdentity</code> action, you can still perform this operation.
- *                 Permissions are not required because the same information is returned when an IAM
- *                 user or role is denied access. To view an example response, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/troubleshoot_general.html#troubleshoot_general_access-denied-delete-mfa">I Am Not Authorized to Perform: iam:DeleteVirtualMFADevice</a> in the
- *                     <i>IAM User Guide</i>.</p>
- *         </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { STSClient, GetCallerIdentityCommand } from "@aws-sdk/client-sts"; // ES Modules import
- * // const { STSClient, GetCallerIdentityCommand } = require("@aws-sdk/client-sts"); // CommonJS import
- * const client = new STSClient(config);
- * const command = new GetCallerIdentityCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetCallerIdentityCommandInput} for command's `input` shape.
- * @see {@link GetCallerIdentityCommandOutput} for command's `response` shape.
- * @see {@link STSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-var GetCallerIdentityCommand = /** @class */ (function (_super) {
+import { GetCallerIdentityRequest, GetCallerIdentityResponse } from "../models/models_0";
+import { deserializeAws_queryGetCallerIdentityCommand, serializeAws_queryGetCallerIdentityCommand, } from "../protocols/Aws_query";
+var GetCallerIdentityCommand = (function (_super) {
     __extends(GetCallerIdentityCommand, _super);
-    // Start section: command_properties
-    // End section: command_properties
     function GetCallerIdentityCommand(input) {
-        var _this = 
-        // Start section: command_constructor
-        _super.call(this) || this;
+        var _this = _super.call(this) || this;
         _this.input = input;
         return _this;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     GetCallerIdentityCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getAwsAuthPlugin(configuration));
@@ -73,4 +39,3 @@ var GetCallerIdentityCommand = /** @class */ (function (_super) {
     return GetCallerIdentityCommand;
 }($Command));
 export { GetCallerIdentityCommand };
-//# sourceMappingURL=GetCallerIdentityCommand.js.map

package/dist-es/commands/GetFederationTokenCommand.js

@@ -0,0 +1,41 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { getAwsAuthPlugin } from "@aws-sdk/middleware-signing";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetFederationTokenRequest, GetFederationTokenResponse } from "../models/models_0";
+import { deserializeAws_queryGetFederationTokenCommand, serializeAws_queryGetFederationTokenCommand, } from "../protocols/Aws_query";
+var GetFederationTokenCommand = (function (_super) {
+    __extends(GetFederationTokenCommand, _super);
+    function GetFederationTokenCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetFederationTokenCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getAwsAuthPlugin(configuration));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "STSClient";
+        var commandName = "GetFederationTokenCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetFederationTokenRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetFederationTokenResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetFederationTokenCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryGetFederationTokenCommand(input, context);
+    };
+    GetFederationTokenCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryGetFederationTokenCommand(output, context);
+    };
+    return GetFederationTokenCommand;
+}($Command));
+export { GetFederationTokenCommand };

package/dist-es/commands/GetSessionTokenCommand.js

@@ -0,0 +1,41 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { getAwsAuthPlugin } from "@aws-sdk/middleware-signing";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetSessionTokenRequest, GetSessionTokenResponse } from "../models/models_0";
+import { deserializeAws_queryGetSessionTokenCommand, serializeAws_queryGetSessionTokenCommand, } from "../protocols/Aws_query";
+var GetSessionTokenCommand = (function (_super) {
+    __extends(GetSessionTokenCommand, _super);
+    function GetSessionTokenCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetSessionTokenCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getAwsAuthPlugin(configuration));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "STSClient";
+        var commandName = "GetSessionTokenCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetSessionTokenRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetSessionTokenResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetSessionTokenCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryGetSessionTokenCommand(input, context);
+    };
+    GetSessionTokenCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryGetSessionTokenCommand(output, context);
+    };
+    return GetSessionTokenCommand;
+}($Command));
+export { GetSessionTokenCommand };

package/dist-es/defaultRoleAssumers.js

@@ -0,0 +1,16 @@
+import { __assign } from "tslib";
+import { getDefaultRoleAssumer as StsGetDefaultRoleAssumer, getDefaultRoleAssumerWithWebIdentity as StsGetDefaultRoleAssumerWithWebIdentity, } from "./defaultStsRoleAssumers";
+import { STSClient } from "./STSClient";
+export var getDefaultRoleAssumer = function (stsOptions) {
+    if (stsOptions === void 0) { stsOptions = {}; }
+    return StsGetDefaultRoleAssumer(stsOptions, STSClient);
+};
+export var getDefaultRoleAssumerWithWebIdentity = function (stsOptions) {
+    if (stsOptions === void 0) { stsOptions = {}; }
+    return StsGetDefaultRoleAssumerWithWebIdentity(stsOptions, STSClient);
+};
+export var decorateDefaultCredentialProvider = function (provider) {
+    return function (input) {
+        return provider(__assign({ roleAssumer: getDefaultRoleAssumer(input), roleAssumerWithWebIdentity: getDefaultRoleAssumerWithWebIdentity(input) }, input));
+    };
+};

package/{dist/es → dist-es}/defaultStsRoleAssumers.js

@@ -2,9 +2,6 @@ import { __assign, __awaiter, __generator } from "tslib";
 import { AssumeRoleCommand } from "./commands/AssumeRoleCommand";
 import { AssumeRoleWithWebIdentityCommand, } from "./commands/AssumeRoleWithWebIdentityCommand";
 var ASSUME_ROLE_DEFAULT_REGION = "us-east-1";
-/**
- * Inject the fallback STS region of us-east-1.
- */
 var decorateDefaultRegion = function (region) {
     if (typeof region !== "function") {
         return region === undefined ? ASSUME_ROLE_DEFAULT_REGION : region;
@@ -15,20 +12,16 @@ var decorateDefaultRegion = function (region) {
             switch (_a.label) {
                 case 0:
                     _a.trys.push([0, 2, , 3]);
-                    return [4 /*yield*/, region()];
-                case 1: return [2 /*return*/, _a.sent()];
+                    return [4, region()];
+                case 1: return [2, _a.sent()];
                 case 2:
                     e_1 = _a.sent();
-                    return [2 /*return*/, ASSUME_ROLE_DEFAULT_REGION];
-                case 3: return [2 /*return*/];
+                    return [2, ASSUME_ROLE_DEFAULT_REGION];
+                case 3: return [2];
             }
         });
     }); };
 };
-/**
- * The default role assumer that used by credential providers when sts:AssumeRole API is needed.
- * @internal
- */
 export var getDefaultRoleAssumer = function (stsOptions, stsClientCtor) {
     var stsClient;
     var closureSourceCreds;
@@ -40,19 +33,17 @@ export var getDefaultRoleAssumer = function (stsOptions, stsClientCtor) {
                     closureSourceCreds = sourceCreds;
                     if (!stsClient) {
                         logger = stsOptions.logger, region = stsOptions.region, requestHandler = stsOptions.requestHandler;
-                        stsClient = new stsClientCtor(__assign({ logger: logger, 
-                            // A hack to make sts client uses the credential in current closure.
-                            credentialDefaultProvider: function () { return function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
-                                return [2 /*return*/, closureSourceCreds];
+                        stsClient = new stsClientCtor(__assign({ logger: logger, credentialDefaultProvider: function () { return function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                                return [2, closureSourceCreds];
                             }); }); }; }, region: decorateDefaultRegion(region || stsOptions.region) }, (requestHandler ? { requestHandler: requestHandler } : {})));
                     }
-                    return [4 /*yield*/, stsClient.send(new AssumeRoleCommand(params))];
+                    return [4, stsClient.send(new AssumeRoleCommand(params))];
                 case 1:
                     Credentials = (_a.sent()).Credentials;
                     if (!Credentials || !Credentials.AccessKeyId || !Credentials.SecretAccessKey) {
                         throw new Error("Invalid response from STS.assumeRole call with role " + params.RoleArn);
                     }
-                    return [2 /*return*/, {
+                    return [2, {
                             accessKeyId: Credentials.AccessKeyId,
                             secretAccessKey: Credentials.SecretAccessKey,
                             sessionToken: Credentials.SessionToken,
@@ -62,10 +53,6 @@ export var getDefaultRoleAssumer = function (stsOptions, stsClientCtor) {
         });
     }); };
 };
-/**
- * The default role assumer that used by credential providers when sts:AssumeRoleWithWebIdentity API is needed.
- * @internal
- */
 export var getDefaultRoleAssumerWithWebIdentity = function (stsOptions, stsClientCtor) {
     var stsClient;
     return function (params) { return __awaiter(void 0, void 0, void 0, function () {
@@ -77,13 +64,13 @@ export var getDefaultRoleAssumerWithWebIdentity = function (stsOptions, stsClien
                         logger = stsOptions.logger, region = stsOptions.region, requestHandler = stsOptions.requestHandler;
                         stsClient = new stsClientCtor(__assign({ logger: logger, region: decorateDefaultRegion(region || stsOptions.region) }, (requestHandler ? { requestHandler: requestHandler } : {})));
                     }
-                    return [4 /*yield*/, stsClient.send(new AssumeRoleWithWebIdentityCommand(params))];
+                    return [4, stsClient.send(new AssumeRoleWithWebIdentityCommand(params))];
                 case 1:
                     Credentials = (_a.sent()).Credentials;
                     if (!Credentials || !Credentials.AccessKeyId || !Credentials.SecretAccessKey) {
                         throw new Error("Invalid response from STS.assumeRoleWithWebIdentity call with role " + params.RoleArn);
                     }
-                    return [2 /*return*/, {
+                    return [2, {
                             accessKeyId: Credentials.AccessKeyId,
                             secretAccessKey: Credentials.SecretAccessKey,
                             sessionToken: Credentials.SessionToken,
@@ -93,17 +80,8 @@ export var getDefaultRoleAssumerWithWebIdentity = function (stsOptions, stsClien
         });
     }); };
 };
-/**
- * The default credential providers depend STS client to assume role with desired API: sts:assumeRole,
- * sts:assumeRoleWithWebIdentity, etc. This function decorates the default credential provider with role assumers which
- * encapsulates the process of calling STS commands. This can only be imported by AWS client packages to avoid circular
- * dependencies.
- *
- * @internal
- */
 export var decorateDefaultCredentialProvider = function (provider) {
     return function (input) {
         return provider(__assign({ roleAssumer: getDefaultRoleAssumer(input, input.stsClientCtor), roleAssumerWithWebIdentity: getDefaultRoleAssumerWithWebIdentity(input, input.stsClientCtor) }, input));
     };
 };
-//# sourceMappingURL=defaultStsRoleAssumers.js.map

package/{dist/es → dist-es}/endpoints.js

@@ -81,7 +81,6 @@ var partitionHash = {
 };
 export var defaultRegionInfoProvider = function (region, options) { return __awaiter(void 0, void 0, void 0, function () {
     return __generator(this, function (_a) {
-        return [2 /*return*/, getRegionInfo(region, __assign(__assign({}, options), { signingService: "sts", regionHash: regionHash, partitionHash: partitionHash }))];
+        return [2, getRegionInfo(region, __assign(__assign({}, options), { signingService: "sts", regionHash: regionHash, partitionHash: partitionHash }))];
     });
 }); };
-//# sourceMappingURL=endpoints.js.map

package/{dist/es → dist-es}/models/models_0.js

@@ -1,205 +1,117 @@
 import { __assign } from "tslib";
 export var AssumedRoleUser;
 (function (AssumedRoleUser) {
-    /**
-     * @internal
-     */
     AssumedRoleUser.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(AssumedRoleUser || (AssumedRoleUser = {}));
 export var PolicyDescriptorType;
 (function (PolicyDescriptorType) {
-    /**
-     * @internal
-     */
     PolicyDescriptorType.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(PolicyDescriptorType || (PolicyDescriptorType = {}));
 export var Tag;
 (function (Tag) {
-    /**
-     * @internal
-     */
     Tag.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(Tag || (Tag = {}));
 export var AssumeRoleRequest;
 (function (AssumeRoleRequest) {
-    /**
-     * @internal
-     */
     AssumeRoleRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(AssumeRoleRequest || (AssumeRoleRequest = {}));
 export var Credentials;
 (function (Credentials) {
-    /**
-     * @internal
-     */
     Credentials.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(Credentials || (Credentials = {}));
 export var AssumeRoleResponse;
 (function (AssumeRoleResponse) {
-    /**
-     * @internal
-     */
     AssumeRoleResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(AssumeRoleResponse || (AssumeRoleResponse = {}));
 export var ExpiredTokenException;
 (function (ExpiredTokenException) {
-    /**
-     * @internal
-     */
     ExpiredTokenException.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(ExpiredTokenException || (ExpiredTokenException = {}));
 export var MalformedPolicyDocumentException;
 (function (MalformedPolicyDocumentException) {
-    /**
-     * @internal
-     */
     MalformedPolicyDocumentException.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(MalformedPolicyDocumentException || (MalformedPolicyDocumentException = {}));
 export var PackedPolicyTooLargeException;
 (function (PackedPolicyTooLargeException) {
-    /**
-     * @internal
-     */
     PackedPolicyTooLargeException.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(PackedPolicyTooLargeException || (PackedPolicyTooLargeException = {}));
 export var RegionDisabledException;
 (function (RegionDisabledException) {
-    /**
-     * @internal
-     */
     RegionDisabledException.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(RegionDisabledException || (RegionDisabledException = {}));
 export var AssumeRoleWithSAMLRequest;
 (function (AssumeRoleWithSAMLRequest) {
-    /**
-     * @internal
-     */
     AssumeRoleWithSAMLRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(AssumeRoleWithSAMLRequest || (AssumeRoleWithSAMLRequest = {}));
 export var AssumeRoleWithSAMLResponse;
 (function (AssumeRoleWithSAMLResponse) {
-    /**
-     * @internal
-     */
     AssumeRoleWithSAMLResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(AssumeRoleWithSAMLResponse || (AssumeRoleWithSAMLResponse = {}));
 export var IDPRejectedClaimException;
 (function (IDPRejectedClaimException) {
-    /**
-     * @internal
-     */
     IDPRejectedClaimException.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(IDPRejectedClaimException || (IDPRejectedClaimException = {}));
 export var InvalidIdentityTokenException;
 (function (InvalidIdentityTokenException) {
-    /**
-     * @internal
-     */
     InvalidIdentityTokenException.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(InvalidIdentityTokenException || (InvalidIdentityTokenException = {}));
 export var AssumeRoleWithWebIdentityRequest;
 (function (AssumeRoleWithWebIdentityRequest) {
-    /**
-     * @internal
-     */
     AssumeRoleWithWebIdentityRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(AssumeRoleWithWebIdentityRequest || (AssumeRoleWithWebIdentityRequest = {}));
 export var AssumeRoleWithWebIdentityResponse;
 (function (AssumeRoleWithWebIdentityResponse) {
-    /**
-     * @internal
-     */
     AssumeRoleWithWebIdentityResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(AssumeRoleWithWebIdentityResponse || (AssumeRoleWithWebIdentityResponse = {}));
 export var IDPCommunicationErrorException;
 (function (IDPCommunicationErrorException) {
-    /**
-     * @internal
-     */
     IDPCommunicationErrorException.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(IDPCommunicationErrorException || (IDPCommunicationErrorException = {}));
 export var DecodeAuthorizationMessageRequest;
 (function (DecodeAuthorizationMessageRequest) {
-    /**
-     * @internal
-     */
     DecodeAuthorizationMessageRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(DecodeAuthorizationMessageRequest || (DecodeAuthorizationMessageRequest = {}));
 export var DecodeAuthorizationMessageResponse;
 (function (DecodeAuthorizationMessageResponse) {
-    /**
-     * @internal
-     */
     DecodeAuthorizationMessageResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(DecodeAuthorizationMessageResponse || (DecodeAuthorizationMessageResponse = {}));
 export var InvalidAuthorizationMessageException;
 (function (InvalidAuthorizationMessageException) {
-    /**
-     * @internal
-     */
     InvalidAuthorizationMessageException.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(InvalidAuthorizationMessageException || (InvalidAuthorizationMessageException = {}));
 export var GetAccessKeyInfoRequest;
 (function (GetAccessKeyInfoRequest) {
-    /**
-     * @internal
-     */
     GetAccessKeyInfoRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(GetAccessKeyInfoRequest || (GetAccessKeyInfoRequest = {}));
 export var GetAccessKeyInfoResponse;
 (function (GetAccessKeyInfoResponse) {
-    /**
-     * @internal
-     */
     GetAccessKeyInfoResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(GetAccessKeyInfoResponse || (GetAccessKeyInfoResponse = {}));
 export var GetCallerIdentityRequest;
 (function (GetCallerIdentityRequest) {
-    /**
-     * @internal
-     */
     GetCallerIdentityRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(GetCallerIdentityRequest || (GetCallerIdentityRequest = {}));
 export var GetCallerIdentityResponse;
 (function (GetCallerIdentityResponse) {
-    /**
-     * @internal
-     */
     GetCallerIdentityResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(GetCallerIdentityResponse || (GetCallerIdentityResponse = {}));
 export var GetFederationTokenRequest;
 (function (GetFederationTokenRequest) {
-    /**
-     * @internal
-     */
     GetFederationTokenRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(GetFederationTokenRequest || (GetFederationTokenRequest = {}));
 export var FederatedUser;
 (function (FederatedUser) {
-    /**
-     * @internal
-     */
     FederatedUser.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(FederatedUser || (FederatedUser = {}));
 export var GetFederationTokenResponse;
 (function (GetFederationTokenResponse) {
-    /**
-     * @internal
-     */
     GetFederationTokenResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(GetFederationTokenResponse || (GetFederationTokenResponse = {}));
 export var GetSessionTokenRequest;
 (function (GetSessionTokenRequest) {
-    /**
-     * @internal
-     */
     GetSessionTokenRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(GetSessionTokenRequest || (GetSessionTokenRequest = {}));
 export var GetSessionTokenResponse;
 (function (GetSessionTokenResponse) {
-    /**
-     * @internal
-     */
     GetSessionTokenResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(GetSessionTokenResponse || (GetSessionTokenResponse = {}));
-//# sourceMappingURL=models_0.js.map