@aws-sdk/client-sts 3.183.0 → 3.186.0

package/dist-es/commands/GetFederationTokenCommand.js

@@ -1,34 +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 { GetFederationTokenRequestFilterSensitiveLog, GetFederationTokenResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryGetFederationTokenCommand, serializeAws_queryGetFederationTokenCommand, } from "../protocols/Aws_query";
-export class GetFederationTokenCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetFederationTokenCommand = (function (_super) {
+    __extends(GetFederationTokenCommand, _super);
+    function GetFederationTokenCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetFederationTokenCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getAwsAuthPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "STSClient";
-        const commandName = "GetFederationTokenCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: GetFederationTokenRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetFederationTokenResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetFederationTokenCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryGetFederationTokenCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetFederationTokenCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryGetFederationTokenCommand(output, context);
-    }
-}
+    };
+    return GetFederationTokenCommand;
+}($Command));
+export { GetFederationTokenCommand };

package/dist-es/commands/GetSessionTokenCommand.js

@@ -1,34 +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 { GetSessionTokenRequestFilterSensitiveLog, GetSessionTokenResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryGetSessionTokenCommand, serializeAws_queryGetSessionTokenCommand, } from "../protocols/Aws_query";
-export class GetSessionTokenCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetSessionTokenCommand = (function (_super) {
+    __extends(GetSessionTokenCommand, _super);
+    function GetSessionTokenCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetSessionTokenCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getAwsAuthPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "STSClient";
-        const commandName = "GetSessionTokenCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: GetSessionTokenRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetSessionTokenResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetSessionTokenCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryGetSessionTokenCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetSessionTokenCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryGetSessionTokenCommand(output, context);
-    }
-}
+    };
+    return GetSessionTokenCommand;
+}($Command));
+export { GetSessionTokenCommand };

package/dist-es/defaultRoleAssumers.js

@@ -1,22 +1,43 @@
+import { __assign, __extends, __values } from "tslib";
 import { getDefaultRoleAssumer as StsGetDefaultRoleAssumer, getDefaultRoleAssumerWithWebIdentity as StsGetDefaultRoleAssumerWithWebIdentity, } from "./defaultStsRoleAssumers";
 import { STSClient } from "./STSClient";
-const getCustomizableStsClientCtor = (baseCtor, customizations) => {
+var getCustomizableStsClientCtor = function (baseCtor, customizations) {
     if (!customizations)
         return baseCtor;
     else
-        return class CustomizableSTSClient extends baseCtor {
-            constructor(config) {
-                super(config);
-                for (const customization of customizations) {
-                    this.middlewareStack.use(customization);
+        return (function (_super) {
+            __extends(CustomizableSTSClient, _super);
+            function CustomizableSTSClient(config) {
+                var e_1, _a;
+                var _this = _super.call(this, config) || this;
+                try {
+                    for (var _b = __values(customizations), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var customization = _c.value;
+                        _this.middlewareStack.use(customization);
+                    }
                 }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                return _this;
             }
-        };
+            return CustomizableSTSClient;
+        }(baseCtor));
+};
+export var getDefaultRoleAssumer = function (stsOptions, stsPlugins) {
+    if (stsOptions === void 0) { stsOptions = {}; }
+    return StsGetDefaultRoleAssumer(stsOptions, getCustomizableStsClientCtor(STSClient, stsPlugins));
+};
+export var getDefaultRoleAssumerWithWebIdentity = function (stsOptions, stsPlugins) {
+    if (stsOptions === void 0) { stsOptions = {}; }
+    return StsGetDefaultRoleAssumerWithWebIdentity(stsOptions, getCustomizableStsClientCtor(STSClient, stsPlugins));
+};
+export var decorateDefaultCredentialProvider = function (provider) {
+    return function (input) {
+        return provider(__assign({ roleAssumer: getDefaultRoleAssumer(input), roleAssumerWithWebIdentity: getDefaultRoleAssumerWithWebIdentity(input) }, input));
+    };
 };
-export const getDefaultRoleAssumer = (stsOptions = {}, stsPlugins) => StsGetDefaultRoleAssumer(stsOptions, getCustomizableStsClientCtor(STSClient, stsPlugins));
-export const getDefaultRoleAssumerWithWebIdentity = (stsOptions = {}, stsPlugins) => StsGetDefaultRoleAssumerWithWebIdentity(stsOptions, getCustomizableStsClientCtor(STSClient, stsPlugins));
-export const decorateDefaultCredentialProvider = (provider) => (input) => provider({
-    roleAssumer: getDefaultRoleAssumer(input),
-    roleAssumerWithWebIdentity: getDefaultRoleAssumerWithWebIdentity(input),
-    ...input,
-});

package/dist-es/defaultStsRoleAssumers.js

@@ -1,70 +1,87 @@
+import { __assign, __awaiter, __generator } from "tslib";
 import { AssumeRoleCommand } from "./commands/AssumeRoleCommand";
 import { AssumeRoleWithWebIdentityCommand, } from "./commands/AssumeRoleWithWebIdentityCommand";
-const ASSUME_ROLE_DEFAULT_REGION = "us-east-1";
-const decorateDefaultRegion = (region) => {
+var ASSUME_ROLE_DEFAULT_REGION = "us-east-1";
+var decorateDefaultRegion = function (region) {
     if (typeof region !== "function") {
         return region === undefined ? ASSUME_ROLE_DEFAULT_REGION : region;
     }
-    return async () => {
-        try {
-            return await region();
-        }
-        catch (e) {
-            return ASSUME_ROLE_DEFAULT_REGION;
-        }
-    };
+    return function () { return __awaiter(void 0, void 0, void 0, function () {
+        var e_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4, region()];
+                case 1: return [2, _a.sent()];
+                case 2:
+                    e_1 = _a.sent();
+                    return [2, ASSUME_ROLE_DEFAULT_REGION];
+                case 3: return [2];
+            }
+        });
+    }); };
 };
-export const getDefaultRoleAssumer = (stsOptions, stsClientCtor) => {
-    let stsClient;
-    let closureSourceCreds;
-    return async (sourceCreds, params) => {
-        closureSourceCreds = sourceCreds;
-        if (!stsClient) {
-            const { logger, region, requestHandler } = stsOptions;
-            stsClient = new stsClientCtor({
-                logger,
-                credentialDefaultProvider: () => async () => closureSourceCreds,
-                region: decorateDefaultRegion(region || stsOptions.region),
-                ...(requestHandler ? { requestHandler } : {}),
-            });
-        }
-        const { Credentials } = await stsClient.send(new AssumeRoleCommand(params));
-        if (!Credentials || !Credentials.AccessKeyId || !Credentials.SecretAccessKey) {
-            throw new Error(`Invalid response from STS.assumeRole call with role ${params.RoleArn}`);
-        }
-        return {
-            accessKeyId: Credentials.AccessKeyId,
-            secretAccessKey: Credentials.SecretAccessKey,
-            sessionToken: Credentials.SessionToken,
-            expiration: Credentials.Expiration,
-        };
-    };
+export var getDefaultRoleAssumer = function (stsOptions, stsClientCtor) {
+    var stsClient;
+    var closureSourceCreds;
+    return function (sourceCreds, params) { return __awaiter(void 0, void 0, void 0, function () {
+        var logger, region, requestHandler, Credentials;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    closureSourceCreds = sourceCreds;
+                    if (!stsClient) {
+                        logger = stsOptions.logger, region = stsOptions.region, requestHandler = stsOptions.requestHandler;
+                        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, 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 ".concat(params.RoleArn));
+                    }
+                    return [2, {
+                            accessKeyId: Credentials.AccessKeyId,
+                            secretAccessKey: Credentials.SecretAccessKey,
+                            sessionToken: Credentials.SessionToken,
+                            expiration: Credentials.Expiration,
+                        }];
+            }
+        });
+    }); };
+};
+export var getDefaultRoleAssumerWithWebIdentity = function (stsOptions, stsClientCtor) {
+    var stsClient;
+    return function (params) { return __awaiter(void 0, void 0, void 0, function () {
+        var logger, region, requestHandler, Credentials;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!stsClient) {
+                        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, 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 ".concat(params.RoleArn));
+                    }
+                    return [2, {
+                            accessKeyId: Credentials.AccessKeyId,
+                            secretAccessKey: Credentials.SecretAccessKey,
+                            sessionToken: Credentials.SessionToken,
+                            expiration: Credentials.Expiration,
+                        }];
+            }
+        });
+    }); };
 };
-export const getDefaultRoleAssumerWithWebIdentity = (stsOptions, stsClientCtor) => {
-    let stsClient;
-    return async (params) => {
-        if (!stsClient) {
-            const { logger, region, requestHandler } = stsOptions;
-            stsClient = new stsClientCtor({
-                logger,
-                region: decorateDefaultRegion(region || stsOptions.region),
-                ...(requestHandler ? { requestHandler } : {}),
-            });
-        }
-        const { Credentials } = await stsClient.send(new AssumeRoleWithWebIdentityCommand(params));
-        if (!Credentials || !Credentials.AccessKeyId || !Credentials.SecretAccessKey) {
-            throw new Error(`Invalid response from STS.assumeRoleWithWebIdentity call with role ${params.RoleArn}`);
-        }
-        return {
-            accessKeyId: Credentials.AccessKeyId,
-            secretAccessKey: Credentials.SecretAccessKey,
-            sessionToken: Credentials.SessionToken,
-            expiration: Credentials.Expiration,
-        };
+export var decorateDefaultCredentialProvider = function (provider) {
+    return function (input) {
+        return provider(__assign({ roleAssumer: getDefaultRoleAssumer(input, input.stsClientCtor), roleAssumerWithWebIdentity: getDefaultRoleAssumerWithWebIdentity(input, input.stsClientCtor) }, input));
     };
 };
-export const decorateDefaultCredentialProvider = (provider) => (input) => provider({
-    roleAssumer: getDefaultRoleAssumer(input, input.stsClientCtor),
-    roleAssumerWithWebIdentity: getDefaultRoleAssumerWithWebIdentity(input, input.stsClientCtor),
-    ...input,
-});

package/dist-es/endpoints.js

@@ -1,5 +1,6 @@
+import { __assign, __awaiter, __generator } from "tslib";
 import { getRegionInfo } from "@aws-sdk/config-resolver";
-const regionHash = {
+var regionHash = {
     "aws-global": {
         variants: [
             {
@@ -58,7 +59,7 @@ const regionHash = {
         ],
     },
 };
-const partitionHash = {
+var partitionHash = {
     aws: {
         regions: [
             "af-south-1",
@@ -183,9 +184,8 @@ const partitionHash = {
         ],
     },
 };
-export const defaultRegionInfoProvider = async (region, options) => getRegionInfo(region, {
-    ...options,
-    signingService: "sts",
-    regionHash,
-    partitionHash,
-});
+export var defaultRegionInfoProvider = function (region, options) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2, getRegionInfo(region, __assign(__assign({}, options), { signingService: "sts", regionHash: regionHash, partitionHash: partitionHash }))];
+    });
+}); };

package/dist-es/models/STSServiceException.js

@@ -1,7 +1,12 @@
+import { __extends } from "tslib";
 import { ServiceException as __ServiceException, } from "@aws-sdk/smithy-client";
-export class STSServiceException extends __ServiceException {
-    constructor(options) {
-        super(options);
-        Object.setPrototypeOf(this, STSServiceException.prototype);
+var STSServiceException = (function (_super) {
+    __extends(STSServiceException, _super);
+    function STSServiceException(options) {
+        var _this = _super.call(this, options) || this;
+        Object.setPrototypeOf(_this, STSServiceException.prototype);
+        return _this;
     }
-}
+    return STSServiceException;
+}(__ServiceException));
+export { STSServiceException };