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

package/dist/loadCognitoIdentity-CWxGlq_8.js

@@ -0,0 +1,828 @@
+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, $ as decorateServiceException, a0 as withBaseException, C as Command, g as getSerdePlugin, a as getEndpointPlugin } from './index-DeZeG5u4.js';
+import { z as toBase64, A as parseUrl, B as fromUtf8, C as toUtf8, F as defaultProvider, G as loadConfig, N as NodeHttpHandler, I as streamCollector, H as HttpRequest, J as expectString, K as expectNonNull, L as parseEpochTimestamp, M as expectNumber } from './index.js';
+import 'node:buffer';
+import { _ as _json, p as parseJsonBody, a as parseJsonErrorBody, l as loadRestJsonErrorCode, t as take } from './parseJsonBody-C_mcRkFo.js';
+import 'node:stream';
+import 'node:crypto';
+import 'node:os';
+import 'node:process';
+import 'node:fs';
+import 'commander';
+import 'node:path';
+import 'posthog-node';
+import 'node:url';
+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: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';
+
+const defaultCognitoIdentityHttpAuthSchemeParametersProvider = 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: "cognito-identity",
+            region: authParameters.region,
+        },
+        propertiesExtractor: (config, context) => ({
+            signingProperties: {
+                config,
+                context,
+            },
+        }),
+    };
+}
+function createSmithyApiNoAuthHttpAuthOption(authParameters) {
+    return {
+        schemeId: "smithy.api#noAuth",
+    };
+}
+const defaultCognitoIdentityHttpAuthSchemeProvider = (authParameters) => {
+    const options = [];
+    switch (authParameters.operation) {
+        case "GetCredentialsForIdentity": {
+            options.push(createSmithyApiNoAuthHttpAuthOption());
+            break;
+        }
+        case "GetId": {
+            options.push(createSmithyApiNoAuthHttpAuthOption());
+            break;
+        }
+        case "GetOpenIdToken": {
+            options.push(createSmithyApiNoAuthHttpAuthOption());
+            break;
+        }
+        case "UnlinkIdentity": {
+            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: "cognito-identity",
+    };
+};
+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-cognito-identity";
+var description = "AWS SDK for JavaScript Cognito Identity 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-cognito-identity",
+	"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 cognito-identity",
+	"test:e2e": "yarn g:vitest run -c vitest.config.e2e.ts --mode development",
+	"test:e2e:watch": "yarn g:vitest watch -c vitest.config.e2e.ts"
+};
+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/client-sso-oidc": "3.716.0",
+	"@aws-sdk/client-sts": "3.716.0",
+	"@aws-sdk/core": "3.716.0",
+	"@aws-sdk/credential-provider-node": "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 = {
+	"@aws-sdk/client-iam": "3.716.0",
+	"@tsconfig/node16": "16.1.3",
+	"@types/chai": "^4.2.11",
+	"@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-cognito-identity";
+var repository = {
+	type: "git",
+	url: "https://github.com/aws/aws-sdk-js-v3.git",
+	directory: "clients/client-cognito-identity"
+};
+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 s = "required", t = "fn", u = "argv", v = "ref";
+const a = true, b = "isSet", c = "booleanEquals", d = "error", e = "endpoint", f = "tree", g = "PartitionResult", h = { [s]: false, "type": "String" }, i = { [s]: true, "default": false, "type": "Boolean" }, j = { [v]: "Endpoint" }, k = { [t]: c, [u]: [{ [v]: "UseFIPS" }, true] }, l = { [t]: c, [u]: [{ [v]: "UseDualStack" }, true] }, m = {}, n = { [t]: "getAttr", [u]: [{ [v]: g }, "supportsFIPS"] }, o = { [t]: c, [u]: [true, { [t]: "getAttr", [u]: [{ [v]: g }, "supportsDualStack"] }] }, p = [k], q = [l], r = [{ [v]: "Region" }];
+const _data = { version: "1.0", parameters: { Region: h, UseDualStack: i, UseFIPS: i, Endpoint: h }, rules: [{ conditions: [{ [t]: b, [u]: [j] }], rules: [{ conditions: p, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: d }, { conditions: q, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: d }, { endpoint: { url: j, properties: m, headers: m }, type: e }], type: f }, { conditions: [{ [t]: b, [u]: r }], rules: [{ conditions: [{ [t]: "aws.partition", [u]: r, assign: g }], rules: [{ conditions: [k, l], rules: [{ conditions: [{ [t]: c, [u]: [a, n] }, o], rules: [{ endpoint: { url: "https://cognito-identity-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: m, headers: m }, type: e }], type: f }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: d }], type: f }, { conditions: p, rules: [{ conditions: [{ [t]: c, [u]: [n, a] }], rules: [{ endpoint: { url: "https://cognito-identity-fips.{Region}.{PartitionResult#dnsSuffix}", properties: m, headers: m }, type: e }], type: f }, { error: "FIPS is enabled but this partition does not support FIPS", type: d }], type: f }, { conditions: q, rules: [{ conditions: [o], rules: [{ endpoint: { url: "https://cognito-identity.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: m, headers: m }, type: e }], type: f }, { error: "DualStack is enabled but this partition does not support DualStack", type: d }], type: f }, { endpoint: { url: "https://cognito-identity.{Region}.{PartitionResult#dnsSuffix}", properties: m, headers: m }, 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: "2014-06-30",
+        base64Decoder: config?.base64Decoder ?? fromBase64,
+        base64Encoder: config?.base64Encoder ?? toBase64,
+        disableHostPrefix: config?.disableHostPrefix ?? false,
+        endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
+        extensions: config?.extensions ?? [],
+        httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultCognitoIdentityHttpAuthSchemeProvider,
+        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 ?? "Cognito Identity",
+        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,
+        credentialDefaultProvider: config?.credentialDefaultProvider ?? defaultProvider,
+        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 CognitoIdentityClient 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: defaultCognitoIdentityHttpAuthSchemeParametersProvider,
+            identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
+                "aws.auth#sigv4": config.credentials,
+            }),
+        }));
+        this.middlewareStack.use(getHttpSigningPlugin(this.config));
+    }
+    destroy() {
+        super.destroy();
+    }
+}
+
+class CognitoIdentityServiceException extends ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, CognitoIdentityServiceException.prototype);
+    }
+}
+
+class InternalErrorException extends CognitoIdentityServiceException {
+    constructor(opts) {
+        super({
+            name: "InternalErrorException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "InternalErrorException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, InternalErrorException.prototype);
+    }
+}
+class InvalidParameterException extends CognitoIdentityServiceException {
+    constructor(opts) {
+        super({
+            name: "InvalidParameterException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "InvalidParameterException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, InvalidParameterException.prototype);
+    }
+}
+class LimitExceededException extends CognitoIdentityServiceException {
+    constructor(opts) {
+        super({
+            name: "LimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "LimitExceededException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, LimitExceededException.prototype);
+    }
+}
+class NotAuthorizedException extends CognitoIdentityServiceException {
+    constructor(opts) {
+        super({
+            name: "NotAuthorizedException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "NotAuthorizedException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, NotAuthorizedException.prototype);
+    }
+}
+class ResourceConflictException extends CognitoIdentityServiceException {
+    constructor(opts) {
+        super({
+            name: "ResourceConflictException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ResourceConflictException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ResourceConflictException.prototype);
+    }
+}
+class TooManyRequestsException extends CognitoIdentityServiceException {
+    constructor(opts) {
+        super({
+            name: "TooManyRequestsException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "TooManyRequestsException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, TooManyRequestsException.prototype);
+    }
+}
+class ResourceNotFoundException extends CognitoIdentityServiceException {
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ResourceNotFoundException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+    }
+}
+class ExternalServiceException extends CognitoIdentityServiceException {
+    constructor(opts) {
+        super({
+            name: "ExternalServiceException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ExternalServiceException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ExternalServiceException.prototype);
+    }
+}
+class InvalidIdentityPoolConfigurationException extends CognitoIdentityServiceException {
+    constructor(opts) {
+        super({
+            name: "InvalidIdentityPoolConfigurationException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "InvalidIdentityPoolConfigurationException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, InvalidIdentityPoolConfigurationException.prototype);
+    }
+}
+class DeveloperUserAlreadyRegisteredException extends CognitoIdentityServiceException {
+    constructor(opts) {
+        super({
+            name: "DeveloperUserAlreadyRegisteredException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "DeveloperUserAlreadyRegisteredException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, DeveloperUserAlreadyRegisteredException.prototype);
+    }
+}
+class ConcurrentModificationException extends CognitoIdentityServiceException {
+    constructor(opts) {
+        super({
+            name: "ConcurrentModificationException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ConcurrentModificationException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ConcurrentModificationException.prototype);
+    }
+}
+const GetCredentialsForIdentityInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Logins && { Logins: SENSITIVE_STRING }),
+});
+const CredentialsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.SecretKey && { SecretKey: SENSITIVE_STRING }),
+});
+const GetCredentialsForIdentityResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Credentials && { Credentials: CredentialsFilterSensitiveLog(obj.Credentials) }),
+});
+const GetIdInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Logins && { Logins: SENSITIVE_STRING }),
+});
+
+const se_GetCredentialsForIdentityCommand = async (input, context) => {
+    const headers = sharedHeaders("GetCredentialsForIdentity");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_GetIdCommand = async (input, context) => {
+    const headers = sharedHeaders("GetId");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const de_GetCredentialsForIdentityCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_GetCredentialsForIdentityResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_GetIdCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseJsonBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_CommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseJsonErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalErrorException":
+        case "com.amazonaws.cognitoidentity#InternalErrorException":
+            throw await de_InternalErrorExceptionRes(parsedOutput);
+        case "InvalidParameterException":
+        case "com.amazonaws.cognitoidentity#InvalidParameterException":
+            throw await de_InvalidParameterExceptionRes(parsedOutput);
+        case "LimitExceededException":
+        case "com.amazonaws.cognitoidentity#LimitExceededException":
+            throw await de_LimitExceededExceptionRes(parsedOutput);
+        case "NotAuthorizedException":
+        case "com.amazonaws.cognitoidentity#NotAuthorizedException":
+            throw await de_NotAuthorizedExceptionRes(parsedOutput);
+        case "ResourceConflictException":
+        case "com.amazonaws.cognitoidentity#ResourceConflictException":
+            throw await de_ResourceConflictExceptionRes(parsedOutput);
+        case "TooManyRequestsException":
+        case "com.amazonaws.cognitoidentity#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.cognitoidentity#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
+        case "ExternalServiceException":
+        case "com.amazonaws.cognitoidentity#ExternalServiceException":
+            throw await de_ExternalServiceExceptionRes(parsedOutput);
+        case "InvalidIdentityPoolConfigurationException":
+        case "com.amazonaws.cognitoidentity#InvalidIdentityPoolConfigurationException":
+            throw await de_InvalidIdentityPoolConfigurationExceptionRes(parsedOutput);
+        case "DeveloperUserAlreadyRegisteredException":
+        case "com.amazonaws.cognitoidentity#DeveloperUserAlreadyRegisteredException":
+            throw await de_DeveloperUserAlreadyRegisteredExceptionRes(parsedOutput);
+        case "ConcurrentModificationException":
+        case "com.amazonaws.cognitoidentity#ConcurrentModificationException":
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+const de_ConcurrentModificationExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new ConcurrentModificationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return decorateServiceException(exception, body);
+};
+const de_DeveloperUserAlreadyRegisteredExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new DeveloperUserAlreadyRegisteredException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return decorateServiceException(exception, body);
+};
+const de_ExternalServiceExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new ExternalServiceException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return decorateServiceException(exception, body);
+};
+const de_InternalErrorExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new InternalErrorException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return decorateServiceException(exception, body);
+};
+const de_InvalidIdentityPoolConfigurationExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new InvalidIdentityPoolConfigurationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return decorateServiceException(exception, body);
+};
+const de_InvalidParameterExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new InvalidParameterException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return decorateServiceException(exception, body);
+};
+const de_LimitExceededExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new LimitExceededException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return decorateServiceException(exception, body);
+};
+const de_NotAuthorizedExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new NotAuthorizedException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return decorateServiceException(exception, body);
+};
+const de_ResourceConflictExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new ResourceConflictException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return decorateServiceException(exception, body);
+};
+const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new ResourceNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return decorateServiceException(exception, body);
+};
+const de_TooManyRequestsExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new TooManyRequestsException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return decorateServiceException(exception, body);
+};
+const de_Credentials = (output, context) => {
+    return take(output, {
+        AccessKeyId: expectString,
+        Expiration: (_) => expectNonNull(parseEpochTimestamp(expectNumber(_))),
+        SecretKey: expectString,
+        SessionToken: expectString,
+    });
+};
+const de_GetCredentialsForIdentityResponse = (output, context) => {
+    return take(output, {
+        Credentials: (_) => de_Credentials(_),
+        IdentityId: expectString,
+    });
+};
+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 throwDefaultError = withBaseException(CognitoIdentityServiceException);
+const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const contents = {
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
+        headers,
+    };
+    if (body !== undefined) {
+        contents.body = body;
+    }
+    return new HttpRequest(contents);
+};
+function sharedHeaders(operation) {
+    return {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": `AWSCognitoIdentityService.${operation}`,
+    };
+}
+
+class GetCredentialsForIdentityCommand extends Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AWSCognitoIdentityService", "GetCredentialsForIdentity", {})
+    .n("CognitoIdentityClient", "GetCredentialsForIdentityCommand")
+    .f(GetCredentialsForIdentityInputFilterSensitiveLog, GetCredentialsForIdentityResponseFilterSensitiveLog)
+    .ser(se_GetCredentialsForIdentityCommand)
+    .de(de_GetCredentialsForIdentityCommand)
+    .build() {
+}
+
+class GetIdCommand extends Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AWSCognitoIdentityService", "GetId", {})
+    .n("CognitoIdentityClient", "GetIdCommand")
+    .f(GetIdInputFilterSensitiveLog, undefined)
+    .ser(se_GetIdCommand)
+    .de(de_GetIdCommand)
+    .build() {
+}
+
+export { CognitoIdentityClient, GetCredentialsForIdentityCommand, GetIdCommand };
+//# sourceMappingURL=loadCognitoIdentity-CWxGlq_8.js.map