@aws-sdk/middleware-flexible-checksums 3.53.0

package/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+# [3.53.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.52.0...v3.53.0) (2022-02-24)
+
+
+### Features
+
+* **middleware-flexible-checksums:** add flexibleChecksumMiddleware ([#3340](https://github.com/aws/aws-sdk-js-v3/issues/3340)) ([15e0512](https://github.com/aws/aws-sdk-js-v3/commit/15e05124f9eb4a9fbf9437f14179188d7d4b11e1))
+* **middleware-flexible-checksums:** support trailing checksums with aws-chunked encoding ([#3347](https://github.com/aws/aws-sdk-js-v3/issues/3347)) ([50b48fe](https://github.com/aws/aws-sdk-js-v3/commit/50b48fec155cb87f85799f001beac6ca6434372b))

package/LICENSE

@@ -0,0 +1,201 @@
+                                Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2018-2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,7 @@
+# @aws-sdk/middleware-flexible-checksums
+
+[![NPM version](https://img.shields.io/npm/v/@aws-sdk/middleware-flexible-checksums/latest.svg)](https://www.npmjs.com/package/@aws-sdk/middleware-flexible-checksums)
+[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/middleware-flexible-checksums.svg)](https://www.npmjs.com/package/@aws-sdk/middleware-flexible-checksums)
+
+This package provides AWS SDK for JavaScript middleware that applies a checksum
+of the request body as a header.

package/dist-cjs/configuration.js

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

package/dist-cjs/constants.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChecksumLocation = exports.ChecksumAlgorithm = void 0;
+var ChecksumAlgorithm;
+(function (ChecksumAlgorithm) {
+    ChecksumAlgorithm["MD5"] = "MD5";
+    ChecksumAlgorithm["CRC32"] = "CRC32";
+    ChecksumAlgorithm["CRC32C"] = "CRC32C";
+    ChecksumAlgorithm["SHA1"] = "SHA1";
+    ChecksumAlgorithm["SHA256"] = "SHA256";
+})(ChecksumAlgorithm = exports.ChecksumAlgorithm || (exports.ChecksumAlgorithm = {}));
+var ChecksumLocation;
+(function (ChecksumLocation) {
+    ChecksumLocation["HEADER"] = "header";
+    ChecksumLocation["TRAILER"] = "trailer";
+})(ChecksumLocation = exports.ChecksumLocation || (exports.ChecksumLocation = {}));

package/dist-cjs/flexibleChecksumsMiddleware.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flexibleChecksumsMiddleware = void 0;
+const protocol_http_1 = require("@aws-sdk/protocol-http");
+const getChecksum_1 = require("./getChecksum");
+const getChecksumAlgorithmForRequest_1 = require("./getChecksumAlgorithmForRequest");
+const getChecksumLocationName_1 = require("./getChecksumLocationName");
+const hasHeader_1 = require("./hasHeader");
+const isStreaming_1 = require("./isStreaming");
+const selectChecksumAlgorithmFunction_1 = require("./selectChecksumAlgorithmFunction");
+const validateChecksumFromResponse_1 = require("./validateChecksumFromResponse");
+const flexibleChecksumsMiddleware = (config, middlewareConfig) => (next) => async (args) => {
+    if (!protocol_http_1.HttpRequest.isInstance(args.request)) {
+        return next(args);
+    }
+    const { request } = args;
+    const { body: requestBody, headers } = request;
+    const { base64Encoder, streamHasher } = config;
+    const { input, requestChecksumRequired, requestAlgorithmMember } = middlewareConfig;
+    const checksumAlgorithm = getChecksumAlgorithmForRequest_1.getChecksumAlgorithmForRequest(input, {
+        requestChecksumRequired,
+        requestAlgorithmMember,
+    });
+    let updatedBody = requestBody;
+    let updatedHeaders = headers;
+    if (checksumAlgorithm) {
+        const checksumLocationName = getChecksumLocationName_1.getChecksumLocationName(checksumAlgorithm);
+        const checksumAlgorithmFn = selectChecksumAlgorithmFunction_1.selectChecksumAlgorithmFunction(checksumAlgorithm, config);
+        if (isStreaming_1.isStreaming(requestBody)) {
+            const { getAwsChunkedEncodingStream, bodyLengthChecker } = config;
+            updatedBody = getAwsChunkedEncodingStream(requestBody, {
+                base64Encoder,
+                bodyLengthChecker,
+                checksumLocationName,
+                checksumAlgorithmFn,
+                streamHasher,
+            });
+            updatedHeaders = {
+                ...headers,
+                "content-encoding": "aws-chunked",
+                "transfer-encoding": "chunked",
+                "x-amz-decoded-content-length": headers["content-length"],
+                "x-amz-content-sha256": "STREAMING-UNSIGNED-PAYLOAD-TRAILER",
+                "x-amz-trailer": checksumLocationName,
+            };
+            delete updatedHeaders["content-length"];
+        }
+        else if (!hasHeader_1.hasHeader(checksumLocationName, headers)) {
+            const checksum = await getChecksum_1.getChecksum(requestBody, { streamHasher, checksumAlgorithmFn, base64Encoder });
+            updatedHeaders = {
+                ...headers,
+                [checksumLocationName]: checksum,
+            };
+        }
+    }
+    const result = await next({
+        ...args,
+        request: {
+            ...request,
+            headers: updatedHeaders,
+            body: updatedBody,
+        },
+    });
+    const { requestValidationModeMember, responseAlgorithms } = middlewareConfig;
+    if (requestValidationModeMember && input[requestValidationModeMember] === "ENABLED") {
+        validateChecksumFromResponse_1.validateChecksumFromResponse(result.response, {
+            config,
+            responseAlgorithms,
+        });
+    }
+    return result;
+};
+exports.flexibleChecksumsMiddleware = flexibleChecksumsMiddleware;

package/dist-cjs/getChecksum.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChecksum = void 0;
+const isStreaming_1 = require("./isStreaming");
+const stringHasher_1 = require("./stringHasher");
+const getChecksum = async (body, { streamHasher, checksumAlgorithmFn, base64Encoder }) => {
+    const digest = isStreaming_1.isStreaming(body) ? streamHasher(checksumAlgorithmFn, body) : stringHasher_1.stringHasher(checksumAlgorithmFn, body);
+    return base64Encoder(await digest);
+};
+exports.getChecksum = getChecksum;

package/dist-cjs/getChecksumAlgorithmForRequest.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChecksumAlgorithmForRequest = void 0;
+const constants_1 = require("./constants");
+const types_1 = require("./types");
+const getChecksumAlgorithmForRequest = (input, { requestChecksumRequired, requestAlgorithmMember }) => {
+    if (!requestAlgorithmMember || !input[requestAlgorithmMember]) {
+        return requestChecksumRequired ? constants_1.ChecksumAlgorithm.MD5 : undefined;
+    }
+    const checksumAlgorithm = input[requestAlgorithmMember];
+    if (!types_1.CLIENT_SUPPORTED_ALGORITHMS.includes(checksumAlgorithm)) {
+        throw new Error(`The checksum algorithm "${checksumAlgorithm}" is not supported by the client.` +
+            ` Select one of ${types_1.CLIENT_SUPPORTED_ALGORITHMS}.`);
+    }
+    return checksumAlgorithm;
+};
+exports.getChecksumAlgorithmForRequest = getChecksumAlgorithmForRequest;

package/dist-cjs/getChecksumAlgorithmListForResponse.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChecksumAlgorithmListForResponse = void 0;
+const types_1 = require("./types");
+const getChecksumAlgorithmListForResponse = (responseAlgorithms = []) => {
+    const validChecksumAlgorithms = [];
+    for (const algorithm of types_1.PRIORITY_ORDER_ALGORITHMS) {
+        if (!responseAlgorithms.includes(algorithm) || !types_1.CLIENT_SUPPORTED_ALGORITHMS.includes(algorithm)) {
+            continue;
+        }
+        validChecksumAlgorithms.push(algorithm);
+    }
+    return validChecksumAlgorithms;
+};
+exports.getChecksumAlgorithmListForResponse = getChecksumAlgorithmListForResponse;

package/dist-cjs/getChecksumLocationName.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChecksumLocationName = void 0;
+const constants_1 = require("./constants");
+const getChecksumLocationName = (algorithm) => algorithm === constants_1.ChecksumAlgorithm.MD5 ? "content-md5" : `x-amz-checksum-${algorithm.toLowerCase()}`;
+exports.getChecksumLocationName = getChecksumLocationName;

package/dist-cjs/getFlexibleChecksumsPlugin.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFlexibleChecksumsPlugin = exports.flexibleChecksumsMiddlewareOptions = void 0;
+const flexibleChecksumsMiddleware_1 = require("./flexibleChecksumsMiddleware");
+exports.flexibleChecksumsMiddlewareOptions = {
+    name: "flexibleChecksumsMiddleware",
+    step: "build",
+    tags: ["BODY_CHECKSUM"],
+    override: true,
+};
+const getFlexibleChecksumsPlugin = (config, middlewareConfig) => ({
+    applyToStack: (clientStack) => {
+        clientStack.add(flexibleChecksumsMiddleware_1.flexibleChecksumsMiddleware(config, middlewareConfig), exports.flexibleChecksumsMiddlewareOptions);
+    },
+});
+exports.getFlexibleChecksumsPlugin = getFlexibleChecksumsPlugin;

package/dist-cjs/hasHeader.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasHeader = void 0;
+const hasHeader = (header, headers) => {
+    const soughtHeader = header.toLowerCase();
+    for (const headerName of Object.keys(headers)) {
+        if (soughtHeader === headerName.toLowerCase()) {
+            return true;
+        }
+    }
+    return false;
+};
+exports.hasHeader = hasHeader;

package/dist-cjs/index.js

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

package/dist-cjs/isStreaming.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isStreaming = void 0;
+const is_array_buffer_1 = require("@aws-sdk/is-array-buffer");
+const isStreaming = (body) => body !== undefined && typeof body !== "string" && !ArrayBuffer.isView(body) && !is_array_buffer_1.isArrayBuffer(body);
+exports.isStreaming = isStreaming;

package/dist-cjs/selectChecksumAlgorithmFunction.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectChecksumAlgorithmFunction = void 0;
+const crc32_1 = require("@aws-crypto/crc32");
+const crc32c_1 = require("@aws-crypto/crc32c");
+const constants_1 = require("./constants");
+const selectChecksumAlgorithmFunction = (checksumAlgorithm, config) => ({
+    [constants_1.ChecksumAlgorithm.MD5]: config.md5,
+    [constants_1.ChecksumAlgorithm.CRC32]: crc32_1.AwsCrc32,
+    [constants_1.ChecksumAlgorithm.CRC32C]: crc32c_1.AwsCrc32c,
+    [constants_1.ChecksumAlgorithm.SHA1]: config.sha1,
+    [constants_1.ChecksumAlgorithm.SHA256]: config.sha256,
+}[checksumAlgorithm]);
+exports.selectChecksumAlgorithmFunction = selectChecksumAlgorithmFunction;

package/dist-cjs/stringHasher.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringHasher = void 0;
+const stringHasher = (checksumAlgorithmFn, body) => {
+    const hash = new checksumAlgorithmFn();
+    hash.update(body || "");
+    return hash.digest();
+};
+exports.stringHasher = stringHasher;

package/dist-cjs/types.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRIORITY_ORDER_ALGORITHMS = exports.CLIENT_SUPPORTED_ALGORITHMS = void 0;
+const constants_1 = require("./constants");
+exports.CLIENT_SUPPORTED_ALGORITHMS = [
+    constants_1.ChecksumAlgorithm.CRC32,
+    constants_1.ChecksumAlgorithm.CRC32C,
+    constants_1.ChecksumAlgorithm.SHA1,
+    constants_1.ChecksumAlgorithm.SHA256,
+];
+exports.PRIORITY_ORDER_ALGORITHMS = [
+    constants_1.ChecksumAlgorithm.CRC32,
+    constants_1.ChecksumAlgorithm.CRC32C,
+    constants_1.ChecksumAlgorithm.SHA1,
+    constants_1.ChecksumAlgorithm.SHA256,
+];

package/dist-cjs/validateChecksumFromResponse.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateChecksumFromResponse = void 0;
+const getChecksum_1 = require("./getChecksum");
+const getChecksumAlgorithmListForResponse_1 = require("./getChecksumAlgorithmListForResponse");
+const getChecksumLocationName_1 = require("./getChecksumLocationName");
+const selectChecksumAlgorithmFunction_1 = require("./selectChecksumAlgorithmFunction");
+const validateChecksumFromResponse = async (response, { config, responseAlgorithms }) => {
+    const checksumAlgorithms = getChecksumAlgorithmListForResponse_1.getChecksumAlgorithmListForResponse(responseAlgorithms);
+    const { body: responseBody, headers: responseHeaders } = response;
+    for (const algorithm of checksumAlgorithms) {
+        const responseHeader = getChecksumLocationName_1.getChecksumLocationName(algorithm);
+        const checksumFromResponse = responseHeaders[responseHeader];
+        if (checksumFromResponse) {
+            const checksumAlgorithmFn = selectChecksumAlgorithmFunction_1.selectChecksumAlgorithmFunction(algorithm, config);
+            const { streamHasher, base64Encoder } = config;
+            const checksum = await getChecksum_1.getChecksum(responseBody, { streamHasher, checksumAlgorithmFn, base64Encoder });
+            if (checksum === checksumFromResponse) {
+                break;
+            }
+            throw new Error(`Checksum mismatch: expected "${checksum}" but received "${checksumFromResponse}"` +
+                ` in response header "${responseHeader}".`);
+        }
+    }
+};
+exports.validateChecksumFromResponse = validateChecksumFromResponse;

package/dist-es/configuration.js

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

package/dist-es/constants.js

@@ -0,0 +1,13 @@
+export var ChecksumAlgorithm;
+(function (ChecksumAlgorithm) {
+    ChecksumAlgorithm["MD5"] = "MD5";
+    ChecksumAlgorithm["CRC32"] = "CRC32";
+    ChecksumAlgorithm["CRC32C"] = "CRC32C";
+    ChecksumAlgorithm["SHA1"] = "SHA1";
+    ChecksumAlgorithm["SHA256"] = "SHA256";
+})(ChecksumAlgorithm || (ChecksumAlgorithm = {}));
+export var ChecksumLocation;
+(function (ChecksumLocation) {
+    ChecksumLocation["HEADER"] = "header";
+    ChecksumLocation["TRAILER"] = "trailer";
+})(ChecksumLocation || (ChecksumLocation = {}));

package/dist-es/flexibleChecksumsMiddleware.js

@@ -0,0 +1,68 @@
+import { __assign, __awaiter, __generator } from "tslib";
+import { HttpRequest } from "@aws-sdk/protocol-http";
+import { getChecksum } from "./getChecksum";
+import { getChecksumAlgorithmForRequest } from "./getChecksumAlgorithmForRequest";
+import { getChecksumLocationName } from "./getChecksumLocationName";
+import { hasHeader } from "./hasHeader";
+import { isStreaming } from "./isStreaming";
+import { selectChecksumAlgorithmFunction } from "./selectChecksumAlgorithmFunction";
+import { validateChecksumFromResponse } from "./validateChecksumFromResponse";
+export var flexibleChecksumsMiddleware = function (config, middlewareConfig) {
+    return function (next) {
+        return function (args) { return __awaiter(void 0, void 0, void 0, function () {
+            var request, requestBody, headers, base64Encoder, streamHasher, input, requestChecksumRequired, requestAlgorithmMember, checksumAlgorithm, updatedBody, updatedHeaders, checksumLocationName, checksumAlgorithmFn, getAwsChunkedEncodingStream, bodyLengthChecker, checksum, result, requestValidationModeMember, responseAlgorithms;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!HttpRequest.isInstance(args.request)) {
+                            return [2, next(args)];
+                        }
+                        request = args.request;
+                        requestBody = request.body, headers = request.headers;
+                        base64Encoder = config.base64Encoder, streamHasher = config.streamHasher;
+                        input = middlewareConfig.input, requestChecksumRequired = middlewareConfig.requestChecksumRequired, requestAlgorithmMember = middlewareConfig.requestAlgorithmMember;
+                        checksumAlgorithm = getChecksumAlgorithmForRequest(input, {
+                            requestChecksumRequired: requestChecksumRequired,
+                            requestAlgorithmMember: requestAlgorithmMember,
+                        });
+                        updatedBody = requestBody;
+                        updatedHeaders = headers;
+                        if (!checksumAlgorithm) return [3, 3];
+                        checksumLocationName = getChecksumLocationName(checksumAlgorithm);
+                        checksumAlgorithmFn = selectChecksumAlgorithmFunction(checksumAlgorithm, config);
+                        if (!isStreaming(requestBody)) return [3, 1];
+                        getAwsChunkedEncodingStream = config.getAwsChunkedEncodingStream, bodyLengthChecker = config.bodyLengthChecker;
+                        updatedBody = getAwsChunkedEncodingStream(requestBody, {
+                            base64Encoder: base64Encoder,
+                            bodyLengthChecker: bodyLengthChecker,
+                            checksumLocationName: checksumLocationName,
+                            checksumAlgorithmFn: checksumAlgorithmFn,
+                            streamHasher: streamHasher,
+                        });
+                        updatedHeaders = __assign(__assign({}, headers), { "content-encoding": "aws-chunked", "transfer-encoding": "chunked", "x-amz-decoded-content-length": headers["content-length"], "x-amz-content-sha256": "STREAMING-UNSIGNED-PAYLOAD-TRAILER", "x-amz-trailer": checksumLocationName });
+                        delete updatedHeaders["content-length"];
+                        return [3, 3];
+                    case 1:
+                        if (!!hasHeader(checksumLocationName, headers)) return [3, 3];
+                        return [4, getChecksum(requestBody, { streamHasher: streamHasher, checksumAlgorithmFn: checksumAlgorithmFn, base64Encoder: base64Encoder })];
+                    case 2:
+                        checksum = _b.sent();
+                        updatedHeaders = __assign(__assign({}, headers), (_a = {}, _a[checksumLocationName] = checksum, _a));
+                        _b.label = 3;
+                    case 3: return [4, next(__assign(__assign({}, args), { request: __assign(__assign({}, request), { headers: updatedHeaders, body: updatedBody }) }))];
+                    case 4:
+                        result = _b.sent();
+                        requestValidationModeMember = middlewareConfig.requestValidationModeMember, responseAlgorithms = middlewareConfig.responseAlgorithms;
+                        if (requestValidationModeMember && input[requestValidationModeMember] === "ENABLED") {
+                            validateChecksumFromResponse(result.response, {
+                                config: config,
+                                responseAlgorithms: responseAlgorithms,
+                            });
+                        }
+                        return [2, result];
+                }
+            });
+        }); };
+    };
+};

package/dist-es/getChecksum.js

@@ -0,0 +1,18 @@
+import { __awaiter, __generator } from "tslib";
+import { isStreaming } from "./isStreaming";
+import { stringHasher } from "./stringHasher";
+export var getChecksum = function (body, _a) {
+    var streamHasher = _a.streamHasher, checksumAlgorithmFn = _a.checksumAlgorithmFn, base64Encoder = _a.base64Encoder;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var digest, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    digest = isStreaming(body) ? streamHasher(checksumAlgorithmFn, body) : stringHasher(checksumAlgorithmFn, body);
+                    _b = base64Encoder;
+                    return [4, digest];
+                case 1: return [2, _b.apply(void 0, [_c.sent()])];
+            }
+        });
+    });
+};

package/dist-es/getChecksumAlgorithmForRequest.js

@@ -0,0 +1,14 @@
+import { ChecksumAlgorithm } from "./constants";
+import { CLIENT_SUPPORTED_ALGORITHMS } from "./types";
+export var getChecksumAlgorithmForRequest = function (input, _a) {
+    var requestChecksumRequired = _a.requestChecksumRequired, requestAlgorithmMember = _a.requestAlgorithmMember;
+    if (!requestAlgorithmMember || !input[requestAlgorithmMember]) {
+        return requestChecksumRequired ? ChecksumAlgorithm.MD5 : undefined;
+    }
+    var checksumAlgorithm = input[requestAlgorithmMember];
+    if (!CLIENT_SUPPORTED_ALGORITHMS.includes(checksumAlgorithm)) {
+        throw new Error("The checksum algorithm \"" + checksumAlgorithm + "\" is not supported by the client." +
+            (" Select one of " + CLIENT_SUPPORTED_ALGORITHMS + "."));
+    }
+    return checksumAlgorithm;
+};

package/dist-es/getChecksumAlgorithmListForResponse.js

@@ -0,0 +1,24 @@
+import { __values } from "tslib";
+import { CLIENT_SUPPORTED_ALGORITHMS, PRIORITY_ORDER_ALGORITHMS } from "./types";
+export var getChecksumAlgorithmListForResponse = function (responseAlgorithms) {
+    var e_1, _a;
+    if (responseAlgorithms === void 0) { responseAlgorithms = []; }
+    var validChecksumAlgorithms = [];
+    try {
+        for (var PRIORITY_ORDER_ALGORITHMS_1 = __values(PRIORITY_ORDER_ALGORITHMS), PRIORITY_ORDER_ALGORITHMS_1_1 = PRIORITY_ORDER_ALGORITHMS_1.next(); !PRIORITY_ORDER_ALGORITHMS_1_1.done; PRIORITY_ORDER_ALGORITHMS_1_1 = PRIORITY_ORDER_ALGORITHMS_1.next()) {
+            var algorithm = PRIORITY_ORDER_ALGORITHMS_1_1.value;
+            if (!responseAlgorithms.includes(algorithm) || !CLIENT_SUPPORTED_ALGORITHMS.includes(algorithm)) {
+                continue;
+            }
+            validChecksumAlgorithms.push(algorithm);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (PRIORITY_ORDER_ALGORITHMS_1_1 && !PRIORITY_ORDER_ALGORITHMS_1_1.done && (_a = PRIORITY_ORDER_ALGORITHMS_1.return)) _a.call(PRIORITY_ORDER_ALGORITHMS_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return validChecksumAlgorithms;
+};

package/dist-es/getChecksumLocationName.js

@@ -0,0 +1,4 @@
+import { ChecksumAlgorithm } from "./constants";
+export var getChecksumLocationName = function (algorithm) {
+    return algorithm === ChecksumAlgorithm.MD5 ? "content-md5" : "x-amz-checksum-" + algorithm.toLowerCase();
+};

package/dist-es/getFlexibleChecksumsPlugin.js

@@ -0,0 +1,12 @@
+import { flexibleChecksumsMiddleware } from "./flexibleChecksumsMiddleware";
+export var flexibleChecksumsMiddlewareOptions = {
+    name: "flexibleChecksumsMiddleware",
+    step: "build",
+    tags: ["BODY_CHECKSUM"],
+    override: true,
+};
+export var getFlexibleChecksumsPlugin = function (config, middlewareConfig) { return ({
+    applyToStack: function (clientStack) {
+        clientStack.add(flexibleChecksumsMiddleware(config, middlewareConfig), flexibleChecksumsMiddlewareOptions);
+    },
+}); };

package/dist-es/hasHeader.js

@@ -0,0 +1,21 @@
+import { __values } from "tslib";
+export var hasHeader = function (header, headers) {
+    var e_1, _a;
+    var soughtHeader = header.toLowerCase();
+    try {
+        for (var _b = __values(Object.keys(headers)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var headerName = _c.value;
+            if (soughtHeader === headerName.toLowerCase()) {
+                return true;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return false;
+};

package/dist-es/index.js

@@ -0,0 +1,3 @@
+export * from "./constants";
+export * from "./flexibleChecksumsMiddleware";
+export * from "./getFlexibleChecksumsPlugin";

package/dist-es/isStreaming.js

@@ -0,0 +1,4 @@
+import { isArrayBuffer } from "@aws-sdk/is-array-buffer";
+export var isStreaming = function (body) {
+    return body !== undefined && typeof body !== "string" && !ArrayBuffer.isView(body) && !isArrayBuffer(body);
+};

package/dist-es/selectChecksumAlgorithmFunction.js

@@ -0,0 +1,13 @@
+import { AwsCrc32 } from "@aws-crypto/crc32";
+import { AwsCrc32c } from "@aws-crypto/crc32c";
+import { ChecksumAlgorithm } from "./constants";
+export var selectChecksumAlgorithmFunction = function (checksumAlgorithm, config) {
+    var _a;
+    return ((_a = {},
+        _a[ChecksumAlgorithm.MD5] = config.md5,
+        _a[ChecksumAlgorithm.CRC32] = AwsCrc32,
+        _a[ChecksumAlgorithm.CRC32C] = AwsCrc32c,
+        _a[ChecksumAlgorithm.SHA1] = config.sha1,
+        _a[ChecksumAlgorithm.SHA256] = config.sha256,
+        _a)[checksumAlgorithm]);
+};

package/dist-es/stringHasher.js

@@ -0,0 +1,5 @@
+export var stringHasher = function (checksumAlgorithmFn, body) {
+    var hash = new checksumAlgorithmFn();
+    hash.update(body || "");
+    return hash.digest();
+};

package/dist-es/types.js

@@ -0,0 +1,13 @@
+import { ChecksumAlgorithm } from "./constants";
+export var CLIENT_SUPPORTED_ALGORITHMS = [
+    ChecksumAlgorithm.CRC32,
+    ChecksumAlgorithm.CRC32C,
+    ChecksumAlgorithm.SHA1,
+    ChecksumAlgorithm.SHA256,
+];
+export var PRIORITY_ORDER_ALGORITHMS = [
+    ChecksumAlgorithm.CRC32,
+    ChecksumAlgorithm.CRC32C,
+    ChecksumAlgorithm.SHA1,
+    ChecksumAlgorithm.SHA256,
+];

package/dist-es/validateChecksumFromResponse.js

@@ -0,0 +1,55 @@
+import { __awaiter, __generator, __values } from "tslib";
+import { getChecksum } from "./getChecksum";
+import { getChecksumAlgorithmListForResponse } from "./getChecksumAlgorithmListForResponse";
+import { getChecksumLocationName } from "./getChecksumLocationName";
+import { selectChecksumAlgorithmFunction } from "./selectChecksumAlgorithmFunction";
+export var validateChecksumFromResponse = function (response, _a) {
+    var config = _a.config, responseAlgorithms = _a.responseAlgorithms;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var checksumAlgorithms, responseBody, responseHeaders, checksumAlgorithms_1, checksumAlgorithms_1_1, algorithm, responseHeader, checksumFromResponse, checksumAlgorithmFn, streamHasher, base64Encoder, checksum, e_1_1;
+        var e_1, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    checksumAlgorithms = getChecksumAlgorithmListForResponse(responseAlgorithms);
+                    responseBody = response.body, responseHeaders = response.headers;
+                    _c.label = 1;
+                case 1:
+                    _c.trys.push([1, 6, 7, 8]);
+                    checksumAlgorithms_1 = __values(checksumAlgorithms), checksumAlgorithms_1_1 = checksumAlgorithms_1.next();
+                    _c.label = 2;
+                case 2:
+                    if (!!checksumAlgorithms_1_1.done) return [3, 5];
+                    algorithm = checksumAlgorithms_1_1.value;
+                    responseHeader = getChecksumLocationName(algorithm);
+                    checksumFromResponse = responseHeaders[responseHeader];
+                    if (!checksumFromResponse) return [3, 4];
+                    checksumAlgorithmFn = selectChecksumAlgorithmFunction(algorithm, config);
+                    streamHasher = config.streamHasher, base64Encoder = config.base64Encoder;
+                    return [4, getChecksum(responseBody, { streamHasher: streamHasher, checksumAlgorithmFn: checksumAlgorithmFn, base64Encoder: base64Encoder })];
+                case 3:
+                    checksum = _c.sent();
+                    if (checksum === checksumFromResponse) {
+                        return [3, 5];
+                    }
+                    throw new Error("Checksum mismatch: expected \"" + checksum + "\" but received \"" + checksumFromResponse + "\"" +
+                        (" in response header \"" + responseHeader + "\"."));
+                case 4:
+                    checksumAlgorithms_1_1 = checksumAlgorithms_1.next();
+                    return [3, 2];
+                case 5: return [3, 8];
+                case 6:
+                    e_1_1 = _c.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3, 8];
+                case 7:
+                    try {
+                        if (checksumAlgorithms_1_1 && !checksumAlgorithms_1_1.done && (_b = checksumAlgorithms_1.return)) _b.call(checksumAlgorithms_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                    return [7];
+                case 8: return [2];
+            }
+        });
+    });
+};

package/dist-types/configuration.d.ts

@@ -0,0 +1,36 @@
+import { Encoder, GetAwsChunkedEncodingStream, HashConstructor, StreamHasher } from "@aws-sdk/types";
+export interface PreviouslyResolved {
+    /**
+     * The function that will be used to convert binary data to a base64-encoded string.
+     * @internal
+     */
+    base64Encoder: Encoder;
+    /**
+     * A function that can calculate the length of a body.
+     */
+    bodyLengthChecker: (body: any) => number | undefined;
+    /**
+     * A function that returns Readable Stream which follows aws-chunked encoding stream.
+     */
+    getAwsChunkedEncodingStream: GetAwsChunkedEncodingStream;
+    /**
+     * A constructor for a class implementing the {@link Hash} interface that computes MD5 hashes.
+     * @internal
+     */
+    md5: HashConstructor;
+    /**
+     * A constructor for a class implementing the {@link Hash} interface that computes SHA1 hashes.
+     * @internal
+     */
+    sha1: HashConstructor;
+    /**
+     * A constructor for a class implementing the {@link Hash} interface that computes SHA256 hashes.
+     * @internal
+     */
+    sha256: HashConstructor;
+    /**
+     * A function that, given a hash constructor and a stream, calculates the hash of the streamed value.
+     * @internal
+     */
+    streamHasher: StreamHasher<any>;
+}

package/dist-types/constants.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Checksum Algorithms supported by the SDK.
+ */
+export declare enum ChecksumAlgorithm {
+    MD5 = "MD5",
+    CRC32 = "CRC32",
+    CRC32C = "CRC32C",
+    SHA1 = "SHA1",
+    SHA256 = "SHA256"
+}
+/**
+ * Location when the checksum is stored in the request body.
+ */
+export declare enum ChecksumLocation {
+    HEADER = "header",
+    TRAILER = "trailer"
+}

package/dist-types/flexibleChecksumsMiddleware.d.ts

@@ -0,0 +1,4 @@
+import { BuildMiddleware } from "@aws-sdk/types";
+import { PreviouslyResolved } from "./configuration";
+import { FlexibleChecksumsMiddlewareConfig } from "./getFlexibleChecksumsPlugin";
+export declare const flexibleChecksumsMiddleware: (config: PreviouslyResolved, middlewareConfig: FlexibleChecksumsMiddlewareConfig) => BuildMiddleware<any, any>;

package/dist-types/getChecksum.d.ts

@@ -0,0 +1,7 @@
+import { Encoder, HashConstructor, StreamHasher } from "@aws-sdk/types";
+export interface GetChecksumDigestOptions {
+    streamHasher: StreamHasher<any>;
+    checksumAlgorithmFn: HashConstructor;
+    base64Encoder: Encoder;
+}
+export declare const getChecksum: (body: unknown, { streamHasher, checksumAlgorithmFn, base64Encoder }: GetChecksumDigestOptions) => Promise<string>;

package/dist-types/getChecksumAlgorithmForRequest.d.ts

@@ -0,0 +1,17 @@
+import { ChecksumAlgorithm } from "./constants";
+export interface GetChecksumAlgorithmForRequestOptions {
+    /**
+     * Indicates an operation requires a checksum in its HTTP request.
+     */
+    requestChecksumRequired: boolean;
+    /**
+     * Defines a top-level operation input member that is used to configure request checksum behavior.
+     */
+    requestAlgorithmMember?: string;
+}
+/**
+ * Returns the checksum algorithm to use for the request, along with
+ * the priority array of location to use to populate checksum and names
+ * to be used as a key at the location.
+ */
+export declare const getChecksumAlgorithmForRequest: (input: any, { requestChecksumRequired, requestAlgorithmMember }: GetChecksumAlgorithmForRequestOptions) => ChecksumAlgorithm | undefined;

package/dist-types/getChecksumAlgorithmListForResponse.d.ts

@@ -0,0 +1,6 @@
+import { ChecksumAlgorithm } from "./constants";
+/**
+ * Returns the priority array of algorithm to use to verify checksum and names
+ * to be used as a key in the response header.
+ */
+export declare const getChecksumAlgorithmListForResponse: (responseAlgorithms?: string[]) => ChecksumAlgorithm[];

package/dist-types/getChecksumLocationName.d.ts

@@ -0,0 +1,5 @@
+import { ChecksumAlgorithm } from "./constants";
+/**
+ * Returns location (header/trailer) name to use to populate checksum in.
+ */
+export declare const getChecksumLocationName: (algorithm: ChecksumAlgorithm) => string;

package/dist-types/getFlexibleChecksumsPlugin.d.ts

@@ -0,0 +1,28 @@
+import { BuildHandlerOptions, Pluggable } from "@aws-sdk/types";
+import { PreviouslyResolved } from "./configuration";
+export declare const flexibleChecksumsMiddlewareOptions: BuildHandlerOptions;
+export interface FlexibleChecksumsMiddlewareConfig {
+    /**
+     * The input object for the operation.
+     */
+    input: Object;
+    /**
+     * Indicates an operation requires a checksum in its HTTP request.
+     */
+    requestChecksumRequired: boolean;
+    /**
+     * Defines a top-level operation input member that is used to configure request checksum behavior.
+     */
+    requestAlgorithmMember?: string;
+    /**
+     * Defines a top-level operation input member used to opt-in to best-effort validation
+     * of a checksum returned in the HTTP response of the operation.
+     */
+    requestValidationModeMember?: string;
+    /**
+     * Defines the checksum algorithms clients SHOULD look for when validating checksums
+     * returned in the HTTP response.
+     */
+    responseAlgorithms?: string[];
+}
+export declare const getFlexibleChecksumsPlugin: (config: PreviouslyResolved, middlewareConfig: FlexibleChecksumsMiddlewareConfig) => Pluggable<any, any>;

package/dist-types/hasHeader.d.ts

@@ -0,0 +1,6 @@
+import { HeaderBag } from "@aws-sdk/types";
+/**
+ * Returns true if header is present in headers.
+ * Comparisons are case-insensitive.
+ */
+export declare const hasHeader: (header: string, headers: HeaderBag) => boolean;

package/dist-types/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./constants";
+export * from "./flexibleChecksumsMiddleware";
+export * from "./getFlexibleChecksumsPlugin";

package/dist-types/isStreaming.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Returns true if the given value is a streaming response.
+ */
+export declare const isStreaming: (body: unknown) => boolean;

package/dist-types/selectChecksumAlgorithmFunction.d.ts

@@ -0,0 +1,7 @@
+import { HashConstructor } from "@aws-sdk/types";
+import { PreviouslyResolved } from "./configuration";
+import { ChecksumAlgorithm } from "./constants";
+/**
+ * Returns the function that will compute the checksum for the given {@link ChecksumAlgorithm}.
+ */
+export declare const selectChecksumAlgorithmFunction: (checksumAlgorithm: ChecksumAlgorithm, config: PreviouslyResolved) => HashConstructor;

package/dist-types/stringHasher.d.ts

@@ -0,0 +1,5 @@
+import { HashConstructor } from "@aws-sdk/types";
+/**
+ * A function that, given a hash constructor and a string, calculates the hash of the string.
+ */
+export declare const stringHasher: (checksumAlgorithmFn: HashConstructor, body: any) => Promise<Uint8Array>;

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

@@ -0,0 +1,17 @@
+import { Encoder, GetAwsChunkedEncodingStream, HashConstructor, StreamHasher } from "@aws-sdk/types";
+export interface PreviouslyResolved {
+    
+    base64Encoder: Encoder;
+    
+    bodyLengthChecker: (body: any) => number | undefined;
+    
+    getAwsChunkedEncodingStream: GetAwsChunkedEncodingStream;
+    
+    md5: HashConstructor;
+    
+    sha1: HashConstructor;
+    
+    sha256: HashConstructor;
+    
+    streamHasher: StreamHasher<any>;
+}

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

@@ -0,0 +1,13 @@
+
+export declare enum ChecksumAlgorithm {
+    MD5 = "MD5",
+    CRC32 = "CRC32",
+    CRC32C = "CRC32C",
+    SHA1 = "SHA1",
+    SHA256 = "SHA256"
+}
+
+export declare enum ChecksumLocation {
+    HEADER = "header",
+    TRAILER = "trailer"
+}

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

@@ -0,0 +1,4 @@
+import { BuildMiddleware } from "@aws-sdk/types";
+import { PreviouslyResolved } from "./configuration";
+import { FlexibleChecksumsMiddlewareConfig } from "./getFlexibleChecksumsPlugin";
+export declare const flexibleChecksumsMiddleware: (config: PreviouslyResolved, middlewareConfig: FlexibleChecksumsMiddlewareConfig) => BuildMiddleware<any, any>;

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

@@ -0,0 +1,7 @@
+import { Encoder, HashConstructor, StreamHasher } from "@aws-sdk/types";
+export interface GetChecksumDigestOptions {
+    streamHasher: StreamHasher<any>;
+    checksumAlgorithmFn: HashConstructor;
+    base64Encoder: Encoder;
+}
+export declare const getChecksum: (body: unknown, { streamHasher, checksumAlgorithmFn, base64Encoder }: GetChecksumDigestOptions) => Promise<string>;

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

@@ -0,0 +1,9 @@
+import { ChecksumAlgorithm } from "./constants";
+export interface GetChecksumAlgorithmForRequestOptions {
+    
+    requestChecksumRequired: boolean;
+    
+    requestAlgorithmMember?: string;
+}
+
+export declare const getChecksumAlgorithmForRequest: (input: any, { requestChecksumRequired, requestAlgorithmMember }: GetChecksumAlgorithmForRequestOptions) => ChecksumAlgorithm | undefined;

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

@@ -0,0 +1,3 @@
+import { ChecksumAlgorithm } from "./constants";
+
+export declare const getChecksumAlgorithmListForResponse: (responseAlgorithms?: string[]) => ChecksumAlgorithm[];

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

@@ -0,0 +1,3 @@
+import { ChecksumAlgorithm } from "./constants";
+
+export declare const getChecksumLocationName: (algorithm: ChecksumAlgorithm) => string;

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

@@ -0,0 +1,16 @@
+import { BuildHandlerOptions, Pluggable } from "@aws-sdk/types";
+import { PreviouslyResolved } from "./configuration";
+export declare const flexibleChecksumsMiddlewareOptions: BuildHandlerOptions;
+export interface FlexibleChecksumsMiddlewareConfig {
+    
+    input: Object;
+    
+    requestChecksumRequired: boolean;
+    
+    requestAlgorithmMember?: string;
+    
+    requestValidationModeMember?: string;
+    
+    responseAlgorithms?: string[];
+}
+export declare const getFlexibleChecksumsPlugin: (config: PreviouslyResolved, middlewareConfig: FlexibleChecksumsMiddlewareConfig) => Pluggable<any, any>;

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

@@ -0,0 +1,3 @@
+import { HeaderBag } from "@aws-sdk/types";
+
+export declare const hasHeader: (header: string, headers: HeaderBag) => boolean;

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

@@ -0,0 +1,3 @@
+export * from "./constants";
+export * from "./flexibleChecksumsMiddleware";
+export * from "./getFlexibleChecksumsPlugin";

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

@@ -0,0 +1,2 @@
+
+export declare const isStreaming: (body: unknown) => boolean;

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

@@ -0,0 +1,5 @@
+import { HashConstructor } from "@aws-sdk/types";
+import { PreviouslyResolved } from "./configuration";
+import { ChecksumAlgorithm } from "./constants";
+
+export declare const selectChecksumAlgorithmFunction: (checksumAlgorithm: ChecksumAlgorithm, config: PreviouslyResolved) => HashConstructor;

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

@@ -0,0 +1,3 @@
+import { HashConstructor } from "@aws-sdk/types";
+
+export declare const stringHasher: (checksumAlgorithmFn: HashConstructor, body: any) => Promise<Uint8Array>;

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

@@ -0,0 +1,5 @@
+import { ChecksumAlgorithm } from "./constants";
+
+export declare const CLIENT_SUPPORTED_ALGORITHMS: ChecksumAlgorithm[];
+
+export declare const PRIORITY_ORDER_ALGORITHMS: ChecksumAlgorithm[];

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

@@ -0,0 +1,8 @@
+import { HttpResponse } from "@aws-sdk/protocol-http";
+import { PreviouslyResolved } from "./configuration";
+export interface ValidateChecksumFromResponseOptions {
+    config: PreviouslyResolved;
+    
+    responseAlgorithms?: string[];
+}
+export declare const validateChecksumFromResponse: (response: HttpResponse, { config, responseAlgorithms }: ValidateChecksumFromResponseOptions) => Promise<void>;

package/dist-types/types.d.ts

@@ -0,0 +1,10 @@
+import { ChecksumAlgorithm } from "./constants";
+/**
+ * List of algorithms supported by client.
+ */
+export declare const CLIENT_SUPPORTED_ALGORITHMS: ChecksumAlgorithm[];
+/**
+ * Priority order for validating checksum algorithm. A faster algorithm has higher priority.
+ * ToDo: update the priority order based on profiling of JavaScript implementations.
+ */
+export declare const PRIORITY_ORDER_ALGORITHMS: ChecksumAlgorithm[];

package/dist-types/validateChecksumFromResponse.d.ts

@@ -0,0 +1,11 @@
+import { HttpResponse } from "@aws-sdk/protocol-http";
+import { PreviouslyResolved } from "./configuration";
+export interface ValidateChecksumFromResponseOptions {
+    config: PreviouslyResolved;
+    /**
+     * Defines the checksum algorithms clients SHOULD look for when validating checksums
+     * returned in the HTTP response.
+     */
+    responseAlgorithms?: string[];
+}
+export declare const validateChecksumFromResponse: (response: HttpResponse, { config, responseAlgorithms }: ValidateChecksumFromResponseOptions) => Promise<void>;

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@aws-sdk/middleware-flexible-checksums",
+  "version": "3.53.0",
+  "scripts": {
+    "build": "concurrently '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",
+    "build:types:downlevel": "downlevel-dts dist-types dist-types/ts3.4",
+    "clean": "rimraf ./dist-* && rimraf *.tsbuildinfo",
+    "test": "jest --coverage"
+  },
+  "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-crypto/crc32": "2.0.0",
+    "@aws-crypto/crc32c": "2.0.0",
+    "@aws-sdk/is-array-buffer": "3.52.0",
+    "@aws-sdk/protocol-http": "3.53.0",
+    "@aws-sdk/types": "3.53.0",
+    "tslib": "^2.3.0"
+  },
+  "devDependencies": {
+    "concurrently": "7.0.0",
+    "downlevel-dts": "0.7.0",
+    "rimraf": "3.0.2",
+    "typescript": "~4.3.5"
+  },
+  "engines": {
+    "node": ">= 12.0.0"
+  },
+  "typesVersions": {
+    "<4.0": {
+      "dist-types/*": [
+        "dist-types/ts3.4/*"
+      ]
+    }
+  },
+  "files": [
+    "dist-*"
+  ],
+  "homepage": "https://github.com/aws/aws-sdk-js-v3/tree/main/packages/middleware-flexible-checksums",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aws/aws-sdk-js-v3.git",
+    "directory": "packages/middleware-flexible-checksums"
+  }
+}