@ndlib/ndlib-cdk2 1.0.30 → 1.0.32

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/core/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aws-sdk/core",
-  "version": "3.582.0",
-  "description": "Core functions & classes shared by multiple AWS SDK clients",
+  "version": "3.758.0",
+  "description": "Core functions & classes shared by multiple AWS SDK clients.",
   "scripts": {
     "build": "yarn lint && concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
     "build:cjs": "node ../../scripts/compilation/inline core",
@@ -9,40 +9,54 @@
     "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",
-    "lint": "node ./scripts/lint.js",
+    "lint": "node ../../scripts/validation/submodules-linter.js --pkg core",
     "clean": "rimraf ./dist-* && rimraf *.tsbuildinfo",
     "extract:docs": "api-extractor run --local",
-    "test": "jest",
-    "test:integration": "jest -c jest.config.integ.js"
+    "test": "yarn g:vitest run",
+    "test:integration": "yarn g:vitest run -c vitest.config.integ.ts",
+    "test:watch": "yarn g:vitest watch",
+    "test:integration:watch": "yarn g:vitest watch -c vitest.config.integ.ts"
   },
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",
   "types": "./dist-types/index.d.ts",
   "exports": {
     ".": {
+      "module": "./dist-es/index.js",
       "node": "./dist-cjs/index.js",
       "import": "./dist-es/index.js",
       "require": "./dist-cjs/index.js",
       "types": "./dist-types/index.d.ts"
     },
     "./package.json": {
+      "module": "./package.json",
       "node": "./package.json",
       "import": "./package.json",
       "require": "./package.json"
     },
     "./client": {
+      "module": "./dist-es/submodules/client/index.js",
       "node": "./dist-cjs/submodules/client/index.js",
       "import": "./dist-es/submodules/client/index.js",
       "require": "./dist-cjs/submodules/client/index.js",
       "types": "./dist-types/submodules/client/index.d.ts"
     },
     "./httpAuthSchemes": {
+      "module": "./dist-es/submodules/httpAuthSchemes/index.js",
       "node": "./dist-cjs/submodules/httpAuthSchemes/index.js",
       "import": "./dist-es/submodules/httpAuthSchemes/index.js",
       "require": "./dist-cjs/submodules/httpAuthSchemes/index.js",
       "types": "./dist-types/submodules/httpAuthSchemes/index.d.ts"
     },
+    "./account-id-endpoint": {
+      "module": "./dist-es/submodules/account-id-endpoint/index.js",
+      "node": "./dist-cjs/submodules/account-id-endpoint/index.js",
+      "import": "./dist-es/submodules/account-id-endpoint/index.js",
+      "require": "./dist-cjs/submodules/account-id-endpoint/index.js",
+      "types": "./dist-types/submodules/account-id-endpoint/index.d.ts"
+    },
     "./protocols": {
+      "module": "./dist-es/submodules/protocols/index.js",
       "node": "./dist-cjs/submodules/protocols/index.js",
       "import": "./dist-es/submodules/protocols/index.js",
       "require": "./dist-cjs/submodules/protocols/index.js",
@@ -50,10 +64,15 @@
     }
   },
   "files": [
-    "dist-*/**",
+    "./account-id-endpoint.d.ts",
+    "./account-id-endpoint.js",
+    "./client.d.ts",
     "./client.js",
+    "./httpAuthSchemes.d.ts",
     "./httpAuthSchemes.js",
-    "./protocols.js"
+    "./protocols.d.ts",
+    "./protocols.js",
+    "dist-*/**"
   ],
   "sideEffects": false,
   "author": {
@@ -62,12 +81,16 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@smithy/core": "^2.0.1",
-    "@smithy/protocol-http": "^4.0.0",
-    "@smithy/signature-v4": "^3.0.0",
-    "@smithy/smithy-client": "^3.0.1",
-    "@smithy/types": "^3.0.0",
-    "fast-xml-parser": "4.2.5",
+    "@aws-sdk/types": "3.734.0",
+    "@smithy/core": "^3.1.5",
+    "@smithy/node-config-provider": "^4.0.1",
+    "@smithy/property-provider": "^4.0.1",
+    "@smithy/protocol-http": "^5.0.1",
+    "@smithy/signature-v4": "^5.0.1",
+    "@smithy/smithy-client": "^4.1.6",
+    "@smithy/types": "^4.1.0",
+    "@smithy/util-middleware": "^4.0.1",
+    "fast-xml-parser": "4.4.1",
     "tslib": "^2.6.2"
   },
   "devDependencies": {
@@ -75,10 +98,10 @@
     "concurrently": "7.0.0",
     "downlevel-dts": "0.10.1",
     "rimraf": "3.0.2",
-    "typescript": "~4.9.5"
+    "typescript": "~5.2.2"
   },
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=18.0.0"
   },
   "typesVersions": {
     "<4.0": {
@@ -87,7 +110,7 @@
       ]
     }
   },
-  "homepage": "https://github.com/aws/aws-sdk-js-v3/tree/master/packages/core",
+  "homepage": "https://github.com/aws/aws-sdk-js-v3/tree/main/packages/core",
   "repository": {
     "type": "git",
     "url": "https://github.com/aws/aws-sdk-js-v3.git",

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/core/protocols.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Do not edit:
+ * This is a compatibility redirect for contexts that do not understand package.json exports field.
+ */
+declare module "@aws-sdk/core/protocols" {
+  export * from "@aws-sdk/core/dist-types/submodules/protocols/index.d";
+}

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/core/scripts/lint.js

@@ -0,0 +1,24 @@
+const fs = require("fs");
+const path = require("path");
+const assert = require("assert");
+
+const root = path.join(__dirname, "..");
+
+const pkgJson = require(path.join(root, "package.json"));
+const srcFolders = fs.readdirSync(path.join(root, "src"));
+
+assert(pkgJson.exports === undefined, "We cannot support package.json exports yet.");
+
+/**
+ * We probably can't enable package.json exports until
+ * dropping support for Node.js 14.x and TypeScript 4.6.
+ */
+process.exit(0);
+
+for (const srcFolder of srcFolders) {
+  if (fs.lstatSync(path.join(root, "src", srcFolder)).isDirectory()) {
+    if (!pkgJson.exports["./" + srcFolder]) {
+      throw new Error(`${srcFolder} is missing exports statement in package.json`);
+    }
+  }
+}

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/core/src/client/emitWarningIfUnsupportedVersion.spec.ts

@@ -0,0 +1,70 @@
+describe("emitWarningIfUnsupportedVersion", () => {
+  let emitWarningIfUnsupportedVersion;
+  const emitWarning = process.emitWarning;
+  const supportedVersion = "16.0.0";
+
+  beforeEach(() => {
+    const module = require("./emitWarningIfUnsupportedVersion");
+    emitWarningIfUnsupportedVersion = module.emitWarningIfUnsupportedVersion;
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+    jest.resetModules();
+    process.emitWarning = emitWarning;
+  });
+
+  describe(`emits warning for Node.js <${supportedVersion}`, () => {
+    const getPreviousMajorVersion = (major: number) => (major === 0 ? 0 : major - 1);
+
+    const getPreviousMinorVersion = ([major, minor]: [number, number]) =>
+      minor === 0 ? [getPreviousMajorVersion(major), 9] : [major, minor - 1];
+
+    const getPreviousPatchVersion = ([major, minor, patch]: [number, number, number]) =>
+      patch === 0 ? [...getPreviousMinorVersion([major, minor]), 9] : [major, minor, patch - 1];
+
+    const [major, minor, patch] = supportedVersion.split(".").map(Number);
+    it.each(
+      [
+        getPreviousPatchVersion([major, minor, patch]),
+        [...getPreviousMinorVersion([major, minor]), 0],
+        [getPreviousMajorVersion(major), 0, 0],
+      ].map((arr) => `v${arr.join(".")}`)
+    )(`%s`, async (unsupportedVersion) => {
+      process.emitWarning = jest.fn();
+      emitWarningIfUnsupportedVersion(unsupportedVersion);
+
+      // Verify that the warning was emitted.
+      expect(process.emitWarning).toHaveBeenCalledTimes(1);
+      expect(process.emitWarning).toHaveBeenCalledWith(
+        `NodeDeprecationWarning: The AWS SDK for JavaScript (v3) will
+no longer support Node.js 14.x on May 1, 2024.
+
+To continue receiving updates to AWS services, bug fixes, and security
+updates please upgrade to an active Node.js LTS version.
+
+More information can be found at: https://a.co/dzr2AJd`
+      );
+
+      // Verify that the warning emits only once.
+      emitWarningIfUnsupportedVersion(unsupportedVersion);
+      expect(process.emitWarning).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe(`emits no warning for Node.js >=${supportedVersion}`, () => {
+    const [major, minor, patch] = supportedVersion.split(".").map(Number);
+    it.each(
+      [
+        [major, minor, patch],
+        [major, minor, patch + 1],
+        [major, minor + 1, 0],
+        [major + 1, 0, 0],
+      ].map((arr) => `v${arr.join(".")}`)
+    )(`%s`, async (unsupportedVersion) => {
+      process.emitWarning = jest.fn();
+      emitWarningIfUnsupportedVersion(unsupportedVersion);
+      expect(process.emitWarning).not.toHaveBeenCalled();
+    });
+  });
+});

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/core/src/client/emitWarningIfUnsupportedVersion.ts

@@ -0,0 +1,25 @@
+// Stores whether the warning was already emitted.
+let warningEmitted = false;
+
+/**
+ * @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 const emitWarningIfUnsupportedVersion = (version: string) => {
+  if (version && !warningEmitted && parseInt(version.substring(1, version.indexOf("."))) < 16) {
+    warningEmitted = true;
+    process.emitWarning(
+      `NodeDeprecationWarning: The AWS SDK for JavaScript (v3) will
+no longer support Node.js 14.x on May 1, 2024.
+
+To continue receiving updates to AWS services, bug fixes, and security
+updates please upgrade to an active Node.js LTS version.
+
+More information can be found at: https://a.co/dzr2AJd`
+    );
+  }
+};

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/core/src/client/index.ts

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

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/core/src/httpAuthSchemes/aws_sdk/AwsSdkSigV4Signer.spec.ts

@@ -0,0 +1,30 @@
+import { AwsSdkSigV4Signer } from "./AwsSdkSigV4Signer";
+
+describe(AwsSdkSigV4Signer.name, () => {
+  it("sets clockSkewCorrected metadata in error handler if systemClockOffset was updated", async () => {
+    const signer = new AwsSdkSigV4Signer();
+
+    let error: Error | any;
+    try {
+      signer.errorHandler({
+        config: {
+          systemClockOffset: 30 * 60 * 1000,
+        },
+      })(
+        Object.assign(new Error("uh oh"), {
+          $metadata: {},
+          $response: {
+            headers: {
+              date: new Date().toISOString(),
+            },
+            statusCode: 500,
+          },
+        })
+      );
+    } catch (e) {
+      error = e as Error;
+    }
+
+    expect((error as any).$metadata.clockSkewCorrected).toBe(true);
+  });
+});

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/core/src/httpAuthSchemes/aws_sdk/AwsSdkSigV4Signer.ts

@@ -0,0 +1,134 @@
+import { HttpRequest } from "@smithy/protocol-http";
+import { ServiceException } from "@smithy/smithy-client";
+import {
+  AuthScheme,
+  AwsCredentialIdentity,
+  HandlerExecutionContext,
+  HttpRequest as IHttpRequest,
+  HttpResponse,
+  HttpSigner,
+  RequestSigner,
+} from "@smithy/types";
+
+import { getDateHeader, getSkewCorrectedDate, getUpdatedSystemClockOffset } from "../utils";
+
+/**
+ * @internal
+ */
+const throwSigningPropertyError = <T>(name: string, property: T | undefined): T | never => {
+  if (!property) {
+    throw new Error(`Property \`${name}\` is not resolved for AWS SDK SigV4Auth`);
+  }
+  return property;
+};
+
+/**
+ * @internal
+ */
+interface AwsSdkSigV4Config {
+  systemClockOffset: number;
+  signer: (authScheme?: AuthScheme) => Promise<RequestSigner>;
+}
+
+/**
+ * @internal
+ */
+interface AwsSdkSigV4AuthSigningProperties {
+  config: AwsSdkSigV4Config;
+  signer: RequestSigner;
+  signingRegion?: string;
+  signingName?: string;
+}
+
+/**
+ * @internal
+ */
+interface AwsSdkSigV4Exception extends ServiceException {
+  ServerTime?: string;
+  $metadata: ServiceException["$metadata"] & {
+    clockSkewCorrected?: boolean;
+  };
+}
+
+/**
+ * @internal
+ */
+const validateSigningProperties = async (
+  signingProperties: Record<string, unknown>
+): Promise<AwsSdkSigV4AuthSigningProperties> => {
+  const context = throwSigningPropertyError(
+    "context",
+    signingProperties.context as HandlerExecutionContext | undefined
+  );
+  const config = throwSigningPropertyError("config", signingProperties.config as AwsSdkSigV4Config | undefined);
+  const authScheme = context.endpointV2?.properties?.authSchemes?.[0];
+  const signerFunction = throwSigningPropertyError(
+    "signer",
+    config.signer as ((authScheme?: AuthScheme) => Promise<RequestSigner>) | undefined
+  );
+  const signer = await signerFunction(authScheme);
+  const signingRegion: string | undefined = signingProperties?.signingRegion as string | undefined;
+  const signingName = signingProperties?.signingName as string | undefined;
+  return {
+    config,
+    signer,
+    signingRegion,
+    signingName,
+  };
+};
+
+/**
+ * @internal
+ */
+export class AwsSdkSigV4Signer implements HttpSigner {
+  async sign(
+    httpRequest: IHttpRequest,
+    /**
+     * `identity` is bound in {@link resolveAWSSDKSigV4Config}
+     */
+    identity: AwsCredentialIdentity,
+    signingProperties: Record<string, unknown>
+  ): Promise<IHttpRequest> {
+    if (!HttpRequest.isInstance(httpRequest)) {
+      throw new Error("The request is not an instance of `HttpRequest` and cannot be signed");
+    }
+    const { config, signer, signingRegion, signingName } = await validateSigningProperties(signingProperties);
+
+    const signedRequest = await signer.sign(httpRequest, {
+      signingDate: getSkewCorrectedDate(config.systemClockOffset),
+      signingRegion: signingRegion,
+      signingService: signingName,
+    });
+    return signedRequest;
+  }
+
+  errorHandler(signingProperties: Record<string, unknown>): (error: Error) => never {
+    return (error: Error) => {
+      const serverTime: string | undefined =
+        (error as AwsSdkSigV4Exception).ServerTime ?? getDateHeader((error as AwsSdkSigV4Exception).$response);
+      if (serverTime) {
+        const config = throwSigningPropertyError("config", signingProperties.config as AwsSdkSigV4Config | undefined);
+        const initialSystemClockOffset = config.systemClockOffset;
+        config.systemClockOffset = getUpdatedSystemClockOffset(serverTime, config.systemClockOffset);
+        const clockSkewCorrected = config.systemClockOffset !== initialSystemClockOffset;
+        if (clockSkewCorrected && (error as AwsSdkSigV4Exception).$metadata) {
+          (error as AwsSdkSigV4Exception).$metadata.clockSkewCorrected = true;
+        }
+      }
+      throw error;
+    };
+  }
+
+  successHandler(httpResponse: HttpResponse | unknown, signingProperties: Record<string, unknown>): void {
+    const dateHeader = getDateHeader(httpResponse);
+    if (dateHeader) {
+      const config = throwSigningPropertyError("config", signingProperties.config as AwsSdkSigV4Config | undefined);
+      config.systemClockOffset = getUpdatedSystemClockOffset(dateHeader, config.systemClockOffset);
+    }
+  }
+}
+
+/**
+ * @deprecated renamed to {@link AwsSdkSigV4Signer}
+ */
+export const AWSSDKSigV4Signer = AwsSdkSigV4Signer;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/core/src/httpAuthSchemes/aws_sdk/index.ts

@@ -0,0 +1,2 @@
+export * from "./AwsSdkSigV4Signer";
+export * from "./resolveAwsSdkSigV4Config";

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/core/src/httpAuthSchemes/aws_sdk/resolveAwsSdkSigV4Config.ts

@@ -0,0 +1,244 @@
+import {
+  doesIdentityRequireRefresh,
+  isIdentityExpired,
+  memoizeIdentityProvider,
+  normalizeProvider,
+} from "@smithy/core";
+import { SignatureV4, SignatureV4CryptoInit, SignatureV4Init } from "@smithy/signature-v4";
+import {
+  AuthScheme,
+  AwsCredentialIdentity,
+  AwsCredentialIdentityProvider,
+  ChecksumConstructor,
+  HashConstructor,
+  MemoizedProvider,
+  Provider,
+  RegionInfo,
+  RegionInfoProvider,
+  RequestSigner,
+} from "@smithy/types";
+
+/**
+ * @internal
+ */
+export interface AwsSdkSigV4AuthInputConfig {
+  /**
+   * The credentials used to sign requests.
+   */
+  credentials?: AwsCredentialIdentity | AwsCredentialIdentityProvider;
+
+  /**
+   * The signer to use when signing requests.
+   */
+  signer?: RequestSigner | ((authScheme?: AuthScheme) => Promise<RequestSigner>);
+
+  /**
+   * Whether to escape request path when signing the request.
+   */
+  signingEscapePath?: boolean;
+
+  /**
+   * An offset value in milliseconds to apply to all signing times.
+   */
+  systemClockOffset?: number;
+
+  /**
+   * The region where you want to sign your request against. This
+   * can be different to the region in the endpoint.
+   */
+  signingRegion?: string;
+
+  /**
+   * The injectable SigV4-compatible signer class constructor. If not supplied,
+   * regular SignatureV4 constructor will be used.
+   *
+   * @internal
+   */
+  signerConstructor?: new (options: SignatureV4Init & SignatureV4CryptoInit) => RequestSigner;
+}
+
+/**
+ * @internal
+ */
+export interface AwsSdkSigV4PreviouslyResolved {
+  credentialDefaultProvider?: (input: any) => MemoizedProvider<AwsCredentialIdentity>;
+  region: string | Provider<string>;
+  sha256: ChecksumConstructor | HashConstructor;
+  signingName?: string;
+  regionInfoProvider?: RegionInfoProvider;
+  defaultSigningName?: string;
+  serviceId: string;
+  useFipsEndpoint: Provider<boolean>;
+  useDualstackEndpoint: Provider<boolean>;
+}
+
+/**
+ * @internal
+ */
+export interface AwsSdkSigV4AuthResolvedConfig {
+  /**
+   * Resolved value for input config {@link AwsSdkSigV4AuthInputConfig.credentials}
+   * This provider MAY memoize the loaded credentials for certain period.
+   * See {@link MemoizedProvider} for more information.
+   */
+  credentials: AwsCredentialIdentityProvider;
+  /**
+   * Resolved value for input config {@link AwsSdkSigV4AuthInputConfig.signer}
+   */
+  signer: (authScheme?: AuthScheme) => Promise<RequestSigner>;
+  /**
+   * Resolved value for input config {@link AwsSdkSigV4AuthInputConfig.signingEscapePath}
+   */
+  signingEscapePath: boolean;
+  /**
+   * Resolved value for input config {@link AwsSdkSigV4AuthInputConfig.systemClockOffset}
+   */
+  systemClockOffset: number;
+}
+
+/**
+ * @internal
+ */
+export const resolveAwsSdkSigV4Config = <T>(
+  config: T & AwsSdkSigV4AuthInputConfig & AwsSdkSigV4PreviouslyResolved
+): T & AwsSdkSigV4AuthResolvedConfig => {
+  // Normalize credentials
+  let normalizedCreds: AwsCredentialIdentityProvider | undefined;
+  if (config.credentials) {
+    normalizedCreds = memoizeIdentityProvider(config.credentials, isIdentityExpired, doesIdentityRequireRefresh);
+  }
+  if (!normalizedCreds) {
+    // credentialDefaultProvider should always be populated, but in case
+    // it isn't, set a default identity provider that throws an error
+    if (config.credentialDefaultProvider) {
+      normalizedCreds = normalizeProvider(
+        config.credentialDefaultProvider(
+          Object.assign({}, config as any, {
+            parentClientConfig: config,
+          })
+        )
+      );
+    } else {
+      normalizedCreds = async () => {
+        throw new Error("`credentials` is missing");
+      };
+    }
+  }
+
+  // Populate sigv4 arguments
+  const {
+    // Default for signingEscapePath
+    signingEscapePath = true,
+    // Default for systemClockOffset
+    systemClockOffset = config.systemClockOffset || 0,
+    // No default for sha256 since it is platform dependent
+    sha256,
+  } = config;
+
+  // Resolve signer
+  let signer: (authScheme?: AuthScheme) => Promise<RequestSigner>;
+  if (config.signer) {
+    // if signer is supplied by user, normalize it to a function returning a promise for signer.
+    signer = normalizeProvider(config.signer);
+  } else if (config.regionInfoProvider) {
+    // This branch is for endpoints V1.
+    // construct a provider inferring signing from region.
+    signer = () =>
+      normalizeProvider(config.region)()
+        .then(
+          async (region) =>
+            [
+              (await config.regionInfoProvider!(region, {
+                useFipsEndpoint: await config.useFipsEndpoint(),
+                useDualstackEndpoint: await config.useDualstackEndpoint(),
+              })) || {},
+              region,
+            ] as [RegionInfo, string]
+        )
+        .then(([regionInfo, region]) => {
+          const { signingRegion, signingService } = regionInfo;
+          // update client's singing region and signing service config if they are resolved.
+          // signing region resolving order: user supplied signingRegion -> endpoints.json inferred region -> client region
+          config.signingRegion = config.signingRegion || signingRegion || region;
+          // signing name resolving order:
+          // user supplied signingName -> endpoints.json inferred (credential scope -> model arnNamespace) -> model service id
+          config.signingName = config.signingName || signingService || config.serviceId;
+
+          const params: SignatureV4Init & SignatureV4CryptoInit = {
+            ...config,
+            credentials: normalizedCreds!,
+            region: config.signingRegion,
+            service: config.signingName,
+            sha256,
+            uriEscapePath: signingEscapePath,
+          };
+          const SignerCtor = config.signerConstructor || SignatureV4;
+          return new SignerCtor(params);
+        });
+  } else {
+    // This branch is for endpoints V2.
+    // Handle endpoints v2 that resolved per-command
+    // TODO: need total refactor for reference auth architecture.
+    signer = async (authScheme?: 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;
+      // update client's singing region and signing service config if they are resolved.
+      // signing region resolving order: user supplied signingRegion -> endpoints.json inferred region -> client region
+      config.signingRegion = config.signingRegion || signingRegion;
+      // signing name resolving order:
+      // user supplied signingName -> endpoints.json inferred (credential scope -> model arnNamespace) -> model service id
+      config.signingName = config.signingName || signingService || config.serviceId;
+
+      const params: SignatureV4Init & SignatureV4CryptoInit = {
+        ...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,
+  };
+};
+
+/**
+ * @deprecated renamed to {@link AwsSdkSigV4AuthInputConfig}
+ */
+export interface AWSSDKSigV4AuthInputConfig extends AwsSdkSigV4AuthInputConfig {}
+
+/**
+ * @deprecated renamed to {@link AwsSdkSigV4PreviouslyResolved}
+ */
+export interface AWSSDKSigV4PreviouslyResolved extends AwsSdkSigV4PreviouslyResolved {}
+
+/**
+ * @deprecated renamed to {@link AwsSdkSigV4AuthResolvedConfig}
+ */
+export interface AWSSDKSigV4AuthResolvedConfig extends AwsSdkSigV4AuthResolvedConfig {}
+
+/**
+ * @deprecated renamed to {@link resolveAwsSdkSigV4Config}
+ */
+export const resolveAWSSDKSigV4Config = resolveAwsSdkSigV4Config;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/core/src/httpAuthSchemes/index.ts

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