@aws-sdk/middleware-bucket-endpoint 3.34.0 → 3.38.0

package/dist-es/bucketHostname.js

@@ -0,0 +1,118 @@
+import { __assign, __read } from "tslib";
+import { DOT_PATTERN, getArnResources, getPseudoRegion, getSuffix, getSuffixForArnEndpoint, isBucketNameOptions, isDnsCompatibleBucketName, isFipsRegion, validateAccountId, validateArnEndpointOptions, validateCustomEndpoint, validateDNSHostLabel, validateMrapAlias, validateNoDualstack, validateNoFIPS, validateOutpostService, validatePartition, validateRegion, validateRegionalClient, validateS3Service, validateService, } from "./bucketHostnameUtils";
+export var bucketHostname = function (options) {
+    validateCustomEndpoint(options);
+    return isBucketNameOptions(options)
+        ?
+            getEndpointFromBucketName(options)
+        :
+            getEndpointFromArn(options);
+};
+var getEndpointFromBucketName = function (_a) {
+    var _b = _a.accelerateEndpoint, accelerateEndpoint = _b === void 0 ? false : _b, region = _a.clientRegion, baseHostname = _a.baseHostname, bucketName = _a.bucketName, _c = _a.dualstackEndpoint, dualstackEndpoint = _c === void 0 ? false : _c, _d = _a.pathStyleEndpoint, pathStyleEndpoint = _d === void 0 ? false : _d, _e = _a.tlsCompatible, tlsCompatible = _e === void 0 ? true : _e, _f = _a.isCustomEndpoint, isCustomEndpoint = _f === void 0 ? false : _f;
+    var _g = __read(isCustomEndpoint ? [region, baseHostname] : getSuffix(baseHostname), 2), clientRegion = _g[0], hostnameSuffix = _g[1];
+    if (pathStyleEndpoint || !isDnsCompatibleBucketName(bucketName) || (tlsCompatible && DOT_PATTERN.test(bucketName))) {
+        return {
+            bucketEndpoint: false,
+            hostname: dualstackEndpoint ? "s3.dualstack." + clientRegion + "." + hostnameSuffix : baseHostname,
+        };
+    }
+    if (accelerateEndpoint) {
+        baseHostname = "s3-accelerate" + (dualstackEndpoint ? ".dualstack" : "") + "." + hostnameSuffix;
+    }
+    else if (dualstackEndpoint) {
+        baseHostname = "s3.dualstack." + clientRegion + "." + hostnameSuffix;
+    }
+    return {
+        bucketEndpoint: true,
+        hostname: bucketName + "." + baseHostname,
+    };
+};
+var getEndpointFromArn = function (options) {
+    var isCustomEndpoint = options.isCustomEndpoint, baseHostname = options.baseHostname, clientRegion = options.clientRegion;
+    var hostnameSuffix = isCustomEndpoint ? baseHostname : getSuffixForArnEndpoint(baseHostname)[1];
+    var pathStyleEndpoint = options.pathStyleEndpoint, _a = options.accelerateEndpoint, accelerateEndpoint = _a === void 0 ? false : _a, _b = options.tlsCompatible, tlsCompatible = _b === void 0 ? true : _b, bucketName = options.bucketName, _c = options.clientPartition, clientPartition = _c === void 0 ? "aws" : _c;
+    validateArnEndpointOptions({ pathStyleEndpoint: pathStyleEndpoint, accelerateEndpoint: accelerateEndpoint, tlsCompatible: tlsCompatible });
+    var service = bucketName.service, partition = bucketName.partition, accountId = bucketName.accountId, region = bucketName.region, resource = bucketName.resource;
+    validateService(service);
+    validatePartition(partition, { clientPartition: clientPartition });
+    validateAccountId(accountId);
+    var _d = getArnResources(resource), accesspointName = _d.accesspointName, outpostId = _d.outpostId;
+    if (service === "s3-object-lambda") {
+        return getEndpointFromObjectLambdaArn(__assign(__assign({}, options), { tlsCompatible: tlsCompatible, bucketName: bucketName, accesspointName: accesspointName, hostnameSuffix: hostnameSuffix }));
+    }
+    if (region === "") {
+        return getEndpointFromMRAPArn(__assign(__assign({}, options), { clientRegion: clientRegion, mrapAlias: accesspointName, hostnameSuffix: hostnameSuffix }));
+    }
+    if (outpostId) {
+        return getEndpointFromOutpostArn(__assign(__assign({}, options), { clientRegion: clientRegion, outpostId: outpostId, accesspointName: accesspointName, hostnameSuffix: hostnameSuffix }));
+    }
+    return getEndpointFromAccessPointArn(__assign(__assign({}, options), { clientRegion: clientRegion, accesspointName: accesspointName, hostnameSuffix: hostnameSuffix }));
+};
+var getEndpointFromObjectLambdaArn = function (_a) {
+    var _b = _a.dualstackEndpoint, dualstackEndpoint = _b === void 0 ? false : _b, _c = _a.tlsCompatible, tlsCompatible = _c === void 0 ? true : _c, useArnRegion = _a.useArnRegion, clientRegion = _a.clientRegion, _d = _a.clientSigningRegion, clientSigningRegion = _d === void 0 ? clientRegion : _d, accesspointName = _a.accesspointName, bucketName = _a.bucketName, hostnameSuffix = _a.hostnameSuffix;
+    var accountId = bucketName.accountId, region = bucketName.region, service = bucketName.service;
+    validateRegionalClient(clientRegion);
+    validateRegion(region, { useArnRegion: useArnRegion, clientRegion: clientRegion, clientSigningRegion: clientSigningRegion, allowFipsRegion: true });
+    validateNoDualstack(dualstackEndpoint);
+    var DNSHostLabel = accesspointName + "-" + accountId;
+    validateDNSHostLabel(DNSHostLabel, { tlsCompatible: tlsCompatible });
+    var endpointRegion = useArnRegion ? region : clientRegion;
+    var signingRegion = useArnRegion ? region : clientSigningRegion;
+    return {
+        bucketEndpoint: true,
+        hostname: DNSHostLabel + "." + service + (isFipsRegion(clientRegion) ? "-fips" : "") + "." + getPseudoRegion(endpointRegion) + "." + hostnameSuffix,
+        signingRegion: signingRegion,
+        signingService: service,
+    };
+};
+var getEndpointFromMRAPArn = function (_a) {
+    var disableMultiregionAccessPoints = _a.disableMultiregionAccessPoints, _b = _a.dualstackEndpoint, dualstackEndpoint = _b === void 0 ? false : _b, isCustomEndpoint = _a.isCustomEndpoint, mrapAlias = _a.mrapAlias, hostnameSuffix = _a.hostnameSuffix;
+    if (disableMultiregionAccessPoints === true) {
+        throw new Error("SDK is attempting to use a MRAP ARN. Please enable to feature.");
+    }
+    validateMrapAlias(mrapAlias);
+    validateNoDualstack(dualstackEndpoint);
+    return {
+        bucketEndpoint: true,
+        hostname: "" + mrapAlias + (isCustomEndpoint ? "" : ".accesspoint.s3-global") + "." + hostnameSuffix,
+        signingRegion: "*",
+    };
+};
+var getEndpointFromOutpostArn = function (_a) {
+    var useArnRegion = _a.useArnRegion, clientRegion = _a.clientRegion, _b = _a.clientSigningRegion, clientSigningRegion = _b === void 0 ? clientRegion : _b, bucketName = _a.bucketName, outpostId = _a.outpostId, _c = _a.dualstackEndpoint, dualstackEndpoint = _c === void 0 ? false : _c, _d = _a.tlsCompatible, tlsCompatible = _d === void 0 ? true : _d, accesspointName = _a.accesspointName, isCustomEndpoint = _a.isCustomEndpoint, hostnameSuffix = _a.hostnameSuffix;
+    validateRegionalClient(clientRegion);
+    validateRegion(bucketName.region, { useArnRegion: useArnRegion, clientRegion: clientRegion, clientSigningRegion: clientSigningRegion });
+    var DNSHostLabel = accesspointName + "-" + bucketName.accountId;
+    validateDNSHostLabel(DNSHostLabel, { tlsCompatible: tlsCompatible });
+    var endpointRegion = useArnRegion ? bucketName.region : clientRegion;
+    var signingRegion = useArnRegion ? bucketName.region : clientSigningRegion;
+    validateOutpostService(bucketName.service);
+    validateDNSHostLabel(outpostId, { tlsCompatible: tlsCompatible });
+    validateNoDualstack(dualstackEndpoint);
+    validateNoFIPS(endpointRegion);
+    var hostnamePrefix = DNSHostLabel + "." + outpostId;
+    return {
+        bucketEndpoint: true,
+        hostname: "" + hostnamePrefix + (isCustomEndpoint ? "" : ".s3-outposts." + endpointRegion) + "." + hostnameSuffix,
+        signingRegion: signingRegion,
+        signingService: "s3-outposts",
+    };
+};
+var getEndpointFromAccessPointArn = function (_a) {
+    var useArnRegion = _a.useArnRegion, clientRegion = _a.clientRegion, _b = _a.clientSigningRegion, clientSigningRegion = _b === void 0 ? clientRegion : _b, bucketName = _a.bucketName, _c = _a.dualstackEndpoint, dualstackEndpoint = _c === void 0 ? false : _c, _d = _a.tlsCompatible, tlsCompatible = _d === void 0 ? true : _d, accesspointName = _a.accesspointName, isCustomEndpoint = _a.isCustomEndpoint, hostnameSuffix = _a.hostnameSuffix;
+    validateRegionalClient(clientRegion);
+    validateRegion(bucketName.region, { useArnRegion: useArnRegion, clientRegion: clientRegion, clientSigningRegion: clientSigningRegion, allowFipsRegion: true });
+    var hostnamePrefix = accesspointName + "-" + bucketName.accountId;
+    validateDNSHostLabel(hostnamePrefix, { tlsCompatible: tlsCompatible });
+    var endpointRegion = useArnRegion ? bucketName.region : clientRegion;
+    var signingRegion = useArnRegion ? bucketName.region : clientSigningRegion;
+    validateS3Service(bucketName.service);
+    return {
+        bucketEndpoint: true,
+        hostname: "" + hostnamePrefix + (isCustomEndpoint
+            ? ""
+            : ".s3-accesspoint" + (isFipsRegion(clientRegion) ? "-fips" : "") + (dualstackEndpoint ? ".dualstack" : "") + "." + getPseudoRegion(endpointRegion)) + "." + hostnameSuffix,
+        signingRegion: signingRegion,
+    };
+};

package/dist-es/bucketHostnameUtils.js

@@ -0,0 +1,144 @@
+import { __read } from "tslib";
+var DOMAIN_PATTERN = /^[a-z0-9][a-z0-9\.\-]{1,61}[a-z0-9]$/;
+var IP_ADDRESS_PATTERN = /(\d+\.){3}\d+/;
+var DOTS_PATTERN = /\.\./;
+export var DOT_PATTERN = /\./;
+export var S3_HOSTNAME_PATTERN = /^(.+\.)?s3[.-]([a-z0-9-]+)\./;
+var S3_US_EAST_1_ALTNAME_PATTERN = /^s3(-external-1)?\.amazonaws\.com$/;
+var AWS_PARTITION_SUFFIX = "amazonaws.com";
+export var isBucketNameOptions = function (options) { return typeof options.bucketName === "string"; };
+export var getPseudoRegion = function (region) { return (isFipsRegion(region) ? region.replace(/fips-|-fips/, "") : region); };
+export var isDnsCompatibleBucketName = function (bucketName) {
+    return DOMAIN_PATTERN.test(bucketName) && !IP_ADDRESS_PATTERN.test(bucketName) && !DOTS_PATTERN.test(bucketName);
+};
+var getRegionalSuffix = function (hostname) {
+    var parts = hostname.match(S3_HOSTNAME_PATTERN);
+    return [parts[2], hostname.replace(new RegExp("^" + parts[0]), "")];
+};
+export var getSuffix = function (hostname) {
+    return S3_US_EAST_1_ALTNAME_PATTERN.test(hostname) ? ["us-east-1", AWS_PARTITION_SUFFIX] : getRegionalSuffix(hostname);
+};
+export var getSuffixForArnEndpoint = function (hostname) {
+    return S3_US_EAST_1_ALTNAME_PATTERN.test(hostname)
+        ? [hostname.replace("." + AWS_PARTITION_SUFFIX, ""), AWS_PARTITION_SUFFIX]
+        : getRegionalSuffix(hostname);
+};
+export var validateArnEndpointOptions = function (options) {
+    if (options.pathStyleEndpoint) {
+        throw new Error("Path-style S3 endpoint is not supported when bucket is an ARN");
+    }
+    if (options.accelerateEndpoint) {
+        throw new Error("Accelerate endpoint is not supported when bucket is an ARN");
+    }
+    if (!options.tlsCompatible) {
+        throw new Error("HTTPS is required when bucket is an ARN");
+    }
+};
+export var validateService = function (service) {
+    if (service !== "s3" && service !== "s3-outposts" && service !== "s3-object-lambda") {
+        throw new Error("Expect 's3' or 's3-outposts' or 's3-object-lambda' in ARN service component");
+    }
+};
+export var validateS3Service = function (service) {
+    if (service !== "s3") {
+        throw new Error("Expect 's3' in Accesspoint ARN service component");
+    }
+};
+export var validateOutpostService = function (service) {
+    if (service !== "s3-outposts") {
+        throw new Error("Expect 's3-posts' in Outpost ARN service component");
+    }
+};
+export var validatePartition = function (partition, options) {
+    if (partition !== options.clientPartition) {
+        throw new Error("Partition in ARN is incompatible, got \"" + partition + "\" but expected \"" + options.clientPartition + "\"");
+    }
+};
+export var validateRegion = function (region, options) {
+    if (region === "") {
+        throw new Error("ARN region is empty");
+    }
+    if (isFipsRegion(options.clientRegion)) {
+        if (!options.allowFipsRegion) {
+            throw new Error("FIPS region is not supported");
+        }
+        else if (!isEqualRegions(region, options.clientRegion)) {
+            throw new Error("Client FIPS region " + options.clientRegion + " doesn't match region " + region + " in ARN");
+        }
+    }
+    if (!options.useArnRegion &&
+        !isEqualRegions(region, options.clientRegion || "") &&
+        !isEqualRegions(region, options.clientSigningRegion || "")) {
+        throw new Error("Region in ARN is incompatible, got " + region + " but expected " + options.clientRegion);
+    }
+};
+export var validateRegionalClient = function (region) {
+    if (["s3-external-1", "aws-global"].includes(getPseudoRegion(region))) {
+        throw new Error("Client region " + region + " is not regional");
+    }
+};
+export var isFipsRegion = function (region) { return region.startsWith("fips-") || region.endsWith("-fips"); };
+var isEqualRegions = function (regionA, regionB) {
+    return regionA === regionB || getPseudoRegion(regionA) === regionB || regionA === getPseudoRegion(regionB);
+};
+export var validateAccountId = function (accountId) {
+    if (!/[0-9]{12}/.exec(accountId)) {
+        throw new Error("Access point ARN accountID does not match regex '[0-9]{12}'");
+    }
+};
+export var validateDNSHostLabel = function (label, options) {
+    if (options === void 0) { options = { tlsCompatible: true }; }
+    if (label.length >= 64 ||
+        !/^[a-z0-9][a-z0-9.-]*[a-z0-9]$/.test(label) ||
+        /(\d+\.){3}\d+/.test(label) ||
+        /[.-]{2}/.test(label) ||
+        ((options === null || options === void 0 ? void 0 : options.tlsCompatible) && DOT_PATTERN.test(label))) {
+        throw new Error("Invalid DNS label " + label);
+    }
+};
+export var validateCustomEndpoint = function (options) {
+    if (options.isCustomEndpoint) {
+        if (options.dualstackEndpoint)
+            throw new Error("Dualstack endpoint is not supported with custom endpoint");
+        if (options.accelerateEndpoint)
+            throw new Error("Accelerate endpoint is not supported with custom endpoint");
+    }
+};
+export var getArnResources = function (resource) {
+    var delimiter = resource.includes(":") ? ":" : "/";
+    var _a = __read(resource.split(delimiter)), resourceType = _a[0], rest = _a.slice(1);
+    if (resourceType === "accesspoint") {
+        if (rest.length !== 1 || rest[0] === "") {
+            throw new Error("Access Point ARN should have one resource accesspoint" + delimiter + "{accesspointname}");
+        }
+        return { accesspointName: rest[0] };
+    }
+    else if (resourceType === "outpost") {
+        if (!rest[0] || rest[1] !== "accesspoint" || !rest[2] || rest.length !== 3) {
+            throw new Error("Outpost ARN should have resource outpost" + delimiter + "{outpostId}" + delimiter + "accesspoint" + delimiter + "{accesspointName}");
+        }
+        var _b = __read(rest, 3), outpostId = _b[0], _1 = _b[1], accesspointName = _b[2];
+        return { outpostId: outpostId, accesspointName: accesspointName };
+    }
+    else {
+        throw new Error("ARN resource should begin with 'accesspoint" + delimiter + "' or 'outpost" + delimiter + "'");
+    }
+};
+export var validateNoDualstack = function (dualstackEndpoint) {
+    if (dualstackEndpoint)
+        throw new Error("Dualstack endpoint is not supported with Outpost or Multi-region Access Point ARN.");
+};
+export var validateNoFIPS = function (region) {
+    if (isFipsRegion(region !== null && region !== void 0 ? region : ""))
+        throw new Error("FIPS region is not supported with Outpost, got " + region);
+};
+export var validateMrapAlias = function (name) {
+    try {
+        name.split(".").forEach(function (label) {
+            validateDNSHostLabel(label);
+        });
+    }
+    catch (e) {
+        throw new Error("\"" + name + "\" is not a DNS compatible name.");
+    }
+};

package/dist-es/configurations.js

@@ -0,0 +1,53 @@
+import { __assign } from "tslib";
+export function resolveBucketEndpointConfig(input) {
+    var _a = input.bucketEndpoint, bucketEndpoint = _a === void 0 ? false : _a, _b = input.forcePathStyle, forcePathStyle = _b === void 0 ? false : _b, _c = input.useAccelerateEndpoint, useAccelerateEndpoint = _c === void 0 ? false : _c, _d = input.useDualstackEndpoint, useDualstackEndpoint = _d === void 0 ? false : _d, _e = input.useArnRegion, useArnRegion = _e === void 0 ? false : _e, _f = input.disableMultiregionAccessPoints, disableMultiregionAccessPoints = _f === void 0 ? false : _f;
+    return __assign(__assign({}, input), { bucketEndpoint: bucketEndpoint, forcePathStyle: forcePathStyle, useAccelerateEndpoint: useAccelerateEndpoint, useDualstackEndpoint: useDualstackEndpoint, useArnRegion: typeof useArnRegion === "function" ? useArnRegion : function () { return Promise.resolve(useArnRegion); }, disableMultiregionAccessPoints: typeof disableMultiregionAccessPoints === "function"
+            ? disableMultiregionAccessPoints
+            : function () { return Promise.resolve(disableMultiregionAccessPoints); } });
+}
+export var NODE_USE_ARN_REGION_ENV_NAME = "AWS_S3_USE_ARN_REGION";
+export var NODE_USE_ARN_REGION_INI_NAME = "s3_use_arn_region";
+export var NODE_DISABLE_MULTIREGION_ACCESS_POINT_ENV_NAME = "AWS_S3_DISABLE_MULTIREGION_ACCESS_POINTS";
+export var NODE_DISABLE_MULTIREGION_ACCESS_POINT_INI_NAME = "s3_disable_multiregion_access_points";
+export var NODE_USE_ARN_REGION_CONFIG_OPTIONS = {
+    environmentVariableSelector: function (env) {
+        if (!Object.prototype.hasOwnProperty.call(env, NODE_USE_ARN_REGION_ENV_NAME))
+            return undefined;
+        if (env[NODE_USE_ARN_REGION_ENV_NAME] === "true")
+            return true;
+        if (env[NODE_USE_ARN_REGION_ENV_NAME] === "false")
+            return false;
+        throw new Error("Cannot load env " + NODE_USE_ARN_REGION_ENV_NAME + ". Expected \"true\" or \"false\", got " + env[NODE_USE_ARN_REGION_ENV_NAME] + ".");
+    },
+    configFileSelector: function (profile) {
+        if (!Object.prototype.hasOwnProperty.call(profile, NODE_USE_ARN_REGION_INI_NAME))
+            return undefined;
+        if (profile[NODE_USE_ARN_REGION_INI_NAME] === "true")
+            return true;
+        if (profile[NODE_USE_ARN_REGION_INI_NAME] === "false")
+            return false;
+        throw new Error("Cannot load shared config entry " + NODE_USE_ARN_REGION_INI_NAME + ". Expected \"true\" or \"false\", got " + profile[NODE_USE_ARN_REGION_INI_NAME] + ".");
+    },
+    default: false,
+};
+export var NODE_DISABLE_MULTIREGION_ACCESS_POINT_CONFIG_OPTIONS = {
+    environmentVariableSelector: function (env) {
+        if (!Object.prototype.hasOwnProperty.call(env, NODE_DISABLE_MULTIREGION_ACCESS_POINT_ENV_NAME))
+            return undefined;
+        if (env[NODE_DISABLE_MULTIREGION_ACCESS_POINT_ENV_NAME] === "true")
+            return true;
+        if (env[NODE_DISABLE_MULTIREGION_ACCESS_POINT_ENV_NAME] === "false")
+            return false;
+        throw new Error("Cannot load env " + NODE_DISABLE_MULTIREGION_ACCESS_POINT_ENV_NAME + ". Expected \"true\" or \"false\", got " + env[NODE_DISABLE_MULTIREGION_ACCESS_POINT_ENV_NAME] + ".");
+    },
+    configFileSelector: function (profile) {
+        if (!Object.prototype.hasOwnProperty.call(profile, NODE_DISABLE_MULTIREGION_ACCESS_POINT_INI_NAME))
+            return undefined;
+        if (profile[NODE_DISABLE_MULTIREGION_ACCESS_POINT_INI_NAME] === "true")
+            return true;
+        if (profile[NODE_DISABLE_MULTIREGION_ACCESS_POINT_INI_NAME] === "false")
+            return false;
+        throw new Error("Cannot load shared config entry " + NODE_DISABLE_MULTIREGION_ACCESS_POINT_INI_NAME + ". Expected \"true\" or \"false\", got " + profile[NODE_DISABLE_MULTIREGION_ACCESS_POINT_INI_NAME] + ".");
+    },
+    default: false,
+};

package/dist-types/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./bucketEndpointMiddleware";
+export * from "./bucketHostname";
+export * from "./configurations";
+export { getArnResources, getPseudoRegion, getSuffixForArnEndpoint, validateOutpostService, validatePartition, validateAccountId, validateRegion, validateDNSHostLabel, validateNoDualstack, validateNoFIPS, } from "./bucketHostnameUtils";

package/{dist/types → dist-types}/ts3.4/bucketHostnameUtils.d.ts

@@ -22,30 +22,15 @@ export interface ArnHostnameParams extends Pick<BucketHostnameParams, Exclude<ke
     disableMultiregionAccessPoints?: boolean;
 }
 export declare const isBucketNameOptions: (options: BucketHostnameParams | ArnHostnameParams) => options is BucketHostnameParams;
-/**
- * Get pseudo region from supplied region. For example, if supplied with `fips-us-west-2`, it returns `us-west-2`.
- * @internal
- */
+
 export declare const getPseudoRegion: (region: string) => string;
-/**
- * Determines whether a given string is DNS compliant per the rules outlined by
- * S3. Length, capitaization, and leading dot restrictions are enforced by the
- * DOMAIN_PATTERN regular expression.
- * @internal
- *
- * @see https://docs.aws.amazon.com/AmazonS3/latest/dev/BucketRestrictions.html
- */
+
 export declare const isDnsCompatibleBucketName: (bucketName: string) => boolean;
 export declare const getSuffix: (hostname: string) => [
     string,
     string
 ];
-/**
- * Infer region and hostname suffix from a complete hostname
- * @internal
- * @param hostname - Hostname
- * @returns [Region, Hostname suffix]
- */
+
 export declare const getSuffixForArnEndpoint: (hostname: string) => [
     string,
     string
@@ -58,43 +43,24 @@ export declare const validateArnEndpointOptions: (options: {
 export declare const validateService: (service: string) => void;
 export declare const validateS3Service: (service: string) => void;
 export declare const validateOutpostService: (service: string) => void;
-/**
- * Validate partition inferred from ARN is the same to `options.clientPartition`.
- * @internal
- */
+
 export declare const validatePartition: (partition: string, options: {
     clientPartition: string;
 }) => void;
-/**
- * validate region value inferred from ARN. If `options.useArnRegion` is set, it validates the region is not a FIPS
- * region. If `options.useArnRegion` is unset, it validates the region is equal to `options.clientRegion` or
- * `options.clientSigningRegion`.
- * @internal
- */
+
 export declare const validateRegion: (region: string, options: {
     useArnRegion?: boolean;
     allowFipsRegion?: boolean;
     clientRegion: string;
     clientSigningRegion: string;
 }) => void;
-/**
- *
- * @param region
- */
+
 export declare const validateRegionalClient: (region: string) => void;
-/**
- * @internal
- */
+
 export declare const isFipsRegion: (region: string) => boolean;
-/**
- * Validate an account ID
- * @internal
- */
+
 export declare const validateAccountId: (accountId: string) => void;
-/**
- * Validate a host label according to https://tools.ietf.org/html/rfc3986#section-3.2.2
- * @internal
- */
+
 export declare const validateDNSHostLabel: (label: string, options?: {
     tlsCompatible?: boolean;
 }) => void;
@@ -103,29 +69,14 @@ export declare const validateCustomEndpoint: (options: {
     dualstackEndpoint?: boolean;
     accelerateEndpoint?: boolean;
 }) => void;
-/**
- * Validate and parse an Access Point ARN or Outposts ARN
- * @internal
- *
- * @param resource - The resource section of an ARN
- * @returns Access Point Name and optional Outpost ID.
- */
+
 export declare const getArnResources: (resource: string) => {
     accesspointName: string;
     outpostId?: string;
 };
-/**
- * Throw if dual stack configuration is set to true.
- * @internal
- */
+
 export declare const validateNoDualstack: (dualstackEndpoint?: boolean | undefined) => void;
-/**
- * Validate region is not appended or prepended with a `fips-`
- * @internal
- */
+
 export declare const validateNoFIPS: (region?: string | undefined) => void;
-/**
- * Validate the multi-region access point alias.
- * @private
- */
+
 export declare const validateMrapAlias: (name: string) => void;

package/dist-types/ts3.4/configurations.d.ts

@@ -0,0 +1,49 @@
+import { LoadedConfigSelectors } from "@aws-sdk/node-config-provider";
+import { Provider, RegionInfoProvider } from "@aws-sdk/types";
+export interface BucketEndpointInputConfig {
+    
+    bucketEndpoint?: boolean;
+    
+    forcePathStyle?: boolean;
+    
+    useAccelerateEndpoint?: boolean;
+    
+    useDualstackEndpoint?: boolean;
+    
+    useArnRegion?: boolean | Provider<boolean>;
+    
+    disableMultiregionAccessPoints?: boolean | Provider<boolean>;
+}
+interface PreviouslyResolved {
+    isCustomEndpoint: boolean;
+    region: Provider<string>;
+    regionInfoProvider: RegionInfoProvider;
+}
+export interface BucketEndpointResolvedConfig {
+    
+    isCustomEndpoint: boolean;
+    
+    bucketEndpoint: boolean;
+    
+    forcePathStyle: boolean;
+    
+    useAccelerateEndpoint: boolean;
+    
+    useDualstackEndpoint: boolean;
+    
+    useArnRegion: Provider<boolean>;
+    
+    region: Provider<string>;
+    
+    regionInfoProvider: RegionInfoProvider;
+    disableMultiregionAccessPoints: Provider<boolean>;
+}
+export declare function resolveBucketEndpointConfig<T>(input: T & PreviouslyResolved & BucketEndpointInputConfig): T & BucketEndpointResolvedConfig;
+export declare const NODE_USE_ARN_REGION_ENV_NAME = "AWS_S3_USE_ARN_REGION";
+export declare const NODE_USE_ARN_REGION_INI_NAME = "s3_use_arn_region";
+export declare const NODE_DISABLE_MULTIREGION_ACCESS_POINT_ENV_NAME = "AWS_S3_DISABLE_MULTIREGION_ACCESS_POINTS";
+export declare const NODE_DISABLE_MULTIREGION_ACCESS_POINT_INI_NAME = "s3_disable_multiregion_access_points";
+
+export declare const NODE_USE_ARN_REGION_CONFIG_OPTIONS: LoadedConfigSelectors<boolean>;
+export declare const NODE_DISABLE_MULTIREGION_ACCESS_POINT_CONFIG_OPTIONS: LoadedConfigSelectors<boolean>;
+export {};

package/package.json

@@ -1,31 +1,31 @@
 {
   "name": "@aws-sdk/middleware-bucket-endpoint",
-  "version": "3.34.0",
+  "version": "3.38.0",
   "scripts": {
     "build": "yarn build:cjs && yarn build:es && yarn build:types",
     "build:cjs": "tsc -p tsconfig.cjs.json",
     "build:es": "tsc -p tsconfig.es.json",
     "build:types": "tsc -p tsconfig.types.json",
-    "downlevel-dts": "downlevel-dts dist/types dist/types/ts3.4",
+    "downlevel-dts": "downlevel-dts dist-types dist-types/ts3.4",
     "test": "jest"
   },
-  "main": "./dist/cjs/index.js",
-  "module": "./dist/es/index.js",
-  "types": "./dist/types/index.d.ts",
+  "main": "./dist-cjs/index.js",
+  "module": "./dist-es/index.js",
+  "types": "./dist-types/index.d.ts",
   "author": {
     "name": "AWS SDK for JavaScript Team",
     "url": "https://aws.amazon.com/javascript/"
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@aws-sdk/protocol-http": "3.34.0",
-    "@aws-sdk/types": "3.34.0",
-    "@aws-sdk/util-arn-parser": "3.34.0",
+    "@aws-sdk/protocol-http": "3.38.0",
+    "@aws-sdk/types": "3.38.0",
+    "@aws-sdk/util-arn-parser": "3.37.0",
     "tslib": "^2.3.0"
   },
   "devDependencies": {
-    "@aws-sdk/middleware-stack": "3.34.0",
-    "@aws-sdk/node-config-provider": "3.34.0",
+    "@aws-sdk/middleware-stack": "3.38.0",
+    "@aws-sdk/node-config-provider": "3.38.0",
     "@types/jest": "^26.0.4",
     "jest": "^26.1.0",
     "typescript": "~4.3.5"
@@ -35,11 +35,14 @@
   },
   "typesVersions": {
     "<4.0": {
-      "dist/types/*": [
-        "dist/types/ts3.4/*"
+      "dist-types/*": [
+        "dist-types/ts3.4/*"
       ]
     }
   },
+  "files": [
+    "dist-*"
+  ],
   "homepage": "https://github.com/aws/aws-sdk-js-v3/tree/main/packages/middleware-bucket-endpoint",
   "repository": {
     "type": "git",