@aws-amplify/graphql-api-construct 1.13.0 → 1.14.0

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/AwsSdkSigV4Signer.js

@@ -0,0 +1,72 @@
+import { HttpRequest } from "@smithy/protocol-http";
+import { getDateHeader, getSkewCorrectedDate, getUpdatedSystemClockOffset } from "../utils";
+const throwSigningPropertyError = (name, property) => {
+    if (!property) {
+        throw new Error(`Property \`${name}\` is not resolved for AWS SDK SigV4Auth`);
+    }
+    return property;
+};
+export const validateSigningProperties = async (signingProperties) => {
+    const context = throwSigningPropertyError("context", signingProperties.context);
+    const config = throwSigningPropertyError("config", signingProperties.config);
+    const authScheme = context.endpointV2?.properties?.authSchemes?.[0];
+    const signerFunction = throwSigningPropertyError("signer", config.signer);
+    const signer = await signerFunction(authScheme);
+    const signingRegion = signingProperties?.signingRegion;
+    const signingRegionSet = signingProperties?.signingRegionSet;
+    const signingName = signingProperties?.signingName;
+    return {
+        config,
+        signer,
+        signingRegion,
+        signingRegionSet,
+        signingName,
+    };
+};
+export class AwsSdkSigV4Signer {
+    async sign(httpRequest, identity, signingProperties) {
+        if (!HttpRequest.isInstance(httpRequest)) {
+            throw new Error("The request is not an instance of `HttpRequest` and cannot be signed");
+        }
+        const validatedProps = await validateSigningProperties(signingProperties);
+        const { config, signer } = validatedProps;
+        let { signingRegion, signingName } = validatedProps;
+        const handlerExecutionContext = signingProperties.context;
+        if (handlerExecutionContext?.authSchemes?.length ?? 0 > 1) {
+            const [first, second] = handlerExecutionContext.authSchemes;
+            if (first?.name === "sigv4a" && second?.name === "sigv4") {
+                signingRegion = second?.signingRegion ?? signingRegion;
+                signingName = second?.signingName ?? signingName;
+            }
+        }
+        const signedRequest = await signer.sign(httpRequest, {
+            signingDate: getSkewCorrectedDate(config.systemClockOffset),
+            signingRegion: signingRegion,
+            signingService: signingName,
+        });
+        return signedRequest;
+    }
+    errorHandler(signingProperties) {
+        return (error) => {
+            const serverTime = error.ServerTime ?? getDateHeader(error.$response);
+            if (serverTime) {
+                const config = throwSigningPropertyError("config", signingProperties.config);
+                const initialSystemClockOffset = config.systemClockOffset;
+                config.systemClockOffset = getUpdatedSystemClockOffset(serverTime, config.systemClockOffset);
+                const clockSkewCorrected = config.systemClockOffset !== initialSystemClockOffset;
+                if (clockSkewCorrected && error.$metadata) {
+                    error.$metadata.clockSkewCorrected = true;
+                }
+            }
+            throw error;
+        };
+    }
+    successHandler(httpResponse, signingProperties) {
+        const dateHeader = getDateHeader(httpResponse);
+        if (dateHeader) {
+            const config = throwSigningPropertyError("config", signingProperties.config);
+            config.systemClockOffset = getUpdatedSystemClockOffset(dateHeader, config.systemClockOffset);
+        }
+    }
+}
+export const AWSSDKSigV4Signer = AwsSdkSigV4Signer;

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/index.js

@@ -0,0 +1,4 @@
+export { AwsSdkSigV4Signer, AWSSDKSigV4Signer, validateSigningProperties } from "./AwsSdkSigV4Signer";
+export { AwsSdkSigV4ASigner } from "./AwsSdkSigV4ASigner";
+export * from "./resolveAwsSdkSigV4AConfig";
+export * from "./resolveAwsSdkSigV4Config";

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/resolveAwsSdkSigV4AConfig.js

@@ -0,0 +1,25 @@
+import { normalizeProvider } from "@smithy/core";
+import { ProviderError } from "@smithy/property-provider";
+export const resolveAwsSdkSigV4AConfig = (config) => {
+    config.sigv4aSigningRegionSet = normalizeProvider(config.sigv4aSigningRegionSet);
+    return config;
+};
+export const NODE_SIGV4A_CONFIG_OPTIONS = {
+    environmentVariableSelector(env) {
+        if (env.AWS_SIGV4A_SIGNING_REGION_SET) {
+            return env.AWS_SIGV4A_SIGNING_REGION_SET.split(",").map((_) => _.trim());
+        }
+        throw new ProviderError("AWS_SIGV4A_SIGNING_REGION_SET not set in env.", {
+            tryNextLink: true,
+        });
+    },
+    configFileSelector(profile) {
+        if (profile.sigv4a_signing_region_set) {
+            return (profile.sigv4a_signing_region_set ?? "").split(",").map((_) => _.trim());
+        }
+        throw new ProviderError("sigv4a_signing_region_set not set in profile.", {
+            tryNextLink: true,
+        });
+    },
+    default: undefined,
+};

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/resolveAwsSdkSigV4Config.js

@@ -0,0 +1,82 @@
+import { doesIdentityRequireRefresh, isIdentityExpired, memoizeIdentityProvider, normalizeProvider, } from "@smithy/core";
+import { SignatureV4 } from "@smithy/signature-v4";
+export const resolveAwsSdkSigV4Config = (config) => {
+    let normalizedCreds;
+    if (config.credentials) {
+        normalizedCreds = memoizeIdentityProvider(config.credentials, isIdentityExpired, doesIdentityRequireRefresh);
+    }
+    if (!normalizedCreds) {
+        if (config.credentialDefaultProvider) {
+            normalizedCreds = normalizeProvider(config.credentialDefaultProvider(Object.assign({}, config, {
+                parentClientConfig: config,
+            })));
+        }
+        else {
+            normalizedCreds = async () => {
+                throw new Error("`credentials` is missing");
+            };
+        }
+    }
+    const { signingEscapePath = true, systemClockOffset = config.systemClockOffset || 0, sha256, } = config;
+    let signer;
+    if (config.signer) {
+        signer = normalizeProvider(config.signer);
+    }
+    else if (config.regionInfoProvider) {
+        signer = () => normalizeProvider(config.region)()
+            .then(async (region) => [
+            (await config.regionInfoProvider(region, {
+                useFipsEndpoint: await config.useFipsEndpoint(),
+                useDualstackEndpoint: await config.useDualstackEndpoint(),
+            })) || {},
+            region,
+        ])
+            .then(([regionInfo, region]) => {
+            const { signingRegion, signingService } = regionInfo;
+            config.signingRegion = config.signingRegion || signingRegion || region;
+            config.signingName = config.signingName || signingService || config.serviceId;
+            const params = {
+                ...config,
+                credentials: normalizedCreds,
+                region: config.signingRegion,
+                service: config.signingName,
+                sha256,
+                uriEscapePath: signingEscapePath,
+            };
+            const SignerCtor = config.signerConstructor || SignatureV4;
+            return new SignerCtor(params);
+        });
+    }
+    else {
+        signer = async (authScheme) => {
+            authScheme = Object.assign({}, {
+                name: "sigv4",
+                signingName: config.signingName || config.defaultSigningName,
+                signingRegion: await normalizeProvider(config.region)(),
+                properties: {},
+            }, authScheme);
+            const signingRegion = authScheme.signingRegion;
+            const signingService = authScheme.signingName;
+            config.signingRegion = config.signingRegion || signingRegion;
+            config.signingName = config.signingName || signingService || config.serviceId;
+            const params = {
+                ...config,
+                credentials: normalizedCreds,
+                region: config.signingRegion,
+                service: config.signingName,
+                sha256,
+                uriEscapePath: signingEscapePath,
+            };
+            const SignerCtor = config.signerConstructor || SignatureV4;
+            return new SignerCtor(params);
+        };
+    }
+    return {
+        ...config,
+        systemClockOffset,
+        signingEscapePath,
+        credentials: normalizedCreds,
+        signer,
+    };
+};
+export const resolveAWSSDKSigV4Config = resolveAwsSdkSigV4Config;

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/index.js

@@ -0,0 +1 @@
+export * from "./aws_sdk";

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getDateHeader.js

@@ -0,0 +1,2 @@
+import { HttpResponse } from "@smithy/protocol-http";
+export const getDateHeader = (response) => HttpResponse.isInstance(response) ? response.headers?.date ?? response.headers?.Date : undefined;

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getSkewCorrectedDate.js

@@ -0,0 +1 @@
+export const getSkewCorrectedDate = (systemClockOffset) => new Date(Date.now() + systemClockOffset);

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getUpdatedSystemClockOffset.js

@@ -0,0 +1,8 @@
+import { isClockSkewed } from "./isClockSkewed";
+export const getUpdatedSystemClockOffset = (clockTime, currentSystemClockOffset) => {
+    const clockTimeInMs = Date.parse(clockTime);
+    if (isClockSkewed(clockTimeInMs, currentSystemClockOffset)) {
+        return clockTimeInMs - Date.now();
+    }
+    return currentSystemClockOffset;
+};

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/index.js

@@ -0,0 +1,3 @@
+export * from "./getDateHeader";
+export * from "./getSkewCorrectedDate";
+export * from "./getUpdatedSystemClockOffset";

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/isClockSkewed.js

@@ -0,0 +1,2 @@
+import { getSkewCorrectedDate } from "./getSkewCorrectedDate";
+export const isClockSkewed = (clockTime, systemClockOffset) => Math.abs(getSkewCorrectedDate(systemClockOffset).getTime() - clockTime) >= 300000;

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@aws-sdk/core/dist-es/submodules/protocols/coercing-serializers.js

@@ -0,0 +1,53 @@
+export const _toStr = (val) => {
+    if (val == null) {
+        return val;
+    }
+    if (typeof val === "number" || typeof val === "bigint") {
+        const warning = new Error(`Received number ${val} where a string was expected.`);
+        warning.name = "Warning";
+        console.warn(warning);
+        return String(val);
+    }
+    if (typeof val === "boolean") {
+        const warning = new Error(`Received boolean ${val} where a string was expected.`);
+        warning.name = "Warning";
+        console.warn(warning);
+        return String(val);
+    }
+    return val;
+};
+export const _toBool = (val) => {
+    if (val == null) {
+        return val;
+    }
+    if (typeof val === "number") {
+    }
+    if (typeof val === "string") {
+        const lowercase = val.toLowerCase();
+        if (val !== "" && lowercase !== "false" && lowercase !== "true") {
+            const warning = new Error(`Received string "${val}" where a boolean was expected.`);
+            warning.name = "Warning";
+            console.warn(warning);
+        }
+        return val !== "" && lowercase !== "false";
+    }
+    return val;
+};
+export const _toNum = (val) => {
+    if (val == null) {
+        return val;
+    }
+    if (typeof val === "boolean") {
+    }
+    if (typeof val === "string") {
+        const num = Number(val);
+        if (num.toString() !== val) {
+            const warning = new Error(`Received string "${val}" where a number was expected.`);
+            warning.name = "Warning";
+            console.warn(warning);
+            return val;
+        }
+        return num;
+    }
+    return val;
+};

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@aws-sdk/core/dist-es/submodules/protocols/common.js

@@ -0,0 +1,2 @@
+import { collectBody } from "@smithy/smithy-client";
+export const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@aws-sdk/core/dist-es/submodules/protocols/index.js

@@ -0,0 +1,4 @@
+export * from "./coercing-serializers";
+export * from "./json/awsExpectUnion";
+export * from "./json/parseJsonBody";
+export * from "./xml/parseXmlBody";

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/awsExpectUnion.js

@@ -0,0 +1,10 @@
+import { expectUnion } from "@smithy/smithy-client";
+export const awsExpectUnion = (value) => {
+    if (value == null) {
+        return undefined;
+    }
+    if (typeof value === "object" && "__type" in value) {
+        delete value.__type;
+    }
+    return expectUnion(value);
+};

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/parseJsonBody.js

@@ -0,0 +1,51 @@
+import { collectBodyString } from "../common";
+export const parseJsonBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+    if (encoded.length) {
+        try {
+            return JSON.parse(encoded);
+        }
+        catch (e) {
+            if (e?.name === "SyntaxError") {
+                Object.defineProperty(e, "$responseBodyText", {
+                    value: encoded,
+                });
+            }
+            throw e;
+        }
+    }
+    return {};
+});
+export const parseJsonErrorBody = async (errorBody, context) => {
+    const value = await parseJsonBody(errorBody, context);
+    value.message = value.message ?? value.Message;
+    return value;
+};
+export const loadRestJsonErrorCode = (output, data) => {
+    const findKey = (object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase());
+    const sanitizeErrorCode = (rawValue) => {
+        let cleanValue = rawValue;
+        if (typeof cleanValue === "number") {
+            cleanValue = cleanValue.toString();
+        }
+        if (cleanValue.indexOf(",") >= 0) {
+            cleanValue = cleanValue.split(",")[0];
+        }
+        if (cleanValue.indexOf(":") >= 0) {
+            cleanValue = cleanValue.split(":")[0];
+        }
+        if (cleanValue.indexOf("#") >= 0) {
+            cleanValue = cleanValue.split("#")[1];
+        }
+        return cleanValue;
+    };
+    const headerKey = findKey(output.headers, "x-amzn-errortype");
+    if (headerKey !== undefined) {
+        return sanitizeErrorCode(output.headers[headerKey]);
+    }
+    if (data.code !== undefined) {
+        return sanitizeErrorCode(data.code);
+    }
+    if (data["__type"] !== undefined) {
+        return sanitizeErrorCode(data["__type"]);
+    }
+};

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@aws-sdk/core/dist-es/submodules/protocols/xml/parseXmlBody.js

@@ -0,0 +1,57 @@
+import { getValueFromTextNode } from "@smithy/smithy-client";
+import { XMLParser } from "fast-xml-parser";
+import { collectBodyString } from "../common";
+export const parseXmlBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+    if (encoded.length) {
+        const parser = new XMLParser({
+            attributeNamePrefix: "",
+            htmlEntities: true,
+            ignoreAttributes: false,
+            ignoreDeclaration: true,
+            parseTagValue: false,
+            trimValues: false,
+            tagValueProcessor: (_, val) => (val.trim() === "" && val.includes("\n") ? "" : undefined),
+        });
+        parser.addEntity("#xD", "\r");
+        parser.addEntity("#10", "\n");
+        let parsedObj;
+        try {
+            parsedObj = parser.parse(encoded, true);
+        }
+        catch (e) {
+            if (e && typeof e === "object") {
+                Object.defineProperty(e, "$responseBodyText", {
+                    value: encoded,
+                });
+            }
+            throw e;
+        }
+        const textNodeName = "#text";
+        const key = Object.keys(parsedObj)[0];
+        const parsedObjToReturn = parsedObj[key];
+        if (parsedObjToReturn[textNodeName]) {
+            parsedObjToReturn[key] = parsedObjToReturn[textNodeName];
+            delete parsedObjToReturn[textNodeName];
+        }
+        return getValueFromTextNode(parsedObjToReturn);
+    }
+    return {};
+});
+export const parseXmlErrorBody = async (errorBody, context) => {
+    const value = await parseXmlBody(errorBody, context);
+    if (value.Error) {
+        value.Error.message = value.Error.message ?? value.Error.Message;
+    }
+    return value;
+};
+export const loadRestXmlErrorCode = (output, data) => {
+    if (data?.Error?.Code !== undefined) {
+        return data.Error.Code;
+    }
+    if (data?.Code !== undefined) {
+        return data.Code;
+    }
+    if (output.statusCode == 404) {
+        return "NotFound";
+    }
+};

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@aws-sdk/core/dist-types/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Submodules annotated with "Legacy" are from prior to the submodule system.
+ * They are exported from the package's root index to preserve backwards compatibility.
+ *
+ * New development should go in a proper submodule and not be exported from the root index.
+ */
+/**
+ * Legacy submodule.
+ */
+export * from "./submodules/client/index";
+/**
+ * Legacy submodule.
+ */
+export * from "./submodules/httpAuthSchemes/index";
+/**
+ * Legacy submodule.
+ */
+export * from "./submodules/protocols/index";
+/**
+ * Warning: do not export any additional submodules from the root of this package. See readme.md for
+ * guide on developing submodules.
+ */

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@aws-sdk/core/dist-types/submodules/account-id-endpoint/AccountIdEndpointModeConfigResolver.d.ts

@@ -0,0 +1,30 @@
+import { Provider } from "@smithy/types";
+import { AccountIdEndpointMode } from "./AccountIdEndpointModeConstants";
+/**
+ * @public
+ */
+export interface AccountIdEndpointModeInputConfig {
+    /**
+     * The account ID endpoint mode to use.
+     */
+    accountIdEndpointMode?: AccountIdEndpointMode | Provider<AccountIdEndpointMode>;
+}
+/**
+ * @internal
+ */
+interface PreviouslyResolved {
+}
+/**
+ * @internal
+ */
+export interface AccountIdEndpointModeResolvedConfig {
+    /**
+     * Resolved value for input config {config.accountIdEndpointMode}
+     */
+    accountIdEndpointMode: Provider<AccountIdEndpointMode>;
+}
+/**
+ * @internal
+ */
+export declare const resolveAccountIdEndpointModeConfig: <T>(input: T & AccountIdEndpointModeInputConfig & PreviouslyResolved) => T & AccountIdEndpointModeResolvedConfig;
+export {};

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@aws-sdk/core/dist-types/submodules/account-id-endpoint/AccountIdEndpointModeConstants.d.ts

@@ -0,0 +1,7 @@
+export type AccountIdEndpointMode = "disabled" | "preferred" | "required";
+export declare const DEFAULT_ACCOUNT_ID_ENDPOINT_MODE = "preferred";
+export declare const ACCOUNT_ID_ENDPOINT_MODE_VALUES: AccountIdEndpointMode[];
+/**
+ * @internal
+ */
+export declare function validateAccountIdEndpointMode(value: any): value is AccountIdEndpointMode;

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@aws-sdk/core/dist-types/submodules/account-id-endpoint/NodeAccountIdEndpointModeConfigOptions.d.ts

@@ -0,0 +1,14 @@
+import { LoadedConfigSelectors } from "@smithy/node-config-provider";
+import { AccountIdEndpointMode } from "./AccountIdEndpointModeConstants";
+/**
+ * @internal
+ */
+export declare const ENV_ACCOUNT_ID_ENDPOINT_MODE = "AWS_ACCOUNT_ID_ENDPOINT_MODE";
+/**
+ * @internal
+ */
+export declare const CONFIG_ACCOUNT_ID_ENDPOINT_MODE = "account_id_endpoint_mode";
+/**
+ * @internal
+ */
+export declare const NODE_ACCOUNT_ID_ENDPOINT_MODE_CONFIG_OPTIONS: LoadedConfigSelectors<AccountIdEndpointMode>;

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@aws-sdk/core/dist-types/submodules/account-id-endpoint/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./AccountIdEndpointModeConfigResolver";
+export * from "./AccountIdEndpointModeConstants";
+export * from "./NodeAccountIdEndpointModeConfigOptions";

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@aws-sdk/core/dist-types/submodules/client/emitWarningIfUnsupportedVersion.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @internal
+ *
+ * Emits warning if the provided Node.js version string is
+ * pending deprecation by AWS SDK JSv3.
+ *
+ * @param version - The Node.js version string.
+ */
+export declare const emitWarningIfUnsupportedVersion: (version: string) => void;

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@aws-sdk/core/dist-types/submodules/client/index.d.ts

@@ -0,0 +1 @@
+export * from "./emitWarningIfUnsupportedVersion";

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@aws-sdk/core/dist-types/submodules/httpAuthSchemes/aws_sdk/AwsSdkSigV4ASigner.d.ts

@@ -0,0 +1,10 @@
+import { AwsCredentialIdentity, HttpRequest as IHttpRequest } from "@smithy/types";
+import { AwsSdkSigV4Signer } from "./AwsSdkSigV4Signer";
+/**
+ * @internal
+ * Note: this is not a signing algorithm implementation. The sign method
+ * accepts the real signer as an input parameter.
+ */
+export declare class AwsSdkSigV4ASigner extends AwsSdkSigV4Signer {
+    sign(httpRequest: IHttpRequest, identity: AwsCredentialIdentity, signingProperties: Record<string, unknown>): Promise<IHttpRequest>;
+}

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@aws-sdk/core/dist-types/submodules/httpAuthSchemes/aws_sdk/AwsSdkSigV4Signer.d.ts

@@ -0,0 +1,42 @@
+import { AuthScheme, AwsCredentialIdentity, HttpRequest as IHttpRequest, HttpResponse, HttpSigner, RequestSigner } from "@smithy/types";
+import { AwsSdkSigV4AAuthResolvedConfig } from "./resolveAwsSdkSigV4AConfig";
+/**
+ * @internal
+ */
+interface AwsSdkSigV4Config extends AwsSdkSigV4AAuthResolvedConfig {
+    systemClockOffset: number;
+    signer: (authScheme?: AuthScheme) => Promise<RequestSigner>;
+}
+/**
+ * @internal
+ */
+interface AwsSdkSigV4AuthSigningProperties {
+    config: AwsSdkSigV4Config;
+    signer: RequestSigner;
+    signingRegion?: string;
+    signingRegionSet?: string[];
+    signingName?: string;
+}
+/**
+ * @internal
+ */
+export declare const validateSigningProperties: (signingProperties: Record<string, unknown>) => Promise<AwsSdkSigV4AuthSigningProperties>;
+/**
+ * @internal
+ * Note: this is not a signing algorithm implementation. The sign method
+ * accepts the real signer as an input parameter.
+ */
+export declare class AwsSdkSigV4Signer implements HttpSigner {
+    sign(httpRequest: IHttpRequest, 
+    /**
+     * `identity` is bound in {@link resolveAWSSDKSigV4Config}
+     */
+    identity: AwsCredentialIdentity, signingProperties: Record<string, unknown>): Promise<IHttpRequest>;
+    errorHandler(signingProperties: Record<string, unknown>): (error: Error) => never;
+    successHandler(httpResponse: HttpResponse | unknown, signingProperties: Record<string, unknown>): void;
+}
+/**
+ * @deprecated renamed to {@link AwsSdkSigV4Signer}
+ */
+export declare const AWSSDKSigV4Signer: typeof AwsSdkSigV4Signer;
+export {};

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@aws-sdk/core/dist-types/submodules/httpAuthSchemes/aws_sdk/index.d.ts

@@ -0,0 +1,4 @@
+export { AwsSdkSigV4Signer, AWSSDKSigV4Signer, validateSigningProperties } from "./AwsSdkSigV4Signer";
+export { AwsSdkSigV4ASigner } from "./AwsSdkSigV4ASigner";
+export * from "./resolveAwsSdkSigV4AConfig";
+export * from "./resolveAwsSdkSigV4Config";

package/node_modules/@aws-sdk/client-bedrock-runtime/node_modules/@aws-sdk/core/dist-types/submodules/httpAuthSchemes/aws_sdk/resolveAwsSdkSigV4AConfig.d.ts

@@ -0,0 +1,38 @@
+import { LoadedConfigSelectors } from "@smithy/node-config-provider";
+import { Provider } from "@smithy/types";
+/**
+ * @public
+ */
+export interface AwsSdkSigV4AAuthInputConfig {
+    /**
+     * This option will override the AWS sigv4a
+     * signing regionSet from any other source.
+     *
+     * The lookup order is:
+     * 1. this value
+     * 2. configuration file value of sigv4a_signing_region_set.
+     * 3. environment value of AWS_SIGV4A_SIGNING_REGION_SET.
+     * 4. signingRegionSet given by endpoint resolution.
+     * 5. the singular region of the SDK client.
+     */
+    sigv4aSigningRegionSet?: string[] | undefined | Provider<string[] | undefined>;
+}
+/**
+ * @internal
+ */
+export interface AwsSdkSigV4APreviouslyResolved {
+}
+/**
+ * @internal
+ */
+export interface AwsSdkSigV4AAuthResolvedConfig {
+    sigv4aSigningRegionSet: Provider<string[] | undefined>;
+}
+/**
+ * @internal
+ */
+export declare const resolveAwsSdkSigV4AConfig: <T>(config: T & AwsSdkSigV4AAuthInputConfig & AwsSdkSigV4APreviouslyResolved) => T & AwsSdkSigV4AAuthResolvedConfig;
+/**
+ * @internal
+ */
+export declare const NODE_SIGV4A_CONFIG_OPTIONS: LoadedConfigSelectors<string[] | undefined>;