@aws-sdk/client-sts 3.185.0 → 3.188.0

package/dist-es/commands/GetCallerIdentityCommand.js

@@ -1,41 +1,34 @@
-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 { GetCallerIdentityRequestFilterSensitiveLog, GetCallerIdentityResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryGetCallerIdentityCommand, serializeAws_queryGetCallerIdentityCommand, } from "../protocols/Aws_query";
-var GetCallerIdentityCommand = (function (_super) {
-    __extends(GetCallerIdentityCommand, _super);
-    function GetCallerIdentityCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetCallerIdentityCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetCallerIdentityCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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 = "GetCallerIdentityCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "STSClient";
+        const commandName = "GetCallerIdentityCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetCallerIdentityRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetCallerIdentityResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetCallerIdentityCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryGetCallerIdentityCommand(input, context);
-    };
-    GetCallerIdentityCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryGetCallerIdentityCommand(output, context);
-    };
-    return GetCallerIdentityCommand;
-}($Command));
-export { GetCallerIdentityCommand };
+    }
+}

package/dist-es/commands/GetFederationTokenCommand.js

@@ -1,41 +1,34 @@
-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";
-var GetFederationTokenCommand = (function (_super) {
-    __extends(GetFederationTokenCommand, _super);
-    function GetFederationTokenCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetFederationTokenCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetFederationTokenCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "STSClient";
+        const commandName = "GetFederationTokenCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetFederationTokenRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetFederationTokenResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetFederationTokenCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryGetFederationTokenCommand(input, context);
-    };
-    GetFederationTokenCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryGetFederationTokenCommand(output, context);
-    };
-    return GetFederationTokenCommand;
-}($Command));
-export { GetFederationTokenCommand };
+    }
+}

package/dist-es/commands/GetSessionTokenCommand.js

@@ -1,41 +1,34 @@
-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";
-var GetSessionTokenCommand = (function (_super) {
-    __extends(GetSessionTokenCommand, _super);
-    function GetSessionTokenCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetSessionTokenCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetSessionTokenCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(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,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "STSClient";
+        const commandName = "GetSessionTokenCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetSessionTokenRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetSessionTokenResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetSessionTokenCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryGetSessionTokenCommand(input, context);
-    };
-    GetSessionTokenCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryGetSessionTokenCommand(output, context);
-    };
-    return GetSessionTokenCommand;
-}($Command));
-export { GetSessionTokenCommand };
+    }
+}

package/dist-es/defaultRoleAssumers.js

@@ -1,43 +1,22 @@
-import { __assign, __extends, __values } from "tslib";
 import { getDefaultRoleAssumer as StsGetDefaultRoleAssumer, getDefaultRoleAssumerWithWebIdentity as StsGetDefaultRoleAssumerWithWebIdentity, } from "./defaultStsRoleAssumers";
 import { STSClient } from "./STSClient";
-var getCustomizableStsClientCtor = function (baseCtor, customizations) {
+const getCustomizableStsClientCtor = (baseCtor, customizations) => {
     if (!customizations)
         return baseCtor;
     else
-        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);
-                    }
+        return class CustomizableSTSClient extends baseCtor {
+            constructor(config) {
+                super(config);
+                for (const customization of customizations) {
+                    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,87 +1,70 @@
-import { __assign, __awaiter, __generator } from "tslib";
 import { AssumeRoleCommand } from "./commands/AssumeRoleCommand";
 import { AssumeRoleWithWebIdentityCommand, } from "./commands/AssumeRoleWithWebIdentityCommand";
-var ASSUME_ROLE_DEFAULT_REGION = "us-east-1";
-var decorateDefaultRegion = function (region) {
+const ASSUME_ROLE_DEFAULT_REGION = "us-east-1";
+const decorateDefaultRegion = (region) => {
     if (typeof region !== "function") {
         return region === undefined ? ASSUME_ROLE_DEFAULT_REGION : 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 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,
-                        }];
-            }
-        });
-    }); };
+    return async () => {
+        try {
+            return await region();
+        }
+        catch (e) {
+            return ASSUME_ROLE_DEFAULT_REGION;
+        }
+    };
 };
-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 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 decorateDefaultCredentialProvider = function (provider) {
-    return function (input) {
-        return provider(__assign({ roleAssumer: getDefaultRoleAssumer(input, input.stsClientCtor), roleAssumerWithWebIdentity: getDefaultRoleAssumerWithWebIdentity(input, input.stsClientCtor) }, input));
+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 const decorateDefaultCredentialProvider = (provider) => (input) => provider({
+    roleAssumer: getDefaultRoleAssumer(input, input.stsClientCtor),
+    roleAssumerWithWebIdentity: getDefaultRoleAssumerWithWebIdentity(input, input.stsClientCtor),
+    ...input,
+});

package/dist-es/endpoints.js

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

package/dist-es/models/STSServiceException.js

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