create-mastra 0.1.0-alpha.23 → 0.1.0-alpha.25

package/dist/loadSso-MEAVww3h.js

@@ -0,0 +1,615 @@
+import { z as toBase64, A as parseUrl, B as fromUtf8, C as toUtf8, G as loadConfig, N as NodeHttpHandler, I as streamCollector, K as expectNonNull, O as expectObject, J as expectString } from './index.js';
+import { d as getSmithyContext, n as normalizeProvider, r as resolveAwsSdkSigV4Config, e as resolveEndpoint, E as EndpointCache, f as customEndpointFunctions, h as awsEndpointFunctions, i as fromBase64, A as AwsSdkSigV4Signer, N as NoAuthSigner, j as NoOpLogger, k as emitWarningIfUnsupportedVersion, l as emitWarningIfUnsupportedVersion$1, m as calculateBodyLength, o as createDefaultUserAgentProvider, p as NODE_MAX_ATTEMPT_CONFIG_OPTIONS, q as NODE_REGION_CONFIG_FILE_OPTIONS, s as NODE_REGION_CONFIG_OPTIONS, t as NODE_RETRY_MODE_CONFIG_OPTIONS, D as DEFAULT_RETRY_MODE, H as Hash, u as NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, v as NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, w as NODE_APP_ID_CONFIG_OPTIONS, x as resolveDefaultsModeConfig, y as loadConfigsForDefaultMode, z as getDefaultExtensionConfiguration, B as getHttpHandlerExtensionConfiguration, F as resolveAwsRegionExtensionConfiguration, G as resolveDefaultRuntimeConfig, I as resolveHttpHandlerRuntimeConfig, J as getAwsRegionExtensionConfiguration, b as Client, K as resolveUserAgentConfig, L as resolveRetryConfig, M as resolveRegionConfig, O as resolveEndpointConfig, P as getUserAgentPlugin, Q as getRetryPlugin, R as getContentLengthPlugin, S as getHostHeaderPlugin, T as getLoggerPlugin, U as getRecursionDetectionPlugin, V as getHttpAuthSchemeEndpointRuleSetPlugin, W as DefaultIdentityProviderConfig, X as getHttpSigningPlugin, Y as resolveHostHeaderConfig, Z as ServiceException, _ as SENSITIVE_STRING, a0 as withBaseException, $ as decorateServiceException, C as Command, g as getSerdePlugin, a as getEndpointPlugin } from './index-DeZeG5u4.js';
+import 'node:buffer';
+import { r as requestBuilder } from './requestBuilder-CuNXirlx.js';
+import { m as map, p as parseJsonBody, t as take, _ as _json, a as parseJsonErrorBody, l as loadRestJsonErrorCode } from './parseJsonBody-C_mcRkFo.js';
+import 'commander';
+import 'node:crypto';
+import 'node:fs';
+import 'node:os';
+import 'node:path';
+import 'posthog-node';
+import 'node:url';
+import 'node:process';
+import 'node:readline';
+import 'node:tty';
+import 'node:child_process';
+import 'node:util';
+import 'prettier';
+import 'fs-extra/esm';
+import 'node:fs/promises';
+import 'execa';
+import 'node:events';
+import 'node:assert';
+import 'node:worker_threads';
+import 'node:module';
+import 'node:stream';
+import 'node:string_decoder';
+import '@opentelemetry/api';
+import '@opentelemetry/auto-instrumentations-node';
+import '@opentelemetry/exporter-trace-otlp-http';
+import '@opentelemetry/resources';
+import '@opentelemetry/sdk-node';
+import '@opentelemetry/sdk-trace-base';
+import '@opentelemetry/semantic-conventions';
+import 'node:http';
+import 'node:https';
+import 'node:punycode';
+import 'node:zlib';
+import 'fs-extra';
+import './extended-encode-uri-component-Dlbpb2Wd.js';
+
+const isSerializableHeaderValue = (value) => {
+    return value != null;
+};
+
+const defaultSSOHttpAuthSchemeParametersProvider = async (config, context, input) => {
+    return {
+        operation: getSmithyContext(context).operation,
+        region: (await normalizeProvider(config.region)()) ||
+            (() => {
+                throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
+            })(),
+    };
+};
+function createAwsAuthSigv4HttpAuthOption(authParameters) {
+    return {
+        schemeId: "aws.auth#sigv4",
+        signingProperties: {
+            name: "awsssoportal",
+            region: authParameters.region,
+        },
+        propertiesExtractor: (config, context) => ({
+            signingProperties: {
+                config,
+                context,
+            },
+        }),
+    };
+}
+function createSmithyApiNoAuthHttpAuthOption(authParameters) {
+    return {
+        schemeId: "smithy.api#noAuth",
+    };
+}
+const defaultSSOHttpAuthSchemeProvider = (authParameters) => {
+    const options = [];
+    switch (authParameters.operation) {
+        case "GetRoleCredentials": {
+            options.push(createSmithyApiNoAuthHttpAuthOption());
+            break;
+        }
+        case "ListAccountRoles": {
+            options.push(createSmithyApiNoAuthHttpAuthOption());
+            break;
+        }
+        case "ListAccounts": {
+            options.push(createSmithyApiNoAuthHttpAuthOption());
+            break;
+        }
+        case "Logout": {
+            options.push(createSmithyApiNoAuthHttpAuthOption());
+            break;
+        }
+        default: {
+            options.push(createAwsAuthSigv4HttpAuthOption(authParameters));
+        }
+    }
+    return options;
+};
+const resolveHttpAuthSchemeConfig = (config) => {
+    const config_0 = resolveAwsSdkSigV4Config(config);
+    return {
+        ...config_0,
+    };
+};
+
+const resolveClientEndpointParameters = (options) => {
+    return {
+        ...options,
+        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+        useFipsEndpoint: options.useFipsEndpoint ?? false,
+        defaultSigningName: "awsssoportal",
+    };
+};
+const commonParams = {
+    UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+    Endpoint: { type: "builtInParams", name: "endpoint" },
+    Region: { type: "builtInParams", name: "region" },
+    UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+};
+
+var name = "@aws-sdk/client-sso";
+var description = "AWS SDK for JavaScript Sso Client for Node.js, Browser and React Native";
+var version = "3.716.0";
+var scripts = {
+	build: "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
+	"build:cjs": "node ../../scripts/compilation/inline client-sso",
+	"build:es": "tsc -p tsconfig.es.json",
+	"build:include:deps": "lerna run --scope $npm_package_name --include-dependencies build",
+	"build:types": "tsc -p tsconfig.types.json",
+	"build:types:downlevel": "downlevel-dts dist-types dist-types/ts3.4",
+	clean: "rimraf ./dist-* && rimraf *.tsbuildinfo",
+	"extract:docs": "api-extractor run --local",
+	"generate:client": "node ../../scripts/generate-clients/single-service --solo sso"
+};
+var main = "./dist-cjs/index.js";
+var types = "./dist-types/index.d.ts";
+var module = "./dist-es/index.js";
+var sideEffects = false;
+var dependencies = {
+	"@aws-crypto/sha256-browser": "5.2.0",
+	"@aws-crypto/sha256-js": "5.2.0",
+	"@aws-sdk/core": "3.716.0",
+	"@aws-sdk/middleware-host-header": "3.714.0",
+	"@aws-sdk/middleware-logger": "3.714.0",
+	"@aws-sdk/middleware-recursion-detection": "3.714.0",
+	"@aws-sdk/middleware-user-agent": "3.716.0",
+	"@aws-sdk/region-config-resolver": "3.714.0",
+	"@aws-sdk/types": "3.714.0",
+	"@aws-sdk/util-endpoints": "3.714.0",
+	"@aws-sdk/util-user-agent-browser": "3.714.0",
+	"@aws-sdk/util-user-agent-node": "3.716.0",
+	"@smithy/config-resolver": "^3.0.13",
+	"@smithy/core": "^2.5.5",
+	"@smithy/fetch-http-handler": "^4.1.2",
+	"@smithy/hash-node": "^3.0.11",
+	"@smithy/invalid-dependency": "^3.0.11",
+	"@smithy/middleware-content-length": "^3.0.13",
+	"@smithy/middleware-endpoint": "^3.2.6",
+	"@smithy/middleware-retry": "^3.0.31",
+	"@smithy/middleware-serde": "^3.0.11",
+	"@smithy/middleware-stack": "^3.0.11",
+	"@smithy/node-config-provider": "^3.1.12",
+	"@smithy/node-http-handler": "^3.3.2",
+	"@smithy/protocol-http": "^4.1.8",
+	"@smithy/smithy-client": "^3.5.1",
+	"@smithy/types": "^3.7.2",
+	"@smithy/url-parser": "^3.0.11",
+	"@smithy/util-base64": "^3.0.0",
+	"@smithy/util-body-length-browser": "^3.0.0",
+	"@smithy/util-body-length-node": "^3.0.0",
+	"@smithy/util-defaults-mode-browser": "^3.0.31",
+	"@smithy/util-defaults-mode-node": "^3.0.31",
+	"@smithy/util-endpoints": "^2.1.7",
+	"@smithy/util-middleware": "^3.0.11",
+	"@smithy/util-retry": "^3.0.11",
+	"@smithy/util-utf8": "^3.0.0",
+	tslib: "^2.6.2"
+};
+var devDependencies = {
+	"@tsconfig/node16": "16.1.3",
+	"@types/node": "^16.18.96",
+	concurrently: "7.0.0",
+	"downlevel-dts": "0.10.1",
+	rimraf: "3.0.2",
+	typescript: "~4.9.5"
+};
+var engines = {
+	node: ">=16.0.0"
+};
+var typesVersions = {
+	"<4.0": {
+		"dist-types/*": [
+			"dist-types/ts3.4/*"
+		]
+	}
+};
+var files = [
+	"dist-*/**"
+];
+var author = {
+	name: "AWS SDK for JavaScript Team",
+	url: "https://aws.amazon.com/javascript/"
+};
+var license = "Apache-2.0";
+var browser = {
+	"./dist-es/runtimeConfig": "./dist-es/runtimeConfig.browser"
+};
+var homepage = "https://github.com/aws/aws-sdk-js-v3/tree/main/clients/client-sso";
+var repository = {
+	type: "git",
+	url: "https://github.com/aws/aws-sdk-js-v3.git",
+	directory: "clients/client-sso"
+};
+var packageInfo = {
+	name: name,
+	description: description,
+	version: version,
+	scripts: scripts,
+	main: main,
+	types: types,
+	module: module,
+	sideEffects: sideEffects,
+	dependencies: dependencies,
+	devDependencies: devDependencies,
+	engines: engines,
+	typesVersions: typesVersions,
+	files: files,
+	author: author,
+	license: license,
+	browser: browser,
+	"react-native": {
+	"./dist-es/runtimeConfig": "./dist-es/runtimeConfig.native"
+},
+	homepage: homepage,
+	repository: repository
+};
+
+const u = "required", v = "fn", w = "argv", x = "ref";
+const a = true, b = "isSet", c = "booleanEquals", d = "error", e = "endpoint", f = "tree", g = "PartitionResult", h = "getAttr", i = { [u]: false, "type": "String" }, j = { [u]: true, "default": false, "type": "Boolean" }, k = { [x]: "Endpoint" }, l = { [v]: c, [w]: [{ [x]: "UseFIPS" }, true] }, m = { [v]: c, [w]: [{ [x]: "UseDualStack" }, true] }, n = {}, o = { [v]: h, [w]: [{ [x]: g }, "supportsFIPS"] }, p = { [x]: g }, q = { [v]: c, [w]: [true, { [v]: h, [w]: [p, "supportsDualStack"] }] }, r = [l], s = [m], t = [{ [x]: "Region" }];
+const _data = { version: "1.0", parameters: { Region: i, UseDualStack: j, UseFIPS: j, Endpoint: i }, rules: [{ conditions: [{ [v]: b, [w]: [k] }], rules: [{ conditions: r, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: d }, { conditions: s, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: d }, { endpoint: { url: k, properties: n, headers: n }, type: e }], type: f }, { conditions: [{ [v]: b, [w]: t }], rules: [{ conditions: [{ [v]: "aws.partition", [w]: t, assign: g }], rules: [{ conditions: [l, m], rules: [{ conditions: [{ [v]: c, [w]: [a, o] }, q], rules: [{ endpoint: { url: "https://portal.sso-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: n, headers: n }, type: e }], type: f }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: d }], type: f }, { conditions: r, rules: [{ conditions: [{ [v]: c, [w]: [o, a] }], rules: [{ conditions: [{ [v]: "stringEquals", [w]: [{ [v]: h, [w]: [p, "name"] }, "aws-us-gov"] }], endpoint: { url: "https://portal.sso.{Region}.amazonaws.com", properties: n, headers: n }, type: e }, { endpoint: { url: "https://portal.sso-fips.{Region}.{PartitionResult#dnsSuffix}", properties: n, headers: n }, type: e }], type: f }, { error: "FIPS is enabled but this partition does not support FIPS", type: d }], type: f }, { conditions: s, rules: [{ conditions: [q], rules: [{ endpoint: { url: "https://portal.sso.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: n, headers: n }, type: e }], type: f }, { error: "DualStack is enabled but this partition does not support DualStack", type: d }], type: f }, { endpoint: { url: "https://portal.sso.{Region}.{PartitionResult#dnsSuffix}", properties: n, headers: n }, type: e }], type: f }], type: f }, { error: "Invalid Configuration: Missing Region", type: d }] };
+const ruleSet = _data;
+
+const cache = new EndpointCache({
+    size: 50,
+    params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"],
+});
+const defaultEndpointResolver = (endpointParams, context = {}) => {
+    return cache.get(endpointParams, () => resolveEndpoint(ruleSet, {
+        endpointParams: endpointParams,
+        logger: context.logger,
+    }));
+};
+customEndpointFunctions.aws = awsEndpointFunctions;
+
+const getRuntimeConfig$1 = (config) => {
+    return {
+        apiVersion: "2019-06-10",
+        base64Decoder: config?.base64Decoder ?? fromBase64,
+        base64Encoder: config?.base64Encoder ?? toBase64,
+        disableHostPrefix: config?.disableHostPrefix ?? false,
+        endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
+        extensions: config?.extensions ?? [],
+        httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultSSOHttpAuthSchemeProvider,
+        httpAuthSchemes: config?.httpAuthSchemes ?? [
+            {
+                schemeId: "aws.auth#sigv4",
+                identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
+                signer: new AwsSdkSigV4Signer(),
+            },
+            {
+                schemeId: "smithy.api#noAuth",
+                identityProvider: (ipc) => ipc.getIdentityProvider("smithy.api#noAuth") || (async () => ({})),
+                signer: new NoAuthSigner(),
+            },
+        ],
+        logger: config?.logger ?? new NoOpLogger(),
+        serviceId: config?.serviceId ?? "SSO",
+        urlParser: config?.urlParser ?? parseUrl,
+        utf8Decoder: config?.utf8Decoder ?? fromUtf8,
+        utf8Encoder: config?.utf8Encoder ?? toUtf8,
+    };
+};
+
+const getRuntimeConfig = (config) => {
+    emitWarningIfUnsupportedVersion(process.version);
+    const defaultsMode = resolveDefaultsModeConfig(config);
+    const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
+    const clientSharedValues = getRuntimeConfig$1(config);
+    emitWarningIfUnsupportedVersion$1(process.version);
+    const profileConfig = { profile: config?.profile };
+    return {
+        ...clientSharedValues,
+        ...config,
+        runtime: "node",
+        defaultsMode,
+        bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
+        defaultUserAgentProvider: config?.defaultUserAgentProvider ??
+            createDefaultUserAgentProvider({ serviceId: clientSharedValues.serviceId, clientVersion: packageInfo.version }),
+        maxAttempts: config?.maxAttempts ?? loadConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
+        region: config?.region ??
+            loadConfig(NODE_REGION_CONFIG_OPTIONS, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...profileConfig }),
+        requestHandler: NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
+        retryMode: config?.retryMode ??
+            loadConfig({
+                ...NODE_RETRY_MODE_CONFIG_OPTIONS,
+                default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE,
+            }, config),
+        sha256: config?.sha256 ?? Hash.bind(null, "sha256"),
+        streamCollector: config?.streamCollector ?? streamCollector,
+        useDualstackEndpoint: config?.useDualstackEndpoint ?? loadConfig(NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, profileConfig),
+        useFipsEndpoint: config?.useFipsEndpoint ?? loadConfig(NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, profileConfig),
+        userAgentAppId: config?.userAgentAppId ?? loadConfig(NODE_APP_ID_CONFIG_OPTIONS, profileConfig),
+    };
+};
+
+const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
+    const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
+    let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
+    let _credentials = runtimeConfig.credentials;
+    return {
+        setHttpAuthScheme(httpAuthScheme) {
+            const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
+            if (index === -1) {
+                _httpAuthSchemes.push(httpAuthScheme);
+            }
+            else {
+                _httpAuthSchemes.splice(index, 1, httpAuthScheme);
+            }
+        },
+        httpAuthSchemes() {
+            return _httpAuthSchemes;
+        },
+        setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
+            _httpAuthSchemeProvider = httpAuthSchemeProvider;
+        },
+        httpAuthSchemeProvider() {
+            return _httpAuthSchemeProvider;
+        },
+        setCredentials(credentials) {
+            _credentials = credentials;
+        },
+        credentials() {
+            return _credentials;
+        },
+    };
+};
+const resolveHttpAuthRuntimeConfig = (config) => {
+    return {
+        httpAuthSchemes: config.httpAuthSchemes(),
+        httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
+        credentials: config.credentials(),
+    };
+};
+
+const asPartial = (t) => t;
+const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
+    const extensionConfiguration = {
+        ...asPartial(getAwsRegionExtensionConfiguration(runtimeConfig)),
+        ...asPartial(getDefaultExtensionConfiguration(runtimeConfig)),
+        ...asPartial(getHttpHandlerExtensionConfiguration(runtimeConfig)),
+        ...asPartial(getHttpAuthExtensionConfiguration(runtimeConfig)),
+    };
+    extensions.forEach((extension) => extension.configure(extensionConfiguration));
+    return {
+        ...runtimeConfig,
+        ...resolveAwsRegionExtensionConfiguration(extensionConfiguration),
+        ...resolveDefaultRuntimeConfig(extensionConfiguration),
+        ...resolveHttpHandlerRuntimeConfig(extensionConfiguration),
+        ...resolveHttpAuthRuntimeConfig(extensionConfiguration),
+    };
+};
+
+class SSOClient extends Client {
+    constructor(...[configuration]) {
+        const _config_0 = getRuntimeConfig(configuration || {});
+        const _config_1 = resolveClientEndpointParameters(_config_0);
+        const _config_2 = resolveUserAgentConfig(_config_1);
+        const _config_3 = resolveRetryConfig(_config_2);
+        const _config_4 = resolveRegionConfig(_config_3);
+        const _config_5 = resolveHostHeaderConfig(_config_4);
+        const _config_6 = resolveEndpointConfig(_config_5);
+        const _config_7 = resolveHttpAuthSchemeConfig(_config_6);
+        const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
+        super(_config_8);
+        this.config = _config_8;
+        this.middlewareStack.use(getUserAgentPlugin(this.config));
+        this.middlewareStack.use(getRetryPlugin(this.config));
+        this.middlewareStack.use(getContentLengthPlugin(this.config));
+        this.middlewareStack.use(getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(getLoggerPlugin(this.config));
+        this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
+        this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
+            httpAuthSchemeParametersProvider: defaultSSOHttpAuthSchemeParametersProvider,
+            identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
+                "aws.auth#sigv4": config.credentials,
+            }),
+        }));
+        this.middlewareStack.use(getHttpSigningPlugin(this.config));
+    }
+    destroy() {
+        super.destroy();
+    }
+}
+
+class SSOServiceException extends ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, SSOServiceException.prototype);
+    }
+}
+
+class InvalidRequestException extends SSOServiceException {
+    constructor(opts) {
+        super({
+            name: "InvalidRequestException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "InvalidRequestException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, InvalidRequestException.prototype);
+    }
+}
+class ResourceNotFoundException extends SSOServiceException {
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ResourceNotFoundException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+    }
+}
+class TooManyRequestsException extends SSOServiceException {
+    constructor(opts) {
+        super({
+            name: "TooManyRequestsException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "TooManyRequestsException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, TooManyRequestsException.prototype);
+    }
+}
+class UnauthorizedException extends SSOServiceException {
+    constructor(opts) {
+        super({
+            name: "UnauthorizedException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "UnauthorizedException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, UnauthorizedException.prototype);
+    }
+}
+const GetRoleCredentialsRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.accessToken && { accessToken: SENSITIVE_STRING }),
+});
+const RoleCredentialsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.secretAccessKey && { secretAccessKey: SENSITIVE_STRING }),
+    ...(obj.sessionToken && { sessionToken: SENSITIVE_STRING }),
+});
+const GetRoleCredentialsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.roleCredentials && { roleCredentials: RoleCredentialsFilterSensitiveLog(obj.roleCredentials) }),
+});
+
+const se_GetRoleCredentialsCommand = async (input, context) => {
+    const b = requestBuilder(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        [_xasbt]: input[_aT],
+    });
+    b.bp("/federation/credentials");
+    const query = map({
+        [_rn]: [, expectNonNull(input[_rN], `roleName`)],
+        [_ai]: [, expectNonNull(input[_aI], `accountId`)],
+    });
+    let body;
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
+};
+const de_GetRoleCredentialsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = expectNonNull(expectObject(await parseJsonBody(output.body, context)), "body");
+    const doc = take(data, {
+        roleCredentials: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_CommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseJsonErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InvalidRequestException":
+        case "com.amazonaws.sso#InvalidRequestException":
+            throw await de_InvalidRequestExceptionRes(parsedOutput);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.sso#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
+        case "TooManyRequestsException":
+        case "com.amazonaws.sso#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput);
+        case "UnauthorizedException":
+        case "com.amazonaws.sso#UnauthorizedException":
+            throw await de_UnauthorizedExceptionRes(parsedOutput);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+const throwDefaultError = withBaseException(SSOServiceException);
+const de_InvalidRequestExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        message: expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new InvalidRequestException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return decorateServiceException(exception, parsedOutput.body);
+};
+const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        message: expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ResourceNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return decorateServiceException(exception, parsedOutput.body);
+};
+const de_TooManyRequestsExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        message: expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new TooManyRequestsException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return decorateServiceException(exception, parsedOutput.body);
+};
+const de_UnauthorizedExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        message: expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new UnauthorizedException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return decorateServiceException(exception, parsedOutput.body);
+};
+const deserializeMetadata = (output) => ({
+    httpStatusCode: output.statusCode,
+    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+    extendedRequestId: output.headers["x-amz-id-2"],
+    cfId: output.headers["x-amz-cf-id"],
+});
+const _aI = "accountId";
+const _aT = "accessToken";
+const _ai = "account_id";
+const _rN = "roleName";
+const _rn = "role_name";
+const _xasbt = "x-amz-sso_bearer_token";
+
+class GetRoleCredentialsCommand extends Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("SWBPortalService", "GetRoleCredentials", {})
+    .n("SSOClient", "GetRoleCredentialsCommand")
+    .f(GetRoleCredentialsRequestFilterSensitiveLog, GetRoleCredentialsResponseFilterSensitiveLog)
+    .ser(se_GetRoleCredentialsCommand)
+    .de(de_GetRoleCredentialsCommand)
+    .build() {
+}
+
+export { GetRoleCredentialsCommand, SSOClient };
+//# sourceMappingURL=loadSso-MEAVww3h.js.map