@depup/aws-sdk__checksums 3.1000.18-depup.0

package/dist-es/submodules/sha/sha1/Sha1WebCrypto.js

@@ -0,0 +1,71 @@
+import { concatBytes, toUint8Array } from "@smithy/core/serde";
+import { Sha1Js } from "./Sha1Js";
+const { digest, sign, importKey } = globalThis?.crypto?.subtle ?? {};
+const subtle = typeof digest === "function" && typeof sign === "function" && typeof importKey === "function"
+    ? globalThis.crypto.subtle
+    : undefined;
+const MAX_PENDING_BYTES = 8 * 1024 * 1024;
+export class Sha1WebCrypto {
+    digestLength = 20;
+    secret;
+    pending = [];
+    pendingBytes = 0;
+    fallback;
+    finished = false;
+    constructor(secret) {
+        if (secret) {
+            this.secret = toUint8Array(secret);
+        }
+    }
+    update(data) {
+        if (this.finished) {
+            throw new Error("Attempted to update an already finished HMAC.");
+        }
+        if (this.fallback) {
+            this.fallback.update(data);
+            return;
+        }
+        this.pending.push(data.slice());
+        this.pendingBytes += data.byteLength;
+        if (this.pendingBytes >= MAX_PENDING_BYTES) {
+            this.switchToFallback();
+        }
+    }
+    async digest() {
+        if (this.fallback) {
+            return this.fallback.digest();
+        }
+        if (this.secret && this.finished) {
+            throw new Error("Attempted to digest an already finished HMAC.");
+        }
+        const data = concatBytes(this.pending);
+        if (subtle) {
+            if (this.secret) {
+                this.finished = true;
+                const key = await subtle.importKey("raw", this.secret, { name: "HMAC", hash: "SHA-1" }, false, ["sign"]);
+                const sig = await subtle.sign("HMAC", key, data);
+                return new Uint8Array(sig);
+            }
+            const hash = await subtle.digest("SHA-1", data);
+            return new Uint8Array(hash);
+        }
+        const sha1 = new Sha1Js(this.secret);
+        sha1.update(data);
+        return sha1.digest();
+    }
+    reset() {
+        this.pending = [];
+        this.pendingBytes = 0;
+        this.fallback = undefined;
+        this.finished = false;
+    }
+    switchToFallback() {
+        const sha1Js = new Sha1Js(this.secret);
+        for (const chunk of this.pending) {
+            sha1Js.update(chunk);
+        }
+        this.fallback = sha1Js;
+        this.pending = [];
+        this.pendingBytes = 0;
+    }
+}

package/dist-types/index.d.ts

@@ -0,0 +1,3 @@
+export { Crc64Nvme, Crc64NvmeJs, crc64NvmeCrtContainer } from "@aws-sdk/checksums/crc";
+export { ENV_REQUEST_CHECKSUM_CALCULATION, CONFIG_REQUEST_CHECKSUM_CALCULATION, NODE_REQUEST_CHECKSUM_CALCULATION_CONFIG_OPTIONS, ENV_RESPONSE_CHECKSUM_VALIDATION, CONFIG_RESPONSE_CHECKSUM_VALIDATION, NODE_RESPONSE_CHECKSUM_VALIDATION_CONFIG_OPTIONS, RequestChecksumCalculation, DEFAULT_REQUEST_CHECKSUM_CALCULATION, ResponseChecksumValidation, DEFAULT_RESPONSE_CHECKSUM_VALIDATION, ChecksumAlgorithm, ChecksumLocation, DEFAULT_CHECKSUM_ALGORITHM, flexibleChecksumsMiddlewareOptions, flexibleChecksumsMiddleware, getFlexibleChecksumsPlugin, resolveFlexibleChecksumsConfig, } from "@aws-sdk/checksums/flexible-checksums";
+export type { FlexibleChecksumsRequestMiddlewareConfig, FlexibleChecksumsMiddlewareConfig, FlexibleChecksumsInputConfig, FlexibleChecksumsResolvedConfig, } from "@aws-sdk/checksums/flexible-checksums";

package/dist-types/submodules/crc/crc32c/Crc32cJs.d.ts

@@ -0,0 +1,13 @@
+import type { Checksum } from "@smithy/types";
+/**
+ * Pure JS CRC-32C using the Castagnoli polynomial.
+ * Non-destructive digest — safe to call digest() multiple times.
+ * @public
+ */
+export declare class Crc32cJs implements Checksum {
+    readonly digestLength = 4;
+    private crc;
+    update(data: Uint8Array): void;
+    digest(): Promise<Uint8Array>;
+    reset(): void;
+}

package/dist-types/submodules/crc/crc32c/Crc32cNode.d.ts

@@ -0,0 +1,13 @@
+import type { Checksum } from "@smithy/types";
+/**
+ * CRC-32C (Castagnoli). No native Node.js implementation exists,
+ * so this is equivalent to the pure JS version.
+ * @public
+ */
+export interface Crc32cNode extends Checksum {
+    readonly digestLength: 4;
+}
+/**
+ * @public
+ */
+export declare const Crc32cNode: new () => Crc32cNode;

package/dist-types/submodules/crc/crc64-nvme/Crc64Nvme.d.ts

@@ -0,0 +1,21 @@
+import type { Checksum } from "@smithy/types";
+/**
+ * CRC-64/NVME checksum. Uses the CRT native implementation if loaded,
+ * otherwise falls back to the pure JS implementation.
+ *
+ * @example
+ * ```typescript
+ * const checksum = new Crc64Nvme();
+ * checksum.update(new Uint8Array([1, 2, 3]));
+ * const result = await checksum.digest();
+ * ```
+ *
+ * @public
+ */
+export declare class Crc64Nvme implements Checksum {
+    private impl;
+    constructor();
+    update(data: Uint8Array): void;
+    digest(): Promise<Uint8Array>;
+    reset(): void;
+}

package/dist-types/submodules/crc/crc64-nvme/Crc64NvmeJs.d.ts

@@ -0,0 +1,14 @@
+import type { Checksum } from "@smithy/types";
+/**
+ * Pure JS CRC-64/NVME implementation using the NVMe polynomial (0x9a6c9329ac4bc9b5).
+ * Uses an 8-slice lookup table for efficient computation.
+ * @public
+ */
+export declare class Crc64NvmeJs implements Checksum {
+    private c1;
+    private c2;
+    constructor();
+    update(data: Uint8Array): void;
+    digest(): Promise<Uint8Array>;
+    reset(): void;
+}

package/dist-types/submodules/crc/crc64-nvme/crc64-nvme-crt-container.d.ts

@@ -0,0 +1,11 @@
+import type { ChecksumConstructor } from "@smithy/types";
+/**
+ * \@aws-sdk/crc64-nvme-crt will install the constructor in this
+ * container if it is installed.
+ *
+ * This avoids a runtime-require being interpreted statically by bundlers.
+ * @internal
+ */
+export declare const crc64NvmeCrtContainer: {
+    CrtCrc64Nvme: null | ChecksumConstructor;
+};

package/dist-types/submodules/crc/index.browser.d.ts

@@ -0,0 +1,5 @@
+export { Crc32cJs, Crc32cJs as Crc32c } from "./crc32c/Crc32cJs";
+export declare const Crc32cNode: symbol;
+export { Crc64NvmeJs, Crc64NvmeJs as Crc64Nvme } from "./crc64-nvme/Crc64NvmeJs";
+export { crc64NvmeCrtContainer } from "./crc64-nvme/crc64-nvme-crt-container";
+export { Crc32, Crc32Js, Crc32Node } from "@smithy/core/checksum";

package/dist-types/submodules/crc/index.d.ts

@@ -0,0 +1,6 @@
+export { Crc32cJs } from "./crc32c/Crc32cJs";
+export { Crc32cNode, Crc32cNode as Crc32c } from "./crc32c/Crc32cNode";
+export { Crc64Nvme } from "./crc64-nvme/Crc64Nvme";
+export { Crc64NvmeJs } from "./crc64-nvme/Crc64NvmeJs";
+export { crc64NvmeCrtContainer } from "./crc64-nvme/crc64-nvme-crt-container";
+export { Crc32, Crc32Js, Crc32Node } from "@smithy/core/checksum";

package/dist-types/submodules/flexible-checksums/NODE_REQUEST_CHECKSUM_CALCULATION_CONFIG_OPTIONS.d.ts

@@ -0,0 +1,14 @@
+import type { LoadedConfigSelectors } from "@smithy/core/config";
+import { RequestChecksumCalculation } from "./constants";
+/**
+ * @internal
+ */
+export declare const ENV_REQUEST_CHECKSUM_CALCULATION = "AWS_REQUEST_CHECKSUM_CALCULATION";
+/**
+ * @internal
+ */
+export declare const CONFIG_REQUEST_CHECKSUM_CALCULATION = "request_checksum_calculation";
+/**
+ * @internal
+ */
+export declare const NODE_REQUEST_CHECKSUM_CALCULATION_CONFIG_OPTIONS: LoadedConfigSelectors<RequestChecksumCalculation>;

package/dist-types/submodules/flexible-checksums/NODE_RESPONSE_CHECKSUM_VALIDATION_CONFIG_OPTIONS.d.ts

@@ -0,0 +1,14 @@
+import type { LoadedConfigSelectors } from "@smithy/core/config";
+import { ResponseChecksumValidation } from "./constants";
+/**
+ * @internal
+ */
+export declare const ENV_RESPONSE_CHECKSUM_VALIDATION = "AWS_RESPONSE_CHECKSUM_VALIDATION";
+/**
+ * @internal
+ */
+export declare const CONFIG_RESPONSE_CHECKSUM_VALIDATION = "response_checksum_validation";
+/**
+ * @internal
+ */
+export declare const NODE_RESPONSE_CHECKSUM_VALIDATION_CONFIG_OPTIONS: LoadedConfigSelectors<ResponseChecksumValidation>;

package/dist-types/submodules/flexible-checksums/configuration.d.ts

@@ -0,0 +1,58 @@
+import type { BodyLengthCalculator, ChecksumConstructor, Encoder, GetAwsChunkedEncodingStream, HashConstructor, Provider, StreamCollector, StreamHasher } from "@smithy/types";
+import type { RequestChecksumCalculation, ResponseChecksumValidation } from "./constants";
+import type { FlexibleChecksumsInputConfig } from "./resolveFlexibleChecksumsConfig";
+/**
+ * @internal
+ */
+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: BodyLengthCalculator;
+    /**
+     * 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: ChecksumConstructor | HashConstructor;
+    /**
+     * Determines when a checksum will be calculated for request payloads
+     */
+    requestChecksumCalculation: Provider<RequestChecksumCalculation>;
+    /**
+     * Determines when a checksum will be calculated for response payloads
+     */
+    responseChecksumValidation: Provider<ResponseChecksumValidation>;
+    /**
+     * A constructor for a class implementing the {@link Hash} interface that computes SHA1 hashes.
+     * @internal
+     */
+    sha1: ChecksumConstructor | HashConstructor;
+    /**
+     * A constructor for a class implementing the {@link Hash} interface that computes SHA256 hashes.
+     * @internal
+     */
+    sha256: ChecksumConstructor | HashConstructor;
+    /**
+     * A function that, given a hash constructor and a stream, calculates the hash of the streamed value.
+     * @internal
+     */
+    streamHasher: StreamHasher<any>;
+    /**
+     * Collects streams into buffers.
+     */
+    streamCollector: StreamCollector;
+    /**
+     * Minimum bytes from a stream to buffer into a chunk before passing to chunked encoding.
+     */
+    requestStreamBufferSize: number;
+    checksumAlgorithms?: FlexibleChecksumsInputConfig["checksumAlgorithms"];
+}

package/dist-types/submodules/flexible-checksums/constants.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Determines when a checksum will be calculated for request payloads.
+ * @public
+ */
+export declare const RequestChecksumCalculation: {
+    /**
+     * When set, a checksum will be calculated for all request payloads of operations
+     * modeled with the {@link httpChecksum} trait where `requestChecksumRequired` is `true`
+     * AND/OR a `requestAlgorithmMember` is modeled.
+     * {@link https://smithy.io/2.0/aws/aws-core.html#aws-protocols-httpchecksum-trait httpChecksum}
+     */
+    readonly WHEN_SUPPORTED: "WHEN_SUPPORTED";
+    /**
+     * When set, a checksum will only be calculated for request payloads of operations
+     * modeled with the {@link httpChecksum} trait where `requestChecksumRequired` is `true`
+     * OR where a `requestAlgorithmMember` is modeled and the user sets it.
+     * {@link https://smithy.io/2.0/aws/aws-core.html#aws-protocols-httpchecksum-trait httpChecksum}
+     */
+    readonly WHEN_REQUIRED: "WHEN_REQUIRED";
+};
+/**
+ * @public
+ */
+export type RequestChecksumCalculation = (typeof RequestChecksumCalculation)[keyof typeof RequestChecksumCalculation];
+/**
+ * @internal
+ */
+export declare const DEFAULT_REQUEST_CHECKSUM_CALCULATION: "WHEN_SUPPORTED";
+/**
+ * Determines when checksum validation will be performed on response payloads.
+ * @public
+ */
+export declare const ResponseChecksumValidation: {
+    /**
+     * When set, checksum validation MUST be performed on all response payloads of operations
+     * modeled with the {@link httpChecksum} trait where `responseAlgorithms` is modeled,
+     * except when no modeled checksum algorithms are supported by an SDK.
+     * {@link https://smithy.io/2.0/aws/aws-core.html#aws-protocols-httpchecksum-trait httpChecksum}
+     */
+    readonly WHEN_SUPPORTED: "WHEN_SUPPORTED";
+    /**
+     * When set, checksum validation MUST NOT be performed on response payloads of operations UNLESS
+     * the SDK supports the modeled checksum algorithms AND the user has set the `requestValidationModeMember` to `ENABLED`.
+     * It is currently impossible to model an operation as requiring a response checksum,
+     * but this setting leaves the door open for future updates.
+     */
+    readonly WHEN_REQUIRED: "WHEN_REQUIRED";
+};
+/**
+ * @public
+ */
+export type ResponseChecksumValidation = (typeof ResponseChecksumValidation)[keyof typeof ResponseChecksumValidation];
+/**
+ * @internal
+ */
+export declare const DEFAULT_RESPONSE_CHECKSUM_VALIDATION: "WHEN_SUPPORTED";
+/**
+ * Checksum Algorithms supported by the SDK.
+ * @public
+ */
+export declare enum ChecksumAlgorithm {
+    /**
+     * @deprecated Use {@link ChecksumAlgorithm.CRC32} instead.
+     */
+    MD5 = "MD5",
+    CRC32 = "CRC32",
+    CRC32C = "CRC32C",
+    CRC64NVME = "CRC64NVME",
+    SHA1 = "SHA1",
+    SHA256 = "SHA256"
+}
+/**
+ * Location when the checksum is stored in the request body.
+ * @internal
+ */
+export declare enum ChecksumLocation {
+    HEADER = "header",
+    TRAILER = "trailer"
+}
+/**
+ * @internal
+ */
+export declare const DEFAULT_CHECKSUM_ALGORITHM = ChecksumAlgorithm.CRC32;

package/dist-types/submodules/flexible-checksums/flexibleChecksumsInputMiddleware.d.ts

@@ -0,0 +1,22 @@
+import type { RelativeMiddlewareOptions, SerializeMiddleware } from "@smithy/types";
+import type { PreviouslyResolved } from "./configuration";
+/**
+ * @internal
+ */
+export interface FlexibleChecksumsInputMiddlewareConfig {
+    /**
+     * 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;
+}
+/**
+ * @internal
+ */
+export declare const flexibleChecksumsInputMiddlewareOptions: RelativeMiddlewareOptions;
+/**
+ * @internal
+ *
+ * The input counterpart to the flexibleChecksumsMiddleware.
+ */
+export declare const flexibleChecksumsInputMiddleware: (config: PreviouslyResolved, middlewareConfig: FlexibleChecksumsInputMiddlewareConfig) => SerializeMiddleware<any, any>;

package/dist-types/submodules/flexible-checksums/flexibleChecksumsMiddleware.d.ts

@@ -0,0 +1,33 @@
+import type { BuildHandlerOptions, BuildMiddleware } from "@smithy/types";
+import type { PreviouslyResolved } from "./configuration";
+/**
+ * @internal
+ */
+export interface FlexibleChecksumsRequestMiddlewareConfig {
+    /**
+     * Indicates an operation requires a checksum in its HTTP request.
+     */
+    requestChecksumRequired: boolean;
+    /**
+     * Member that is used to configure request checksum behavior.
+     */
+    requestAlgorithmMember?: {
+        /**
+         * Defines a top-level operation input member that is used to configure request checksum behavior.
+         */
+        name: string;
+        /**
+         * The {@link httpHeader} value, if present.
+         * {@link https://smithy.io/2.0/spec/http-bindings.html#httpheader-trait httpHeader}
+         */
+        httpHeader?: string;
+    };
+}
+/**
+ * @internal
+ */
+export declare const flexibleChecksumsMiddlewareOptions: BuildHandlerOptions;
+/**
+ * @internal
+ */
+export declare const flexibleChecksumsMiddleware: (config: PreviouslyResolved, middlewareConfig: FlexibleChecksumsRequestMiddlewareConfig) => BuildMiddleware<any, any>;

package/dist-types/submodules/flexible-checksums/flexibleChecksumsResponseMiddleware.d.ts

@@ -0,0 +1,27 @@
+import type { DeserializeMiddleware, RelativeMiddlewareOptions } from "@smithy/types";
+import type { PreviouslyResolved } from "./configuration";
+/**
+ * @internal
+ */
+export interface FlexibleChecksumsResponseMiddlewareConfig {
+    /**
+     * 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[];
+}
+/**
+ * @internal
+ */
+export declare const flexibleChecksumsResponseMiddlewareOptions: RelativeMiddlewareOptions;
+/**
+ * @internal
+ *
+ * The validation counterpart to the flexibleChecksumsMiddleware.
+ */
+export declare const flexibleChecksumsResponseMiddleware: (config: PreviouslyResolved, middlewareConfig: FlexibleChecksumsResponseMiddlewareConfig) => DeserializeMiddleware<any, any>;

package/dist-types/submodules/flexible-checksums/getChecksum.d.ts

@@ -0,0 +1,6 @@
+import type { ChecksumConstructor, Encoder, HashConstructor } from "@smithy/types";
+export interface GetChecksumDigestOptions {
+    checksumAlgorithmFn: ChecksumConstructor | HashConstructor;
+    base64Encoder: Encoder;
+}
+export declare const getChecksum: (body: unknown, { checksumAlgorithmFn, base64Encoder }: GetChecksumDigestOptions) => Promise<string>;

package/dist-types/submodules/flexible-checksums/getChecksumAlgorithmForRequest.d.ts

@@ -0,0 +1,22 @@
+import type { ChecksumAlgorithm } from "./constants";
+import { RequestChecksumCalculation } 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;
+    /**
+     * Determines when a checksum will be calculated for request payloads
+     */
+    requestChecksumCalculation: RequestChecksumCalculation;
+}
+/**
+ * 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, requestChecksumCalculation }: GetChecksumAlgorithmForRequestOptions) => ChecksumAlgorithm | string | undefined;

package/dist-types/submodules/flexible-checksums/getChecksumAlgorithmListForResponse.d.ts

@@ -0,0 +1,6 @@
+import type { 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/submodules/flexible-checksums/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) => string;

package/dist-types/submodules/flexible-checksums/getFlexibleChecksumsPlugin.d.ts

@@ -0,0 +1,14 @@
+import type { Pluggable } from "@smithy/types";
+import type { PreviouslyResolved } from "./configuration";
+import type { FlexibleChecksumsInputMiddlewareConfig } from "./flexibleChecksumsInputMiddleware";
+import type { FlexibleChecksumsRequestMiddlewareConfig } from "./flexibleChecksumsMiddleware";
+import type { FlexibleChecksumsResponseMiddlewareConfig } from "./flexibleChecksumsResponseMiddleware";
+/**
+ * @internal
+ */
+export interface FlexibleChecksumsMiddlewareConfig extends FlexibleChecksumsRequestMiddlewareConfig, FlexibleChecksumsInputMiddlewareConfig, FlexibleChecksumsResponseMiddlewareConfig {
+}
+/**
+ * @internal
+ */
+export declare const getFlexibleChecksumsPlugin: (config: PreviouslyResolved, middlewareConfig: FlexibleChecksumsMiddlewareConfig) => Pluggable<any, any>;

package/dist-types/submodules/flexible-checksums/hasHeader.d.ts

@@ -0,0 +1,6 @@
+import type { HeaderBag } from "@smithy/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/submodules/flexible-checksums/hasHeaderWithPrefix.d.ts

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

package/dist-types/submodules/flexible-checksums/index.d.ts

@@ -0,0 +1,9 @@
+export { ENV_REQUEST_CHECKSUM_CALCULATION, CONFIG_REQUEST_CHECKSUM_CALCULATION, NODE_REQUEST_CHECKSUM_CALCULATION_CONFIG_OPTIONS, } from "./NODE_REQUEST_CHECKSUM_CALCULATION_CONFIG_OPTIONS";
+export { ENV_RESPONSE_CHECKSUM_VALIDATION, CONFIG_RESPONSE_CHECKSUM_VALIDATION, NODE_RESPONSE_CHECKSUM_VALIDATION_CONFIG_OPTIONS, } from "./NODE_RESPONSE_CHECKSUM_VALIDATION_CONFIG_OPTIONS";
+export { RequestChecksumCalculation, DEFAULT_REQUEST_CHECKSUM_CALCULATION, ResponseChecksumValidation, DEFAULT_RESPONSE_CHECKSUM_VALIDATION, ChecksumAlgorithm, ChecksumLocation, DEFAULT_CHECKSUM_ALGORITHM, } from "./constants";
+export type { FlexibleChecksumsRequestMiddlewareConfig } from "./flexibleChecksumsMiddleware";
+export { flexibleChecksumsMiddlewareOptions, flexibleChecksumsMiddleware } from "./flexibleChecksumsMiddleware";
+export type { FlexibleChecksumsMiddlewareConfig } from "./getFlexibleChecksumsPlugin";
+export { getFlexibleChecksumsPlugin } from "./getFlexibleChecksumsPlugin";
+export type { FlexibleChecksumsInputConfig, FlexibleChecksumsResolvedConfig } from "./resolveFlexibleChecksumsConfig";
+export { resolveFlexibleChecksumsConfig } from "./resolveFlexibleChecksumsConfig";

package/dist-types/submodules/flexible-checksums/isChecksumWithPartNumber.d.ts

@@ -0,0 +1 @@
+export declare const isChecksumWithPartNumber: (checksum: string) => boolean;

package/dist-types/submodules/flexible-checksums/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/submodules/flexible-checksums/resolveFlexibleChecksumsConfig.d.ts

@@ -0,0 +1,57 @@
+import type { ChecksumConstructor, Provider } from "@smithy/types";
+import type { RequestChecksumCalculation, ResponseChecksumValidation } from "./constants";
+/**
+ * @public
+ */
+export interface FlexibleChecksumsInputConfig {
+    /**
+     * Determines when a checksum will be calculated for request payloads.
+     */
+    requestChecksumCalculation?: RequestChecksumCalculation | Provider<RequestChecksumCalculation>;
+    /**
+     * Determines when checksum validation will be performed on response payloads.
+     */
+    responseChecksumValidation?: ResponseChecksumValidation | Provider<ResponseChecksumValidation>;
+    /**
+     * Default 0 (off).
+     *
+     * When set to a value greater than or equal to 8192, sets the minimum number
+     * of bytes to buffer into a chunk when processing input streams
+     * with chunked encoding (that is, when request checksums are enabled).
+     * A minimum of 8kb = 8 * 1024 is required, and 64kb or higher is recommended.
+     *
+     * See https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-streaming.html.
+     *
+     * This has a slight performance penalty because it must wrap and buffer
+     * your input stream.
+     * You do not need to set this value if your stream already flows chunks
+     * of 8kb or greater.
+     */
+    requestStreamBufferSize?: number | false;
+    /**
+     * Optional implementations of checksum algorithms adhering to the
+     * Checksum interface.
+     */
+    checksumAlgorithms?: {
+        CRC32?: ChecksumConstructor;
+        CRC32C?: ChecksumConstructor;
+        CRC64NVME?: ChecksumConstructor;
+        SHA1?: ChecksumConstructor;
+        SHA256?: ChecksumConstructor;
+    } & {
+        [algorithmId: string]: ChecksumConstructor;
+    };
+}
+/**
+ * @internal
+ */
+export interface FlexibleChecksumsResolvedConfig {
+    requestChecksumCalculation: Provider<RequestChecksumCalculation>;
+    responseChecksumValidation: Provider<ResponseChecksumValidation>;
+    requestStreamBufferSize: number;
+    checksumAlgorithms?: FlexibleChecksumsInputConfig["checksumAlgorithms"];
+}
+/**
+ * @internal
+ */
+export declare const resolveFlexibleChecksumsConfig: <T>(input: T & FlexibleChecksumsInputConfig) => T & FlexibleChecksumsResolvedConfig;

package/dist-types/submodules/flexible-checksums/selectChecksumAlgorithmFunction.d.ts

@@ -0,0 +1,7 @@
+import type { ChecksumConstructor, HashConstructor } from "@smithy/types";
+import type { 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 | string, config: PreviouslyResolved) => ChecksumConstructor | HashConstructor;

package/dist-types/submodules/flexible-checksums/stringHasher.d.ts

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

package/dist-types/submodules/flexible-checksums/stringUnionSelector.d.ts

@@ -0,0 +1,12 @@
+export declare enum SelectorType {
+    ENV = "env",
+    CONFIG = "shared config entry"
+}
+/**
+ * Returns undefined, if obj[key] is not defined.
+ * Returns string value, if the string is defined in obj[key] and it's uppercase matches union value.
+ * Throws error for all other cases.
+ *
+ * @internal
+ */
+export declare const stringUnionSelector: <U extends object, K extends keyof U>(obj: Record<string, string | undefined>, key: string, union: U, type: SelectorType) => U[K] | undefined;

package/dist-types/submodules/flexible-checksums/types.d.ts

@@ -0,0 +1,9 @@
+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.
+ */
+export declare const PRIORITY_ORDER_ALGORITHMS: ChecksumAlgorithm[];

package/dist-types/submodules/flexible-checksums/validateChecksumFromResponse.d.ts

@@ -0,0 +1,13 @@
+import type { HttpResponse } from "@smithy/core/protocols";
+import type { Logger } from "@smithy/types";
+import type { 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[];
+    logger?: Logger;
+}
+export declare const validateChecksumFromResponse: (response: HttpResponse, { config, responseAlgorithms, logger }: ValidateChecksumFromResponseOptions) => Promise<void>;

package/dist-types/submodules/md5/index.d.ts

@@ -0,0 +1 @@
+export { Md5, Md5Js, Md5Node } from "@smithy/core/checksum";

package/dist-types/submodules/sha/index.browser.d.ts

@@ -0,0 +1,3 @@
+export { Sha1Js, Sha1Js as Sha1 } from "./sha1/Sha1Js";
+export declare const Sha1Node: symbol;
+export { Sha256, Sha256Js, Sha256Node, Sha256WebCrypto } from "@smithy/core/checksum";