@aws-sdk/client-sts 3.31.0 → 3.35.0

package/dist/es/commands/DecodeAuthorizationMessageCommand.js

@@ -1,102 +0,0 @@
-import { __extends } from "tslib";
-import { DecodeAuthorizationMessageRequest, DecodeAuthorizationMessageResponse } from "../models/models_0";
-import { deserializeAws_queryDecodeAuthorizationMessageCommand, serializeAws_queryDecodeAuthorizationMessageCommand, } 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>Decodes additional information about the authorization status of a request from an
- *          encoded message returned in response to an Amazon Web Services request.</p>
- *          <p>For example, if a user is not authorized to perform an operation that he or she has
- *          requested, the request returns a <code>Client.UnauthorizedOperation</code> response (an
- *          HTTP 403 response). Some Amazon Web Services operations additionally return an encoded message that can
- *          provide details about this authorization failure. </p>
- *          <note>
- *             <p>Only certain Amazon Web Services operations return an encoded authorization message. The
- *             documentation for an individual operation indicates whether that operation returns an
- *             encoded message in addition to returning an HTTP code.</p>
- *          </note>
- *          <p>The message is encoded because the details of the authorization status can constitute
- *          privileged information that the user who requested the operation should not see. To decode
- *          an authorization status message, a user must be granted permissions via an IAM policy to
- *          request the <code>DecodeAuthorizationMessage</code>
- *             (<code>sts:DecodeAuthorizationMessage</code>) action. </p>
- *          <p>The decoded message includes the following type of information:</p>
- *          <ul>
- *             <li>
- *                <p>Whether the request was denied due to an explicit deny or due to the absence of an
- *                explicit allow. For more information, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html#policy-eval-denyallow">Determining Whether a Request is Allowed or Denied</a> in the
- *                   <i>IAM User Guide</i>. </p>
- *             </li>
- *             <li>
- *                <p>The principal who made the request.</p>
- *             </li>
- *             <li>
- *                <p>The requested action.</p>
- *             </li>
- *             <li>
- *                <p>The requested resource.</p>
- *             </li>
- *             <li>
- *                <p>The values of condition keys in the context of the user's request.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { STSClient, DecodeAuthorizationMessageCommand } from "@aws-sdk/client-sts"; // ES Modules import
- * // const { STSClient, DecodeAuthorizationMessageCommand } = require("@aws-sdk/client-sts"); // CommonJS import
- * const client = new STSClient(config);
- * const command = new DecodeAuthorizationMessageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DecodeAuthorizationMessageCommandInput} for command's `input` shape.
- * @see {@link DecodeAuthorizationMessageCommandOutput} for command's `response` shape.
- * @see {@link STSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-var DecodeAuthorizationMessageCommand = /** @class */ (function (_super) {
-    __extends(DecodeAuthorizationMessageCommand, _super);
-    // Start section: command_properties
-    // End section: command_properties
-    function DecodeAuthorizationMessageCommand(input) {
-        var _this = 
-        // Start section: command_constructor
-        _super.call(this) || this;
-        _this.input = input;
-        return _this;
-        // End section: command_constructor
-    }
-    /**
-     * @internal
-     */
-    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 };
-//# sourceMappingURL=DecodeAuthorizationMessageCommand.js.map

package/dist/es/commands/DecodeAuthorizationMessageCommand.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"DecodeAuthorizationMessageCommand.js","sourceRoot":"","sources":["../../../commands/DecodeAuthorizationMessageCommand.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,iCAAiC,EAAE,kCAAkC,EAAE,MAAM,oBAAoB,CAAC;AAC3G,OAAO,EACL,qDAAqD,EACrD,mDAAmD,GACpD,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAE/D,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAc7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH;IAAuD,qDAItD;IACC,oCAAoC;IACpC,kCAAkC;IAElC,2CAAqB,KAA6C;QAAlE;QACE,qCAAqC;QACrC,iBAAO,SAER;QAJoB,WAAK,GAAL,KAAK,CAAwC;;QAGhE,mCAAmC;IACrC,CAAC;IAED;;OAEG;IACH,6DAAiB,GAAjB,UACE,WAAmE,EACnE,aAAsC,EACtC,OAA8B;QAE9B,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,cAAc,CAAC,aAAa,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;QAC1F,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC,CAAC;QAE1D,IAAM,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAE/C,IAAA,MAAM,GAAK,aAAa,OAAlB,CAAmB;QACjC,IAAM,UAAU,GAAG,WAAW,CAAC;QAC/B,IAAM,WAAW,GAAG,mCAAmC,CAAC;QACxD,IAAM,uBAAuB,GAA4B;YACvD,MAAM,QAAA;YACN,UAAU,YAAA;YACV,WAAW,aAAA;YACX,uBAAuB,EAAE,iCAAiC,CAAC,kBAAkB;YAC7E,wBAAwB,EAAE,kCAAkC,CAAC,kBAAkB;SAChF,CAAC;QACM,IAAA,cAAc,GAAK,aAAa,eAAlB,CAAmB;QACzC,OAAO,KAAK,CAAC,OAAO,CAClB,UAAC,OAAsC;YACrC,OAAA,cAAc,CAAC,MAAM,CAAC,OAAO,CAAC,OAAwB,EAAE,OAAO,IAAI,EAAE,CAAC;QAAtE,CAAsE,EACxE,uBAAuB,CACxB,CAAC;IACJ,CAAC;IAEO,qDAAS,GAAjB,UAAkB,KAA6C,EAAE,OAAuB;QACtF,OAAO,mDAAmD,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAC7E,CAAC;IAEO,uDAAW,GAAnB,UACE,MAAsB,EACtB,OAAuB;QAEvB,OAAO,qDAAqD,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChF,CAAC;IAIH,wCAAC;AAAD,CAAC,AA1DD,CAAuD,QAAQ,GA0D9D"}

package/dist/es/commands/GetAccessKeyInfoCommand.js

@@ -1,84 +0,0 @@
-import { __extends } from "tslib";
-import { GetAccessKeyInfoRequest, GetAccessKeyInfoResponse } from "../models/models_0";
-import { deserializeAws_queryGetAccessKeyInfoCommand, serializeAws_queryGetAccessKeyInfoCommand, } 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 the account identifier for the specified access key ID.</p>
- *         <p>Access keys consist of two parts: an access key ID (for example,
- *                 <code>AKIAIOSFODNN7EXAMPLE</code>) and a secret access key (for example,
- *                 <code>wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY</code>). For more information about
- *             access keys, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html">Managing Access Keys for IAM
- *                 Users</a> in the <i>IAM User Guide</i>.</p>
- *         <p>When you pass an access key ID to this operation, it returns the ID of the Amazon Web Services
- *             account to which the keys belong. Access key IDs beginning with <code>AKIA</code> are
- *             long-term credentials for an IAM user or the Amazon Web Services account root user. Access key IDs
- *             beginning with <code>ASIA</code> are temporary credentials that are created using STS
- *             operations. If the account in the response belongs to you, you can sign in as the root
- *             user and review your root user access keys. Then, you can pull a <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_getting-report.html">credentials report</a> to learn which IAM user owns the keys. To learn who
- *             requested the temporary credentials for an <code>ASIA</code> access key, view the STS
- *             events in your <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/cloudtrail-integration.html">CloudTrail logs</a> in the
- *                 <i>IAM User Guide</i>.</p>
- *         <p>This operation does not indicate the state of the access key. The key might be active,
- *             inactive, or deleted. Active keys might not have permissions to perform an operation.
- *             Providing a deleted access key might return an error that the key doesn't exist.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { STSClient, GetAccessKeyInfoCommand } from "@aws-sdk/client-sts"; // ES Modules import
- * // const { STSClient, GetAccessKeyInfoCommand } = require("@aws-sdk/client-sts"); // CommonJS import
- * const client = new STSClient(config);
- * const command = new GetAccessKeyInfoCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetAccessKeyInfoCommandInput} for command's `input` shape.
- * @see {@link GetAccessKeyInfoCommandOutput} for command's `response` shape.
- * @see {@link STSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-var GetAccessKeyInfoCommand = /** @class */ (function (_super) {
-    __extends(GetAccessKeyInfoCommand, _super);
-    // Start section: command_properties
-    // End section: command_properties
-    function GetAccessKeyInfoCommand(input) {
-        var _this = 
-        // Start section: command_constructor
-        _super.call(this) || this;
-        _this.input = input;
-        return _this;
-        // End section: command_constructor
-    }
-    /**
-     * @internal
-     */
-    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 };
-//# sourceMappingURL=GetAccessKeyInfoCommand.js.map

package/dist/es/commands/GetAccessKeyInfoCommand.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"GetAccessKeyInfoCommand.js","sourceRoot":"","sources":["../../../commands/GetAccessKeyInfoCommand.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AACvF,OAAO,EACL,2CAA2C,EAC3C,yCAAyC,GAC1C,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAE/D,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAc7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH;IAA6C,2CAI5C;IACC,oCAAoC;IACpC,kCAAkC;IAElC,iCAAqB,KAAmC;QAAxD;QACE,qCAAqC;QACrC,iBAAO,SAER;QAJoB,WAAK,GAAL,KAAK,CAA8B;;QAGtD,mCAAmC;IACrC,CAAC;IAED;;OAEG;IACH,mDAAiB,GAAjB,UACE,WAAmE,EACnE,aAAsC,EACtC,OAA8B;QAE9B,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,cAAc,CAAC,aAAa,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;QAC1F,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC,CAAC;QAE1D,IAAM,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAE/C,IAAA,MAAM,GAAK,aAAa,OAAlB,CAAmB;QACjC,IAAM,UAAU,GAAG,WAAW,CAAC;QAC/B,IAAM,WAAW,GAAG,yBAAyB,CAAC;QAC9C,IAAM,uBAAuB,GAA4B;YACvD,MAAM,QAAA;YACN,UAAU,YAAA;YACV,WAAW,aAAA;YACX,uBAAuB,EAAE,uBAAuB,CAAC,kBAAkB;YACnE,wBAAwB,EAAE,wBAAwB,CAAC,kBAAkB;SACtE,CAAC;QACM,IAAA,cAAc,GAAK,aAAa,eAAlB,CAAmB;QACzC,OAAO,KAAK,CAAC,OAAO,CAClB,UAAC,OAAsC;YACrC,OAAA,cAAc,CAAC,MAAM,CAAC,OAAO,CAAC,OAAwB,EAAE,OAAO,IAAI,EAAE,CAAC;QAAtE,CAAsE,EACxE,uBAAuB,CACxB,CAAC;IACJ,CAAC;IAEO,2CAAS,GAAjB,UAAkB,KAAmC,EAAE,OAAuB;QAC5E,OAAO,yCAAyC,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACnE,CAAC;IAEO,6CAAW,GAAnB,UAAoB,MAAsB,EAAE,OAAuB;QACjE,OAAO,2CAA2C,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtE,CAAC;IAIH,8BAAC;AAAD,CAAC,AAvDD,CAA6C,QAAQ,GAuDpD"}

package/dist/es/commands/GetCallerIdentityCommand.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"GetCallerIdentityCommand.js","sourceRoot":"","sources":["../../../commands/GetCallerIdentityCommand.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,wBAAwB,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AACzF,OAAO,EACL,4CAA4C,EAC5C,0CAA0C,GAC3C,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAE/D,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAc7D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IAA8C,4CAI7C;IACC,oCAAoC;IACpC,kCAAkC;IAElC,kCAAqB,KAAoC;QAAzD;QACE,qCAAqC;QACrC,iBAAO,SAER;QAJoB,WAAK,GAAL,KAAK,CAA+B;;QAGvD,mCAAmC;IACrC,CAAC;IAED;;OAEG;IACH,oDAAiB,GAAjB,UACE,WAAmE,EACnE,aAAsC,EACtC,OAA8B;QAE9B,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,cAAc,CAAC,aAAa,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;QAC1F,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC,CAAC;QAE1D,IAAM,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAE/C,IAAA,MAAM,GAAK,aAAa,OAAlB,CAAmB;QACjC,IAAM,UAAU,GAAG,WAAW,CAAC;QAC/B,IAAM,WAAW,GAAG,0BAA0B,CAAC;QAC/C,IAAM,uBAAuB,GAA4B;YACvD,MAAM,QAAA;YACN,UAAU,YAAA;YACV,WAAW,aAAA;YACX,uBAAuB,EAAE,wBAAwB,CAAC,kBAAkB;YACpE,wBAAwB,EAAE,yBAAyB,CAAC,kBAAkB;SACvE,CAAC;QACM,IAAA,cAAc,GAAK,aAAa,eAAlB,CAAmB;QACzC,OAAO,KAAK,CAAC,OAAO,CAClB,UAAC,OAAsC;YACrC,OAAA,cAAc,CAAC,MAAM,CAAC,OAAO,CAAC,OAAwB,EAAE,OAAO,IAAI,EAAE,CAAC;QAAtE,CAAsE,EACxE,uBAAuB,CACxB,CAAC;IACJ,CAAC;IAEO,4CAAS,GAAjB,UAAkB,KAAoC,EAAE,OAAuB;QAC7E,OAAO,0CAA0C,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACpE,CAAC;IAEO,8CAAW,GAAnB,UAAoB,MAAsB,EAAE,OAAuB;QACjE,OAAO,4CAA4C,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACvE,CAAC;IAIH,+BAAC;AAAD,CAAC,AAvDD,CAA8C,QAAQ,GAuDrD"}

package/dist/es/commands/GetFederationTokenCommand.js

@@ -1,205 +0,0 @@
-import { __extends } from "tslib";
-import { GetFederationTokenRequest, GetFederationTokenResponse } from "../models/models_0";
-import { deserializeAws_queryGetFederationTokenCommand, serializeAws_queryGetFederationTokenCommand, } 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 a set of temporary security credentials (consisting of an access key ID, a
- *          secret access key, and a security token) for a federated user. A typical use is in a proxy
- *          application that gets temporary security credentials on behalf of distributed applications
- *          inside a corporate network. You must call the <code>GetFederationToken</code> operation
- *          using the long-term security credentials of an IAM user. As a result, this call is
- *          appropriate in contexts where those credentials can be safely stored, usually in a
- *          server-based application. For a comparison of <code>GetFederationToken</code> with the
- *          other API operations that produce temporary credentials, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html">Requesting Temporary Security
- *             Credentials</a> and <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#stsapi_comparison">Comparing the
- *             STS API operations</a> in the <i>IAM User Guide</i>.</p>
- *          <note>
- *             <p>You can create a mobile-based or browser-based app that can authenticate users using
- *             a web identity provider like Login with Amazon, Facebook, Google, or an OpenID
- *             Connect-compatible identity provider. In this case, we recommend that you use <a href="http://aws.amazon.com/cognito/">Amazon Cognito</a> or
- *                <code>AssumeRoleWithWebIdentity</code>. For more information, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#api_assumerolewithwebidentity">Federation Through a Web-based Identity Provider</a> in the
- *                <i>IAM User Guide</i>.</p>
- *          </note>
- *          <p>You can also call <code>GetFederationToken</code> using the security credentials of an
- *          Amazon Web Services account root user, but we do not recommend it. Instead, we recommend that you create
- *          an IAM user for the purpose of the proxy application. Then attach a policy to the IAM
- *          user that limits federated users to only the actions and resources that they need to
- *          access. For more information, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html">IAM Best Practices</a> in the
- *             <i>IAM User Guide</i>. </p>
- *          <p>
- *             <b>Session duration</b>
- *          </p>
- *          <p>The temporary credentials are valid for the specified duration, from 900 seconds (15
- *          minutes) up to a maximum of 129,600 seconds (36 hours). The default session duration is
- *          43,200 seconds (12 hours). Temporary credentials that are obtained by using Amazon Web Services account
- *          root user credentials have a maximum duration of 3,600 seconds (1 hour).</p>
- *          <p>
- *             <b>Permissions</b>
- *          </p>
- *          <p>You can use the temporary credentials created by <code>GetFederationToken</code> in any
- *          Amazon Web Services service except the following:</p>
- *          <ul>
- *             <li>
- *                <p>You cannot call any IAM operations using the CLI or the Amazon Web Services API. </p>
- *             </li>
- *             <li>
- *                <p>You cannot call any STS operations except <code>GetCallerIdentity</code>.</p>
- *             </li>
- *          </ul>
- *          <p>You must pass an inline or managed <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session">session policy</a> to
- *          this operation. You can pass a single JSON policy document to use as an inline session
- *          policy. You can also specify up to 10 managed policies to use as managed session policies.
- *          The plaintext that you use for both inline and managed session policies can't exceed 2,048
- *          characters.</p>
- *          <p>Though the session policy parameters are optional, if you do not pass a policy, then the
- *          resulting federated user session has no permissions. When you pass session policies, the
- *          session permissions are the intersection of the IAM user policies and the session
- *          policies that you pass. This gives you a way to further restrict the permissions for a
- *          federated user. You cannot use session policies to grant more permissions than those that
- *          are defined in the permissions policy of the IAM user. For more information, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session">Session
- *             Policies</a> in the <i>IAM User Guide</i>. For information about
- *          using <code>GetFederationToken</code> to create temporary security credentials, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#api_getfederationtoken">GetFederationToken—Federation Through a Custom Identity Broker</a>. </p>
- *          <p>You can use the credentials to access a resource that has a resource-based policy. If
- *          that policy specifically references the federated user session in the
- *             <code>Principal</code> element of the policy, the session has the permissions allowed by
- *          the policy. These permissions are granted in addition to the permissions granted by the
- *          session policies.</p>
- *          <p>
- *             <b>Tags</b>
- *          </p>
- *          <p>(Optional) You can pass tag key-value pairs to your session. These are called session
- *          tags. For more information about session tags, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_session-tags.html">Passing Session Tags in STS</a> in the
- *             <i>IAM User Guide</i>.</p>
- *         <note>
- *             <p>You can create a mobile-based or browser-based app that can authenticate users
- *                 using a web identity provider like Login with Amazon, Facebook, Google, or an OpenID
- *                 Connect-compatible identity provider. In this case, we recommend that you use <a href="http://aws.amazon.com/cognito/">Amazon Cognito</a> or
- *                     <code>AssumeRoleWithWebIdentity</code>. For more information, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#api_assumerolewithwebidentity">Federation Through a Web-based Identity Provider</a> in the
- *                     <i>IAM User Guide</i>.</p>
- *         </note>
- *         <p>You can also call <code>GetFederationToken</code> using the security credentials of an
- *             Amazon Web Services account root user, but we do not recommend it. Instead, we recommend that you
- *             create an IAM user for the purpose of the proxy application. Then attach a policy to
- *             the IAM user that limits federated users to only the actions and resources that they
- *             need to access. For more information, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html">IAM Best Practices</a> in the
- *                 <i>IAM User Guide</i>. </p>
- *         <p>
- *             <b>Session duration</b>
- *          </p>
- *         <p>The temporary credentials are valid for the specified duration, from 900 seconds (15
- *             minutes) up to a maximum of 129,600 seconds (36 hours). The default session duration is
- *             43,200 seconds (12 hours). Temporary credentials that are obtained by using Amazon Web Services
- *             account root user credentials have a maximum duration of 3,600 seconds (1 hour).</p>
- *         <p>
- *             <b>Permissions</b>
- *         </p>
- *         <p>You can use the temporary credentials created by <code>GetFederationToken</code> in
- *             any Amazon Web Services service except the following:</p>
- *         <ul>
- *             <li>
- *                 <p>You cannot call any IAM operations using the CLI or the Amazon Web Services API.
- *                 </p>
- *             </li>
- *             <li>
- *                 <p>You cannot call any STS operations except
- *                     <code>GetCallerIdentity</code>.</p>
- *             </li>
- *          </ul>
- *         <p>You must pass an inline or managed <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session">session policy</a> to
- *             this operation. You can pass a single JSON policy document to use as an inline session
- *             policy. You can also specify up to 10 managed policies to use as managed session
- *             policies. The plain text that you use for both inline and managed session policies can't
- *             exceed 2,048 characters.</p>
- *         <p>Though the session policy parameters are optional, if you do not pass a policy, then
- *             the resulting federated user session has no permissions. When you pass session policies,
- *             the session permissions are the intersection of the IAM user policies and the session
- *             policies that you pass. This gives you a way to further restrict the permissions for a
- *             federated user. You cannot use session policies to grant more permissions than those
- *             that are defined in the permissions policy of the IAM user. For more information, see
- *                 <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session">Session Policies</a>
- *             in the <i>IAM User Guide</i>. For information about using
- *                 <code>GetFederationToken</code> to create temporary security credentials, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#api_getfederationtoken">GetFederationToken—Federation Through a Custom Identity Broker</a>. </p>
- *         <p>You can use the credentials to access a resource that has a resource-based policy. If
- *             that policy specifically references the federated user session in the
- *                 <code>Principal</code> element of the policy, the session has the permissions
- *             allowed by the policy. These permissions are granted in addition to the permissions
- *             granted by the session policies.</p>
- *         <p>
- *             <b>Tags</b>
- *          </p>
- *         <p>(Optional) You can pass tag key-value pairs to your session. These are called session
- *             tags. For more information about session tags, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_session-tags.html">Passing Session Tags in STS</a> in
- *             the <i>IAM User Guide</i>.</p>
- *         <p>An administrator must grant you the permissions necessary to pass session tags. The
- *             administrator can also create granular permissions to allow you to pass only specific
- *             session tags. For more information, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_attribute-based-access-control.html">Tutorial: Using
- *                 Tags for Attribute-Based Access Control</a> in the
- *                 <i>IAM User Guide</i>.</p>
- *         <p>Tag key–value pairs are not case sensitive, but case is preserved. This means that you
- *             cannot have separate <code>Department</code> and <code>department</code> tag keys.
- *             Assume that the user that you are federating has the
- *                 <code>Department</code>=<code>Marketing</code> tag and you pass the
- *                 <code>department</code>=<code>engineering</code> session tag.
- *                 <code>Department</code> and <code>department</code> are not saved as separate tags,
- *             and the session tag passed in the request takes precedence over the user tag.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { STSClient, GetFederationTokenCommand } from "@aws-sdk/client-sts"; // ES Modules import
- * // const { STSClient, GetFederationTokenCommand } = require("@aws-sdk/client-sts"); // CommonJS import
- * const client = new STSClient(config);
- * const command = new GetFederationTokenCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetFederationTokenCommandInput} for command's `input` shape.
- * @see {@link GetFederationTokenCommandOutput} for command's `response` shape.
- * @see {@link STSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-var GetFederationTokenCommand = /** @class */ (function (_super) {
-    __extends(GetFederationTokenCommand, _super);
-    // Start section: command_properties
-    // End section: command_properties
-    function GetFederationTokenCommand(input) {
-        var _this = 
-        // Start section: command_constructor
-        _super.call(this) || this;
-        _this.input = input;
-        return _this;
-        // End section: command_constructor
-    }
-    /**
-     * @internal
-     */
-    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 };
-//# sourceMappingURL=GetFederationTokenCommand.js.map

package/dist/es/commands/GetFederationTokenCommand.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"GetFederationTokenCommand.js","sourceRoot":"","sources":["../../../commands/GetFederationTokenCommand.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,yBAAyB,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AAC3F,OAAO,EACL,6CAA6C,EAC7C,2CAA2C,GAC5C,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAE/D,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAc7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0JG;AACH;IAA+C,6CAI9C;IACC,oCAAoC;IACpC,kCAAkC;IAElC,mCAAqB,KAAqC;QAA1D;QACE,qCAAqC;QACrC,iBAAO,SAER;QAJoB,WAAK,GAAL,KAAK,CAAgC;;QAGxD,mCAAmC;IACrC,CAAC;IAED;;OAEG;IACH,qDAAiB,GAAjB,UACE,WAAmE,EACnE,aAAsC,EACtC,OAA8B;QAE9B,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,cAAc,CAAC,aAAa,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;QAC1F,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC,CAAC;QAE1D,IAAM,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAE/C,IAAA,MAAM,GAAK,aAAa,OAAlB,CAAmB;QACjC,IAAM,UAAU,GAAG,WAAW,CAAC;QAC/B,IAAM,WAAW,GAAG,2BAA2B,CAAC;QAChD,IAAM,uBAAuB,GAA4B;YACvD,MAAM,QAAA;YACN,UAAU,YAAA;YACV,WAAW,aAAA;YACX,uBAAuB,EAAE,yBAAyB,CAAC,kBAAkB;YACrE,wBAAwB,EAAE,0BAA0B,CAAC,kBAAkB;SACxE,CAAC;QACM,IAAA,cAAc,GAAK,aAAa,eAAlB,CAAmB;QACzC,OAAO,KAAK,CAAC,OAAO,CAClB,UAAC,OAAsC;YACrC,OAAA,cAAc,CAAC,MAAM,CAAC,OAAO,CAAC,OAAwB,EAAE,OAAO,IAAI,EAAE,CAAC;QAAtE,CAAsE,EACxE,uBAAuB,CACxB,CAAC;IACJ,CAAC;IAEO,6CAAS,GAAjB,UAAkB,KAAqC,EAAE,OAAuB;QAC9E,OAAO,2CAA2C,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACrE,CAAC;IAEO,+CAAW,GAAnB,UAAoB,MAAsB,EAAE,OAAuB;QACjE,OAAO,6CAA6C,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACxE,CAAC;IAIH,gCAAC;AAAD,CAAC,AAvDD,CAA+C,QAAQ,GAuDtD"}

package/dist/es/commands/GetSessionTokenCommand.js

@@ -1,118 +0,0 @@
-import { __extends } from "tslib";
-import { GetSessionTokenRequest, GetSessionTokenResponse } from "../models/models_0";
-import { deserializeAws_queryGetSessionTokenCommand, serializeAws_queryGetSessionTokenCommand, } 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 a set of temporary credentials for an Amazon Web Services account or IAM user. The
- *          credentials consist of an access key ID, a secret access key, and a security token.
- *          Typically, you use <code>GetSessionToken</code> if you want to use MFA to protect
- *          programmatic calls to specific Amazon Web Services API operations like Amazon EC2 <code>StopInstances</code>.
- *          MFA-enabled IAM users would need to call <code>GetSessionToken</code> and submit an MFA
- *          code that is associated with their MFA device. Using the temporary security credentials
- *          that are returned from the call, IAM users can then make programmatic calls to API
- *          operations that require MFA authentication. If you do not supply a correct MFA code, then
- *          the API returns an access denied error. For a comparison of <code>GetSessionToken</code>
- *          with the other API operations that produce temporary credentials, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html">Requesting
- *             Temporary Security Credentials</a> and <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#stsapi_comparison">Comparing the
- *             STS API operations</a> in the <i>IAM User Guide</i>.</p>
- *          <p>
- *             <b>Session Duration</b>
- *          </p>
- *          <p>The <code>GetSessionToken</code> operation must be called by using the long-term Amazon Web Services
- *          security credentials of the Amazon Web Services account root user or an IAM user. Credentials that are
- *          created by IAM users are valid for the duration that you specify. This duration can range
- *          from 900 seconds (15 minutes) up to a maximum of 129,600 seconds (36 hours), with a default
- *          of 43,200 seconds (12 hours). Credentials based on account credentials can range from 900
- *          seconds (15 minutes) up to 3,600 seconds (1 hour), with a default of 1 hour. </p>
- *          <p>
- *             <b>Permissions</b>
- *          </p>
- *          <p>The temporary security credentials created by <code>GetSessionToken</code> can be used
- *          to make API calls to any Amazon Web Services service with the following exceptions:</p>
- *          <ul>
- *             <li>
- *                <p>You cannot call any IAM API operations unless MFA authentication information is
- *                included in the request.</p>
- *             </li>
- *             <li>
- *                <p>You cannot call any STS API <i>except</i>
- *                   <code>AssumeRole</code> or <code>GetCallerIdentity</code>.</p>
- *             </li>
- *          </ul>
- *          <note>
- *             <p>We recommend that you do not call <code>GetSessionToken</code> with Amazon Web Services account
- *             root user credentials. Instead, follow our <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#create-iam-users">best practices</a> by
- *             creating one or more IAM users, giving them the necessary permissions, and using IAM
- *             users for everyday interaction with Amazon Web Services. </p>
- *          </note>
- *          <p>The credentials that are returned by <code>GetSessionToken</code> are based on
- *          permissions associated with the user whose credentials were used to call the operation. If
- *             <code>GetSessionToken</code> is called using Amazon Web Services account root user credentials, the
- *          temporary credentials have root user permissions. Similarly, if
- *             <code>GetSessionToken</code> is called using the credentials of an IAM user, the
- *          temporary credentials have the same permissions as the IAM user. </p>
- *          <p>For more information about using <code>GetSessionToken</code> to create temporary
- *          credentials, go to <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#api_getsessiontoken">Temporary
- *             Credentials for Users in Untrusted Environments</a> in the
- *             <i>IAM User Guide</i>. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { STSClient, GetSessionTokenCommand } from "@aws-sdk/client-sts"; // ES Modules import
- * // const { STSClient, GetSessionTokenCommand } = require("@aws-sdk/client-sts"); // CommonJS import
- * const client = new STSClient(config);
- * const command = new GetSessionTokenCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetSessionTokenCommandInput} for command's `input` shape.
- * @see {@link GetSessionTokenCommandOutput} for command's `response` shape.
- * @see {@link STSClientResolvedConfig | config} for command's `input` shape.
- *
- */
-var GetSessionTokenCommand = /** @class */ (function (_super) {
-    __extends(GetSessionTokenCommand, _super);
-    // Start section: command_properties
-    // End section: command_properties
-    function GetSessionTokenCommand(input) {
-        var _this = 
-        // Start section: command_constructor
-        _super.call(this) || this;
-        _this.input = input;
-        return _this;
-        // End section: command_constructor
-    }
-    /**
-     * @internal
-     */
-    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 };
-//# sourceMappingURL=GetSessionTokenCommand.js.map

package/dist/es/commands/GetSessionTokenCommand.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"GetSessionTokenCommand.js","sourceRoot":"","sources":["../../../commands/GetSessionTokenCommand.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AACrF,OAAO,EACL,0CAA0C,EAC1C,wCAAwC,GACzC,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAE/D,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAc7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH;IAA4C,0CAI3C;IACC,oCAAoC;IACpC,kCAAkC;IAElC,gCAAqB,KAAkC;QAAvD;QACE,qCAAqC;QACrC,iBAAO,SAER;QAJoB,WAAK,GAAL,KAAK,CAA6B;;QAGrD,mCAAmC;IACrC,CAAC;IAED;;OAEG;IACH,kDAAiB,GAAjB,UACE,WAAmE,EACnE,aAAsC,EACtC,OAA8B;QAE9B,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,cAAc,CAAC,aAAa,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;QAC1F,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC,CAAC;QAE1D,IAAM,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAE/C,IAAA,MAAM,GAAK,aAAa,OAAlB,CAAmB;QACjC,IAAM,UAAU,GAAG,WAAW,CAAC;QAC/B,IAAM,WAAW,GAAG,wBAAwB,CAAC;QAC7C,IAAM,uBAAuB,GAA4B;YACvD,MAAM,QAAA;YACN,UAAU,YAAA;YACV,WAAW,aAAA;YACX,uBAAuB,EAAE,sBAAsB,CAAC,kBAAkB;YAClE,wBAAwB,EAAE,uBAAuB,CAAC,kBAAkB;SACrE,CAAC;QACM,IAAA,cAAc,GAAK,aAAa,eAAlB,CAAmB;QACzC,OAAO,KAAK,CAAC,OAAO,CAClB,UAAC,OAAsC;YACrC,OAAA,cAAc,CAAC,MAAM,CAAC,OAAO,CAAC,OAAwB,EAAE,OAAO,IAAI,EAAE,CAAC;QAAtE,CAAsE,EACxE,uBAAuB,CACxB,CAAC;IACJ,CAAC;IAEO,0CAAS,GAAjB,UAAkB,KAAkC,EAAE,OAAuB;QAC3E,OAAO,wCAAwC,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAClE,CAAC;IAEO,4CAAW,GAAnB,UAAoB,MAAsB,EAAE,OAAuB;QACjE,OAAO,0CAA0C,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrE,CAAC;IAIH,6BAAC;AAAD,CAAC,AAvDD,CAA4C,QAAQ,GAuDnD"}

package/dist/es/defaultRoleAssumers.js

@@ -1,33 +0,0 @@
-import { __assign } from "tslib";
-// Please do not touch this file. It's generated from template in:
-// https://github.com/aws/aws-sdk-js-v3/blob/main/codegen/smithy-aws-typescript-codegen/src/main/resources/software/amazon/smithy/aws/typescript/codegen/sts-client-defaultRoleAssumers.ts
-import { getDefaultRoleAssumer as StsGetDefaultRoleAssumer, getDefaultRoleAssumerWithWebIdentity as StsGetDefaultRoleAssumerWithWebIdentity, } from "./defaultStsRoleAssumers";
-import { STSClient } from "./STSClient";
-/**
- * The default role assumer that used by credential providers when sts:AssumeRole API is needed.
- */
-export var getDefaultRoleAssumer = function (stsOptions) {
-    if (stsOptions === void 0) { stsOptions = {}; }
-    return StsGetDefaultRoleAssumer(stsOptions, STSClient);
-};
-/**
- * The default role assumer that used by credential providers when sts:AssumeRoleWithWebIdentity API is needed.
- */
-export var getDefaultRoleAssumerWithWebIdentity = function (stsOptions) {
-    if (stsOptions === void 0) { stsOptions = {}; }
-    return StsGetDefaultRoleAssumerWithWebIdentity(stsOptions, STSClient);
-};
-/**
- * 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), roleAssumerWithWebIdentity: getDefaultRoleAssumerWithWebIdentity(input) }, input));
-    };
-};
-//# sourceMappingURL=defaultRoleAssumers.js.map

package/dist/es/defaultRoleAssumers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"defaultRoleAssumers.js","sourceRoot":"","sources":["../../defaultRoleAssumers.ts"],"names":[],"mappings":";AAAA,kEAAkE;AAClE,0LAA0L;AAC1L,OAAO,EAEL,qBAAqB,IAAI,wBAAwB,EACjD,oCAAoC,IAAI,uCAAuC,GAGhF,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,SAAS,EAAmB,MAAM,aAAa,CAAC;AAEzD;;GAEG;AACH,MAAM,CAAC,IAAM,qBAAqB,GAAG,UACnC,UAA8E;IAA9E,2BAAA,EAAA,eAA8E;IAC9D,OAAA,wBAAwB,CAAC,UAAU,EAAE,SAAS,CAAC;AAA/C,CAA+C,CAAC;AAElE;;GAEG;AACH,MAAM,CAAC,IAAM,oCAAoC,GAAG,UAClD,UAA8E;IAA9E,2BAAA,EAAA,eAA8E;IAC/C,OAAA,uCAAuC,CAAC,UAAU,EAAE,SAAS,CAAC;AAA9D,CAA8D,CAAC;AAEhG;;;;;;;GAOG;AACH,MAAM,CAAC,IAAM,iCAAiC,GAC5C,UAAC,QAAmC;IACpC,OAAA,UAAC,KAAU;QACT,OAAA,QAAQ,YACN,WAAW,EAAE,qBAAqB,CAAC,KAAK,CAAC,EACzC,0BAA0B,EAAE,oCAAoC,CAAC,KAAK,CAAC,IACpE,KAAK,EACR;IAJF,CAIE;AALJ,CAKI,CAAC"}