@ndlib/ndlib-cdk2 1.0.18 → 1.0.20

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-cjs/adaptors/getEndpointFromInstructions.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveParams = exports.getEndpointFromInstructions = void 0;
+const service_customizations_1 = require("../service-customizations");
+const createConfigValueProvider_1 = require("./createConfigValueProvider");
+const getEndpointFromConfig_1 = require("./getEndpointFromConfig");
+const toEndpointV1_1 = require("./toEndpointV1");
+const getEndpointFromInstructions = async (commandInput, instructionsSupplier, clientConfig, context) => {
+    if (!clientConfig.endpoint) {
+        const endpointFromConfig = await (0, getEndpointFromConfig_1.getEndpointFromConfig)(clientConfig.serviceId || "");
+        if (endpointFromConfig) {
+            clientConfig.endpoint = () => Promise.resolve((0, toEndpointV1_1.toEndpointV1)(endpointFromConfig));
+        }
+    }
+    const endpointParams = await (0, exports.resolveParams)(commandInput, instructionsSupplier, clientConfig);
+    if (typeof clientConfig.endpointProvider !== "function") {
+        throw new Error("config.endpointProvider is not set.");
+    }
+    const endpoint = clientConfig.endpointProvider(endpointParams, context);
+    return endpoint;
+};
+exports.getEndpointFromInstructions = getEndpointFromInstructions;
+const resolveParams = async (commandInput, instructionsSupplier, clientConfig) => {
+    var _a;
+    const endpointParams = {};
+    const instructions = ((_a = instructionsSupplier === null || instructionsSupplier === void 0 ? void 0 : instructionsSupplier.getEndpointParameterInstructions) === null || _a === void 0 ? void 0 : _a.call(instructionsSupplier)) || {};
+    for (const [name, instruction] of Object.entries(instructions)) {
+        switch (instruction.type) {
+            case "staticContextParams":
+                endpointParams[name] = instruction.value;
+                break;
+            case "contextParams":
+                endpointParams[name] = commandInput[instruction.name];
+                break;
+            case "clientContextParams":
+            case "builtInParams":
+                endpointParams[name] = await (0, createConfigValueProvider_1.createConfigValueProvider)(instruction.name, name, clientConfig)();
+                break;
+            default:
+                throw new Error("Unrecognized endpoint parameter instruction: " + JSON.stringify(instruction));
+        }
+    }
+    if (Object.keys(instructions).length === 0) {
+        Object.assign(endpointParams, clientConfig);
+    }
+    if (String(clientConfig.serviceId).toLowerCase() === "s3") {
+        await (0, service_customizations_1.resolveParamsForS3)(endpointParams);
+    }
+    return endpointParams;
+};
+exports.resolveParams = resolveParams;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-cjs/adaptors/getEndpointUrlConfig.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEndpointUrlConfig = void 0;
+const shared_ini_file_loader_1 = require("@smithy/shared-ini-file-loader");
+const ENV_ENDPOINT_URL = "AWS_ENDPOINT_URL";
+const CONFIG_ENDPOINT_URL = "endpoint_url";
+const getEndpointUrlConfig = (serviceId) => ({
+    environmentVariableSelector: (env) => {
+        const serviceSuffixParts = serviceId.split(" ").map((w) => w.toUpperCase());
+        const serviceEndpointUrl = env[[ENV_ENDPOINT_URL, ...serviceSuffixParts].join("_")];
+        if (serviceEndpointUrl)
+            return serviceEndpointUrl;
+        const endpointUrl = env[ENV_ENDPOINT_URL];
+        if (endpointUrl)
+            return endpointUrl;
+        return undefined;
+    },
+    configFileSelector: (profile, config) => {
+        if (config && profile.services) {
+            const servicesSection = config[["services", profile.services].join(shared_ini_file_loader_1.CONFIG_PREFIX_SEPARATOR)];
+            if (servicesSection) {
+                const servicePrefixParts = serviceId.split(" ").map((w) => w.toLowerCase());
+                const endpointUrl = servicesSection[[servicePrefixParts.join("_"), CONFIG_ENDPOINT_URL].join(shared_ini_file_loader_1.CONFIG_PREFIX_SEPARATOR)];
+                if (endpointUrl)
+                    return endpointUrl;
+            }
+        }
+        const endpointUrl = profile[CONFIG_ENDPOINT_URL];
+        if (endpointUrl)
+            return endpointUrl;
+        return undefined;
+    },
+    default: undefined,
+});
+exports.getEndpointUrlConfig = getEndpointUrlConfig;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-cjs/adaptors/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./getEndpointFromInstructions"), exports);
+tslib_1.__exportStar(require("./toEndpointV1"), exports);

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-cjs/adaptors/toEndpointV1.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toEndpointV1 = void 0;
+const url_parser_1 = require("@smithy/url-parser");
+const toEndpointV1 = (endpoint) => {
+    if (typeof endpoint === "object") {
+        if ("url" in endpoint) {
+            return (0, url_parser_1.parseUrl)(endpoint.url);
+        }
+        return endpoint;
+    }
+    return (0, url_parser_1.parseUrl)(endpoint);
+};
+exports.toEndpointV1 = toEndpointV1;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-cjs/endpointMiddleware.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.endpointMiddleware = void 0;
+const util_middleware_1 = require("@smithy/util-middleware");
+const getEndpointFromInstructions_1 = require("./adaptors/getEndpointFromInstructions");
+const endpointMiddleware = ({ config, instructions, }) => {
+    return (next, context) => async (args) => {
+        var _a, _b, _c;
+        const endpoint = await (0, getEndpointFromInstructions_1.getEndpointFromInstructions)(args.input, {
+            getEndpointParameterInstructions() {
+                return instructions;
+            },
+        }, { ...config }, context);
+        context.endpointV2 = endpoint;
+        context.authSchemes = (_a = endpoint.properties) === null || _a === void 0 ? void 0 : _a.authSchemes;
+        const authScheme = (_b = context.authSchemes) === null || _b === void 0 ? void 0 : _b[0];
+        if (authScheme) {
+            context["signing_region"] = authScheme.signingRegion;
+            context["signing_service"] = authScheme.signingName;
+            const smithyContext = (0, util_middleware_1.getSmithyContext)(context);
+            const httpAuthOption = (_c = smithyContext === null || smithyContext === void 0 ? void 0 : smithyContext.selectedHttpAuthScheme) === null || _c === void 0 ? void 0 : _c.httpAuthOption;
+            if (httpAuthOption) {
+                httpAuthOption.signingProperties = Object.assign(httpAuthOption.signingProperties || {}, {
+                    signing_region: authScheme.signingRegion,
+                    signingRegion: authScheme.signingRegion,
+                    signing_service: authScheme.signingName,
+                    signingName: authScheme.signingName,
+                    signingRegionSet: authScheme.signingRegionSet,
+                }, authScheme.properties);
+            }
+        }
+        return next({
+            ...args,
+        });
+    };
+};
+exports.endpointMiddleware = endpointMiddleware;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-cjs/getEndpointPlugin.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEndpointPlugin = exports.endpointMiddlewareOptions = void 0;
+const middleware_serde_1 = require("@smithy/middleware-serde");
+const endpointMiddleware_1 = require("./endpointMiddleware");
+exports.endpointMiddlewareOptions = {
+    step: "serialize",
+    tags: ["ENDPOINT_PARAMETERS", "ENDPOINT_V2", "ENDPOINT"],
+    name: "endpointV2Middleware",
+    override: true,
+    relation: "before",
+    toMiddleware: middleware_serde_1.serializerMiddlewareOption.name,
+};
+const getEndpointPlugin = (config, instructions) => ({
+    applyToStack: (clientStack) => {
+        clientStack.addRelativeTo((0, endpointMiddleware_1.endpointMiddleware)({
+            config,
+            instructions,
+        }), exports.endpointMiddlewareOptions);
+    },
+});
+exports.getEndpointPlugin = getEndpointPlugin;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-cjs/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./adaptors"), exports);
+tslib_1.__exportStar(require("./endpointMiddleware"), exports);
+tslib_1.__exportStar(require("./getEndpointPlugin"), exports);
+tslib_1.__exportStar(require("./resolveEndpointConfig"), exports);
+tslib_1.__exportStar(require("./types"), exports);

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-cjs/resolveEndpointConfig.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveEndpointConfig = void 0;
+const util_middleware_1 = require("@smithy/util-middleware");
+const toEndpointV1_1 = require("./adaptors/toEndpointV1");
+const resolveEndpointConfig = (input) => {
+    var _a, _b, _c;
+    const tls = (_a = input.tls) !== null && _a !== void 0 ? _a : true;
+    const { endpoint } = input;
+    const customEndpointProvider = endpoint != null ? async () => (0, toEndpointV1_1.toEndpointV1)(await (0, util_middleware_1.normalizeProvider)(endpoint)()) : undefined;
+    const isCustomEndpoint = !!endpoint;
+    return {
+        ...input,
+        endpoint: customEndpointProvider,
+        tls,
+        isCustomEndpoint,
+        useDualstackEndpoint: (0, util_middleware_1.normalizeProvider)((_b = input.useDualstackEndpoint) !== null && _b !== void 0 ? _b : false),
+        useFipsEndpoint: (0, util_middleware_1.normalizeProvider)((_c = input.useFipsEndpoint) !== null && _c !== void 0 ? _c : false),
+    };
+};
+exports.resolveEndpointConfig = resolveEndpointConfig;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-cjs/service-customizations/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./s3"), exports);

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-cjs/service-customizations/s3.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isArnBucketName = exports.isDnsCompatibleBucketName = exports.S3_HOSTNAME_PATTERN = exports.DOT_PATTERN = exports.resolveParamsForS3 = void 0;
+const resolveParamsForS3 = async (endpointParams) => {
+    const bucket = (endpointParams === null || endpointParams === void 0 ? void 0 : endpointParams.Bucket) || "";
+    if (typeof endpointParams.Bucket === "string") {
+        endpointParams.Bucket = bucket.replace(/#/g, encodeURIComponent("#")).replace(/\?/g, encodeURIComponent("?"));
+    }
+    if ((0, exports.isArnBucketName)(bucket)) {
+        if (endpointParams.ForcePathStyle === true) {
+            throw new Error("Path-style addressing cannot be used with ARN buckets");
+        }
+    }
+    else if (!(0, exports.isDnsCompatibleBucketName)(bucket) ||
+        (bucket.indexOf(".") !== -1 && !String(endpointParams.Endpoint).startsWith("http:")) ||
+        bucket.toLowerCase() !== bucket ||
+        bucket.length < 3) {
+        endpointParams.ForcePathStyle = true;
+    }
+    if (endpointParams.DisableMultiRegionAccessPoints) {
+        endpointParams.disableMultiRegionAccessPoints = true;
+        endpointParams.DisableMRAP = true;
+    }
+    return endpointParams;
+};
+exports.resolveParamsForS3 = resolveParamsForS3;
+const DOMAIN_PATTERN = /^[a-z0-9][a-z0-9\.\-]{1,61}[a-z0-9]$/;
+const IP_ADDRESS_PATTERN = /(\d+\.){3}\d+/;
+const DOTS_PATTERN = /\.\./;
+exports.DOT_PATTERN = /\./;
+exports.S3_HOSTNAME_PATTERN = /^(.+\.)?s3(-fips)?(\.dualstack)?[.-]([a-z0-9-]+)\./;
+const isDnsCompatibleBucketName = (bucketName) => DOMAIN_PATTERN.test(bucketName) && !IP_ADDRESS_PATTERN.test(bucketName) && !DOTS_PATTERN.test(bucketName);
+exports.isDnsCompatibleBucketName = isDnsCompatibleBucketName;
+const isArnBucketName = (bucketName) => {
+    const [arn, partition, service, region, account, typeOrId] = bucketName.split(":");
+    const isArn = arn === "arn" && bucketName.split(":").length >= 6;
+    const isValidArn = [arn, partition, service, account, typeOrId].filter(Boolean).length === 5;
+    if (isArn && !isValidArn) {
+        throw new Error(`Invalid ARN: ${bucketName} was an invalid ARN.`);
+    }
+    return arn === "arn" && !!partition && !!service && !!account && !!typeOrId;
+};
+exports.isArnBucketName = isArnBucketName;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/createConfigValueProvider.js

@@ -0,0 +1,25 @@
+export const createConfigValueProvider = (configKey, canonicalEndpointParamKey, config) => {
+    const configProvider = async () => {
+        const configValue = config[configKey] ?? config[canonicalEndpointParamKey];
+        if (typeof configValue === "function") {
+            return configValue();
+        }
+        return configValue;
+    };
+    if (configKey === "endpoint" || canonicalEndpointParamKey === "endpoint") {
+        return async () => {
+            const endpoint = await configProvider();
+            if (endpoint && typeof endpoint === "object") {
+                if ("url" in endpoint) {
+                    return endpoint.url.href;
+                }
+                if ("hostname" in endpoint) {
+                    const { protocol, hostname, port, path } = endpoint;
+                    return `${protocol}//${hostname}${port ? ":" + port : ""}${path}`;
+                }
+            }
+            return endpoint;
+        };
+    }
+    return configProvider;
+};

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/getEndpointFromConfig.browser.js

@@ -0,0 +1 @@
+export const getEndpointFromConfig = async (serviceId) => undefined;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/getEndpointFromConfig.js

@@ -0,0 +1,3 @@
+import { loadConfig } from "@smithy/node-config-provider";
+import { getEndpointUrlConfig } from "./getEndpointUrlConfig";
+export const getEndpointFromConfig = async (serviceId) => loadConfig(getEndpointUrlConfig(serviceId))();

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/getEndpointFromInstructions.js

@@ -0,0 +1,45 @@
+import { resolveParamsForS3 } from "../service-customizations";
+import { createConfigValueProvider } from "./createConfigValueProvider";
+import { getEndpointFromConfig } from "./getEndpointFromConfig";
+import { toEndpointV1 } from "./toEndpointV1";
+export const getEndpointFromInstructions = async (commandInput, instructionsSupplier, clientConfig, context) => {
+    if (!clientConfig.endpoint) {
+        const endpointFromConfig = await getEndpointFromConfig(clientConfig.serviceId || "");
+        if (endpointFromConfig) {
+            clientConfig.endpoint = () => Promise.resolve(toEndpointV1(endpointFromConfig));
+        }
+    }
+    const endpointParams = await resolveParams(commandInput, instructionsSupplier, clientConfig);
+    if (typeof clientConfig.endpointProvider !== "function") {
+        throw new Error("config.endpointProvider is not set.");
+    }
+    const endpoint = clientConfig.endpointProvider(endpointParams, context);
+    return endpoint;
+};
+export const resolveParams = async (commandInput, instructionsSupplier, clientConfig) => {
+    const endpointParams = {};
+    const instructions = instructionsSupplier?.getEndpointParameterInstructions?.() || {};
+    for (const [name, instruction] of Object.entries(instructions)) {
+        switch (instruction.type) {
+            case "staticContextParams":
+                endpointParams[name] = instruction.value;
+                break;
+            case "contextParams":
+                endpointParams[name] = commandInput[instruction.name];
+                break;
+            case "clientContextParams":
+            case "builtInParams":
+                endpointParams[name] = await createConfigValueProvider(instruction.name, name, clientConfig)();
+                break;
+            default:
+                throw new Error("Unrecognized endpoint parameter instruction: " + JSON.stringify(instruction));
+        }
+    }
+    if (Object.keys(instructions).length === 0) {
+        Object.assign(endpointParams, clientConfig);
+    }
+    if (String(clientConfig.serviceId).toLowerCase() === "s3") {
+        await resolveParamsForS3(endpointParams);
+    }
+    return endpointParams;
+};

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/getEndpointUrlConfig.js

@@ -0,0 +1,31 @@
+import { CONFIG_PREFIX_SEPARATOR } from "@smithy/shared-ini-file-loader";
+const ENV_ENDPOINT_URL = "AWS_ENDPOINT_URL";
+const CONFIG_ENDPOINT_URL = "endpoint_url";
+export const getEndpointUrlConfig = (serviceId) => ({
+    environmentVariableSelector: (env) => {
+        const serviceSuffixParts = serviceId.split(" ").map((w) => w.toUpperCase());
+        const serviceEndpointUrl = env[[ENV_ENDPOINT_URL, ...serviceSuffixParts].join("_")];
+        if (serviceEndpointUrl)
+            return serviceEndpointUrl;
+        const endpointUrl = env[ENV_ENDPOINT_URL];
+        if (endpointUrl)
+            return endpointUrl;
+        return undefined;
+    },
+    configFileSelector: (profile, config) => {
+        if (config && profile.services) {
+            const servicesSection = config[["services", profile.services].join(CONFIG_PREFIX_SEPARATOR)];
+            if (servicesSection) {
+                const servicePrefixParts = serviceId.split(" ").map((w) => w.toLowerCase());
+                const endpointUrl = servicesSection[[servicePrefixParts.join("_"), CONFIG_ENDPOINT_URL].join(CONFIG_PREFIX_SEPARATOR)];
+                if (endpointUrl)
+                    return endpointUrl;
+            }
+        }
+        const endpointUrl = profile[CONFIG_ENDPOINT_URL];
+        if (endpointUrl)
+            return endpointUrl;
+        return undefined;
+    },
+    default: undefined,
+});

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/index.js

@@ -0,0 +1,2 @@
+export * from "./getEndpointFromInstructions";
+export * from "./toEndpointV1";

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/toEndpointV1.js

@@ -0,0 +1,10 @@
+import { parseUrl } from "@smithy/url-parser";
+export const toEndpointV1 = (endpoint) => {
+    if (typeof endpoint === "object") {
+        if ("url" in endpoint) {
+            return parseUrl(endpoint.url);
+        }
+        return endpoint;
+    }
+    return parseUrl(endpoint);
+};

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-es/endpointMiddleware.js

@@ -0,0 +1,32 @@
+import { getSmithyContext } from "@smithy/util-middleware";
+import { getEndpointFromInstructions } from "./adaptors/getEndpointFromInstructions";
+export const endpointMiddleware = ({ config, instructions, }) => {
+    return (next, context) => async (args) => {
+        const endpoint = await getEndpointFromInstructions(args.input, {
+            getEndpointParameterInstructions() {
+                return instructions;
+            },
+        }, { ...config }, context);
+        context.endpointV2 = endpoint;
+        context.authSchemes = endpoint.properties?.authSchemes;
+        const authScheme = context.authSchemes?.[0];
+        if (authScheme) {
+            context["signing_region"] = authScheme.signingRegion;
+            context["signing_service"] = authScheme.signingName;
+            const smithyContext = getSmithyContext(context);
+            const httpAuthOption = smithyContext?.selectedHttpAuthScheme?.httpAuthOption;
+            if (httpAuthOption) {
+                httpAuthOption.signingProperties = Object.assign(httpAuthOption.signingProperties || {}, {
+                    signing_region: authScheme.signingRegion,
+                    signingRegion: authScheme.signingRegion,
+                    signing_service: authScheme.signingName,
+                    signingName: authScheme.signingName,
+                    signingRegionSet: authScheme.signingRegionSet,
+                }, authScheme.properties);
+            }
+        }
+        return next({
+            ...args,
+        });
+    };
+};

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-es/getEndpointPlugin.js

@@ -0,0 +1,18 @@
+import { serializerMiddlewareOption } from "@smithy/middleware-serde";
+import { endpointMiddleware } from "./endpointMiddleware";
+export const endpointMiddlewareOptions = {
+    step: "serialize",
+    tags: ["ENDPOINT_PARAMETERS", "ENDPOINT_V2", "ENDPOINT"],
+    name: "endpointV2Middleware",
+    override: true,
+    relation: "before",
+    toMiddleware: serializerMiddlewareOption.name,
+};
+export const getEndpointPlugin = (config, instructions) => ({
+    applyToStack: (clientStack) => {
+        clientStack.addRelativeTo(endpointMiddleware({
+            config,
+            instructions,
+        }), endpointMiddlewareOptions);
+    },
+});

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-es/index.js

@@ -0,0 +1,5 @@
+export * from "./adaptors";
+export * from "./endpointMiddleware";
+export * from "./getEndpointPlugin";
+export * from "./resolveEndpointConfig";
+export * from "./types";

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-es/resolveEndpointConfig.js

@@ -0,0 +1,16 @@
+import { normalizeProvider } from "@smithy/util-middleware";
+import { toEndpointV1 } from "./adaptors/toEndpointV1";
+export const resolveEndpointConfig = (input) => {
+    const tls = input.tls ?? true;
+    const { endpoint } = input;
+    const customEndpointProvider = endpoint != null ? async () => toEndpointV1(await normalizeProvider(endpoint)()) : undefined;
+    const isCustomEndpoint = !!endpoint;
+    return {
+        ...input,
+        endpoint: customEndpointProvider,
+        tls,
+        isCustomEndpoint,
+        useDualstackEndpoint: normalizeProvider(input.useDualstackEndpoint ?? false),
+        useFipsEndpoint: normalizeProvider(input.useFipsEndpoint ?? false),
+    };
+};

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-es/service-customizations/index.js

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

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-es/service-customizations/s3.js

@@ -0,0 +1,37 @@
+export const resolveParamsForS3 = async (endpointParams) => {
+    const bucket = endpointParams?.Bucket || "";
+    if (typeof endpointParams.Bucket === "string") {
+        endpointParams.Bucket = bucket.replace(/#/g, encodeURIComponent("#")).replace(/\?/g, encodeURIComponent("?"));
+    }
+    if (isArnBucketName(bucket)) {
+        if (endpointParams.ForcePathStyle === true) {
+            throw new Error("Path-style addressing cannot be used with ARN buckets");
+        }
+    }
+    else if (!isDnsCompatibleBucketName(bucket) ||
+        (bucket.indexOf(".") !== -1 && !String(endpointParams.Endpoint).startsWith("http:")) ||
+        bucket.toLowerCase() !== bucket ||
+        bucket.length < 3) {
+        endpointParams.ForcePathStyle = true;
+    }
+    if (endpointParams.DisableMultiRegionAccessPoints) {
+        endpointParams.disableMultiRegionAccessPoints = true;
+        endpointParams.DisableMRAP = true;
+    }
+    return endpointParams;
+};
+const DOMAIN_PATTERN = /^[a-z0-9][a-z0-9\.\-]{1,61}[a-z0-9]$/;
+const IP_ADDRESS_PATTERN = /(\d+\.){3}\d+/;
+const DOTS_PATTERN = /\.\./;
+export const DOT_PATTERN = /\./;
+export const S3_HOSTNAME_PATTERN = /^(.+\.)?s3(-fips)?(\.dualstack)?[.-]([a-z0-9-]+)\./;
+export const isDnsCompatibleBucketName = (bucketName) => DOMAIN_PATTERN.test(bucketName) && !IP_ADDRESS_PATTERN.test(bucketName) && !DOTS_PATTERN.test(bucketName);
+export const isArnBucketName = (bucketName) => {
+    const [arn, partition, service, region, account, typeOrId] = bucketName.split(":");
+    const isArn = arn === "arn" && bucketName.split(":").length >= 6;
+    const isValidArn = [arn, partition, service, account, typeOrId].filter(Boolean).length === 5;
+    if (isArn && !isValidArn) {
+        throw new Error(`Invalid ARN: ${bucketName} was an invalid ARN.`);
+    }
+    return arn === "arn" && !!partition && !!service && !!account && !!typeOrId;
+};

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-es/types.js

@@ -0,0 +1 @@
+export {};

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-types/adaptors/createConfigValueProvider.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Normalize some key of the client config to an async provider.
+ * @internal
+ *
+ * @param configKey - the key to look up in config.
+ * @param canonicalEndpointParamKey - this is the name the EndpointRuleSet uses.
+ *                                    it will most likely not contain the config
+ *                                    value, but we use it as a fallback.
+ * @param config - container of the config values.
+ *
+ * @returns async function that will resolve with the value.
+ */
+export declare const createConfigValueProvider: <Config extends Record<string, unknown>>(configKey: string, canonicalEndpointParamKey: string, config: Config) => () => Promise<any>;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-types/adaptors/getEndpointFromConfig.browser.d.ts

@@ -0,0 +1 @@
+export declare const getEndpointFromConfig: (serviceId: string) => Promise<undefined>;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-types/adaptors/getEndpointFromConfig.d.ts

@@ -0,0 +1 @@
+export declare const getEndpointFromConfig: (serviceId: string) => Promise<string | undefined>;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-types/adaptors/getEndpointFromInstructions.d.ts

@@ -0,0 +1,28 @@
+import { EndpointParameters, EndpointV2, HandlerExecutionContext } from "@smithy/types";
+import { EndpointResolvedConfig } from "../resolveEndpointConfig";
+import { EndpointParameterInstructions } from "../types";
+/**
+ * @internal
+ */
+export type EndpointParameterInstructionsSupplier = Partial<{
+    getEndpointParameterInstructions(): EndpointParameterInstructions;
+}>;
+/**
+ * This step in the endpoint resolution process is exposed as a function
+ * to allow packages such as signers, lib-upload, etc. to get
+ * the V2 Endpoint associated to an instance of some api operation command
+ * without needing to send it or resolve its middleware stack.
+ *
+ * @internal
+ * @param commandInput         - the input of the Command in question.
+ * @param instructionsSupplier - this is typically a Command constructor. A static function supplying the
+ *                               endpoint parameter instructions will exist for commands in services
+ *                               having an endpoints ruleset trait.
+ * @param clientConfig         - config of the service client.
+ * @param context              - optional context.
+ */
+export declare const getEndpointFromInstructions: <T extends EndpointParameters, CommandInput extends Record<string, unknown>, Config extends Record<string, unknown>>(commandInput: CommandInput, instructionsSupplier: EndpointParameterInstructionsSupplier, clientConfig: Partial<EndpointResolvedConfig<T>> & Config, context?: HandlerExecutionContext) => Promise<EndpointV2>;
+/**
+ * @internal
+ */
+export declare const resolveParams: <T extends EndpointParameters, CommandInput extends Record<string, unknown>, Config extends Record<string, unknown>>(commandInput: CommandInput, instructionsSupplier: EndpointParameterInstructionsSupplier, clientConfig: Partial<EndpointResolvedConfig<T>> & Config) => Promise<EndpointParameters>;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-types/adaptors/getEndpointUrlConfig.d.ts

@@ -0,0 +1,2 @@
+import { LoadedConfigSelectors } from "@smithy/node-config-provider";
+export declare const getEndpointUrlConfig: (serviceId: string) => LoadedConfigSelectors<string | undefined>;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-types/adaptors/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @internal
+ */
+export * from "./getEndpointFromInstructions";
+/**
+ * @internal
+ */
+export * from "./toEndpointV1";

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-types/adaptors/toEndpointV1.d.ts

@@ -0,0 +1,5 @@
+import { Endpoint, EndpointV2 } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare const toEndpointV1: (endpoint: string | Endpoint | EndpointV2) => Endpoint;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-types/endpointMiddleware.d.ts

@@ -0,0 +1,10 @@
+import { EndpointParameters, SerializeMiddleware } from "@smithy/types";
+import { EndpointResolvedConfig } from "./resolveEndpointConfig";
+import { EndpointParameterInstructions } from "./types";
+/**
+ * @internal
+ */
+export declare const endpointMiddleware: <T extends EndpointParameters>({ config, instructions, }: {
+    config: EndpointResolvedConfig<T>;
+    instructions: EndpointParameterInstructions;
+}) => SerializeMiddleware<any, any>;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-types/getEndpointPlugin.d.ts

@@ -0,0 +1,11 @@
+import { EndpointParameters, Pluggable, RelativeMiddlewareOptions, SerializeHandlerOptions } from "@smithy/types";
+import { EndpointResolvedConfig } from "./resolveEndpointConfig";
+import { EndpointParameterInstructions } from "./types";
+/**
+ * @internal
+ */
+export declare const endpointMiddlewareOptions: SerializeHandlerOptions & RelativeMiddlewareOptions;
+/**
+ * @internal
+ */
+export declare const getEndpointPlugin: <T extends EndpointParameters>(config: EndpointResolvedConfig<T>, instructions: EndpointParameterInstructions) => Pluggable<any, any>;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@smithy/middleware-endpoint/dist-types/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @internal
+ */
+export * from "./adaptors";
+/**
+ * @internal
+ */
+export * from "./endpointMiddleware";
+/**
+ * @internal
+ */
+export * from "./getEndpointPlugin";
+export * from "./resolveEndpointConfig";
+/**
+ * @internal
+ */
+export * from "./types";