@cdk8s/awscdk-resolver 0.0.562 → 0.0.564

package/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/checksum/ChecksumStream.js

@@ -0,0 +1,60 @@
+import { Duplex } from "node:stream";
+import { toBase64 } from "../../util-base64/toBase64";
+export class ChecksumStream extends Duplex {
+    expectedChecksum;
+    checksumSourceLocation;
+    checksum;
+    source;
+    base64Encoder;
+    pendingCallback = null;
+    constructor({ expectedChecksum, checksum, source, checksumSourceLocation, base64Encoder, }) {
+        super();
+        if (typeof source.pipe === "function") {
+            this.source = source;
+        }
+        else {
+            throw new Error(`@smithy/util-stream: unsupported source type ${source?.constructor?.name ?? source} in ChecksumStream.`);
+        }
+        this.base64Encoder = base64Encoder ?? toBase64;
+        this.expectedChecksum = expectedChecksum;
+        this.checksum = checksum;
+        this.checksumSourceLocation = checksumSourceLocation;
+        this.source.pipe(this);
+    }
+    _read(size) {
+        if (this.pendingCallback) {
+            const callback = this.pendingCallback;
+            this.pendingCallback = null;
+            callback();
+        }
+    }
+    _write(chunk, encoding, callback) {
+        try {
+            this.checksum.update(chunk);
+            const canPushMore = this.push(chunk);
+            if (!canPushMore) {
+                this.pendingCallback = callback;
+                return;
+            }
+        }
+        catch (e) {
+            return callback(e);
+        }
+        return callback();
+    }
+    async _final(callback) {
+        try {
+            const digest = await this.checksum.digest();
+            const received = this.base64Encoder(digest);
+            if (this.expectedChecksum !== received) {
+                return callback(new Error(`Checksum mismatch: expected "${this.expectedChecksum}" but received "${received}"` +
+                    ` in response header "${this.checksumSourceLocation}".`));
+            }
+        }
+        catch (e) {
+            return callback(e);
+        }
+        this.push(null);
+        return callback();
+    }
+}

package/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/checksum/createChecksumStream.browser.js

@@ -0,0 +1,35 @@
+import { toBase64 } from "../../util-base64/toBase64";
+import { isReadableStream } from "../stream-type-check";
+import { ChecksumStream } from "./ChecksumStream.browser";
+export const createChecksumStream = ({ expectedChecksum, checksum, source, checksumSourceLocation, base64Encoder, }) => {
+    if (!isReadableStream(source)) {
+        throw new Error(`@smithy/util-stream: unsupported source type ${source?.constructor?.name ?? source} in ChecksumStream.`);
+    }
+    const encoder = base64Encoder ?? toBase64;
+    if (typeof TransformStream !== "function") {
+        throw new Error("@smithy/util-stream: unable to instantiate ChecksumStream because API unavailable: ReadableStream/TransformStream.");
+    }
+    const transform = new TransformStream({
+        start() { },
+        async transform(chunk, controller) {
+            checksum.update(chunk);
+            controller.enqueue(chunk);
+        },
+        async flush(controller) {
+            const digest = await checksum.digest();
+            const received = encoder(digest);
+            if (expectedChecksum !== received) {
+                const error = new Error(`Checksum mismatch: expected "${expectedChecksum}" but received "${received}"` +
+                    ` in response header "${checksumSourceLocation}".`);
+                controller.error(error);
+            }
+            else {
+                controller.terminate();
+            }
+        },
+    });
+    source.pipeThrough(transform);
+    const readable = transform.readable;
+    Object.setPrototypeOf(readable, ChecksumStream.prototype);
+    return readable;
+};

package/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/checksum/createChecksumStream.js

@@ -0,0 +1,9 @@
+import { isReadableStream } from "../stream-type-check";
+import { ChecksumStream } from "./ChecksumStream";
+import { createChecksumStream as createChecksumStreamWeb, } from "./createChecksumStream.browser";
+export function createChecksumStream(init) {
+    if (typeof ReadableStream === "function" && isReadableStream(init.source)) {
+        return createChecksumStreamWeb(init);
+    }
+    return new ChecksumStream(init);
+}

package/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/createBufferedReadable.js

@@ -0,0 +1,57 @@
+import { Readable } from "node:stream";
+import { ByteArrayCollector } from "./ByteArrayCollector";
+import { createBufferedReadableStream, flush, merge, modeOf, sizeOf, } from "./createBufferedReadable.browser";
+import { isReadableStream } from "./stream-type-check";
+export function createBufferedReadable(upstream, size, logger) {
+    if (isReadableStream(upstream)) {
+        return createBufferedReadableStream(upstream, size, logger);
+    }
+    const downstream = new Readable({ read() { } });
+    let streamBufferingLoggedWarning = false;
+    let bytesSeen = 0;
+    const buffers = [
+        "",
+        new ByteArrayCollector((size) => new Uint8Array(size)),
+        new ByteArrayCollector((size) => Buffer.from(new Uint8Array(size))),
+    ];
+    let mode = -1;
+    upstream.on("data", (chunk) => {
+        const chunkMode = modeOf(chunk, true);
+        if (mode !== chunkMode) {
+            if (mode >= 0) {
+                downstream.push(flush(buffers, mode));
+            }
+            mode = chunkMode;
+        }
+        if (mode === -1) {
+            downstream.push(chunk);
+            return;
+        }
+        const chunkSize = sizeOf(chunk);
+        bytesSeen += chunkSize;
+        const bufferSize = sizeOf(buffers[mode]);
+        if (chunkSize >= size && bufferSize === 0) {
+            downstream.push(chunk);
+        }
+        else {
+            const newSize = merge(buffers, mode, chunk);
+            if (!streamBufferingLoggedWarning && bytesSeen > size * 2) {
+                streamBufferingLoggedWarning = true;
+                logger?.warn(`@smithy/util-stream - stream chunk size ${chunkSize} is below threshold of ${size}, automatically buffering.`);
+            }
+            if (newSize >= size) {
+                downstream.push(flush(buffers, mode));
+            }
+        }
+    });
+    upstream.on("end", () => {
+        if (mode !== -1) {
+            const remainder = flush(buffers, mode);
+            if (sizeOf(remainder) > 0) {
+                downstream.push(remainder);
+            }
+        }
+        downstream.push(null);
+    });
+    return downstream;
+}

package/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/headStream.js

@@ -0,0 +1,38 @@
+import { Writable } from "node:stream";
+import { headStream as headWebStream } from "./headStream.browser";
+import { isReadableStream } from "./stream-type-check";
+export const headStream = (stream, bytes) => {
+    if (isReadableStream(stream)) {
+        return headWebStream(stream, bytes);
+    }
+    return new Promise((resolve, reject) => {
+        const collector = new Collector();
+        collector.limit = bytes;
+        stream.pipe(collector);
+        stream.on("error", (err) => {
+            collector.end();
+            reject(err);
+        });
+        collector.on("error", reject);
+        collector.on("finish", function () {
+            const bytes = new Uint8Array(Buffer.concat(this.buffers));
+            resolve(bytes);
+        });
+    });
+};
+class Collector extends Writable {
+    buffers = [];
+    limit = Infinity;
+    bytesBuffered = 0;
+    _write(chunk, encoding, callback) {
+        this.buffers.push(chunk);
+        this.bytesBuffered += chunk.byteLength ?? 0;
+        if (this.bytesBuffered >= this.limit) {
+            const excess = this.bytesBuffered - this.limit;
+            const tailBuffer = this.buffers[this.buffers.length - 1];
+            this.buffers[this.buffers.length - 1] = tailBuffer.subarray(0, tailBuffer.byteLength - excess);
+            this.emit("finish");
+        }
+        callback();
+    }
+}

package/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/sdk-stream-mixin.browser.js

@@ -0,0 +1,64 @@
+import { toBase64 } from "../util-base64/toBase64";
+import { toHex } from "../util-hex-encoding/hex-encoding";
+import { toUtf8 } from "../util-utf8/toUtf8";
+import { streamCollector } from "./stream-collector.browser";
+import { isReadableStream } from "./stream-type-check";
+const ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED = "The stream has already been transformed.";
+export const sdkStreamMixin = (stream) => {
+    if (!isBlobInstance(stream) && !isReadableStream(stream)) {
+        const name = stream?.__proto__?.constructor?.name || stream;
+        throw new Error(`Unexpected stream implementation, expect Blob or ReadableStream, got ${name}`);
+    }
+    let transformed = false;
+    const transformToByteArray = async () => {
+        if (transformed) {
+            throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED);
+        }
+        transformed = true;
+        return await streamCollector(stream);
+    };
+    const blobToWebStream = (blob) => {
+        if (typeof blob.stream !== "function") {
+            throw new Error("Cannot transform payload Blob to web stream. Please make sure the Blob.stream() is polyfilled.\n" +
+                "If you are using React Native, this API is not yet supported, see: https://react-native.canny.io/feature-requests/p/fetch-streaming-body");
+        }
+        return blob.stream();
+    };
+    return Object.assign(stream, {
+        transformToByteArray: transformToByteArray,
+        transformToString: async (encoding) => {
+            const buf = await transformToByteArray();
+            if (encoding === "base64") {
+                return toBase64(buf);
+            }
+            else if (encoding === "hex") {
+                return toHex(buf);
+            }
+            else if (encoding === undefined || encoding === "utf8" || encoding === "utf-8") {
+                return toUtf8(buf);
+            }
+            else if (typeof TextDecoder === "function") {
+                return new TextDecoder(encoding).decode(buf);
+            }
+            else {
+                throw new Error("TextDecoder is not available, please make sure polyfill is provided.");
+            }
+        },
+        transformToWebStream: () => {
+            if (transformed) {
+                throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED);
+            }
+            transformed = true;
+            if (isBlobInstance(stream)) {
+                return blobToWebStream(stream);
+            }
+            else if (isReadableStream(stream)) {
+                return stream;
+            }
+            else {
+                throw new Error(`Cannot transform payload to web stream, got ${stream}`);
+            }
+        },
+    });
+};
+const isBlobInstance = (stream) => typeof Blob === "function" && stream instanceof Blob;

package/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/sdk-stream-mixin.js

@@ -0,0 +1,50 @@
+import { Readable } from "node:stream";
+import { fromArrayBuffer } from "../util-buffer-from/buffer-from";
+import { sdkStreamMixin as sdkStreamMixinReadableStream } from "./sdk-stream-mixin.browser";
+import { streamCollector } from "./stream-collector";
+const ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED = "The stream has already been transformed.";
+export const sdkStreamMixin = (stream) => {
+    if (!(stream instanceof Readable)) {
+        try {
+            return sdkStreamMixinReadableStream(stream);
+        }
+        catch (e) {
+            const name = stream?.__proto__?.constructor?.name || stream;
+            throw new Error(`Unexpected stream implementation, expect Stream.Readable instance, got ${name}`);
+        }
+    }
+    let transformed = false;
+    const transformToByteArray = async () => {
+        if (transformed) {
+            throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED);
+        }
+        transformed = true;
+        return await streamCollector(stream);
+    };
+    return Object.assign(stream, {
+        transformToByteArray,
+        transformToString: async (encoding) => {
+            const buf = await transformToByteArray();
+            if (encoding === undefined || Buffer.isEncoding(encoding)) {
+                return fromArrayBuffer(buf.buffer, buf.byteOffset, buf.byteLength).toString(encoding);
+            }
+            else {
+                const decoder = new TextDecoder(encoding);
+                return decoder.decode(buf);
+            }
+        },
+        transformToWebStream: () => {
+            if (transformed) {
+                throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED);
+            }
+            if (stream.readableFlowing !== null) {
+                throw new Error("The stream has been consumed by other callbacks.");
+            }
+            if (typeof Readable.toWeb !== "function") {
+                throw new Error("Readable.toWeb() is not supported. Please ensure a polyfill is available.");
+            }
+            transformed = true;
+            return Readable.toWeb(stream);
+        },
+    });
+};

package/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/splitStream.js

@@ -0,0 +1,13 @@
+import { PassThrough } from "node:stream";
+import { splitStream as splitWebStream } from "./splitStream.browser";
+import { isBlob, isReadableStream } from "./stream-type-check";
+export async function splitStream(stream) {
+    if (isReadableStream(stream) || isBlob(stream)) {
+        return splitWebStream(stream);
+    }
+    const stream1 = new PassThrough();
+    const stream2 = new PassThrough();
+    stream.pipe(stream1);
+    stream.pipe(stream2);
+    return [stream1, stream2];
+}

package/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/stream-collector.browser.js

@@ -0,0 +1,53 @@
+import { fromBase64 } from "../util-base64/fromBase64";
+export const streamCollector = async (stream) => {
+    if ((typeof Blob === "function" && stream instanceof Blob) || stream.constructor?.name === "Blob") {
+        if (Blob.prototype.arrayBuffer !== undefined) {
+            return new Uint8Array(await stream.arrayBuffer());
+        }
+        return collectBlob(stream);
+    }
+    return collectStream(stream);
+};
+async function collectBlob(blob) {
+    const base64 = await readToBase64(blob);
+    const arrayBuffer = fromBase64(base64);
+    return new Uint8Array(arrayBuffer);
+}
+async function collectStream(stream) {
+    const chunks = [];
+    const reader = stream.getReader();
+    let isDone = false;
+    let length = 0;
+    while (!isDone) {
+        const { done, value } = await reader.read();
+        if (value) {
+            chunks.push(value);
+            length += value.length;
+        }
+        isDone = done;
+    }
+    const collected = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+        collected.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return collected;
+}
+function readToBase64(blob) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onloadend = () => {
+            if (reader.readyState !== 2) {
+                return reject(new Error("Reader aborted too early"));
+            }
+            const result = (reader.result ?? "");
+            const commaIndex = result.indexOf(",");
+            const dataOffset = commaIndex > -1 ? commaIndex + 1 : result.length;
+            resolve(result.substring(dataOffset));
+        };
+        reader.onabort = () => reject(new Error("Read aborted"));
+        reader.onerror = () => reject(reader.error);
+        reader.readAsDataURL(blob);
+    });
+}

package/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/stream-collector.js

@@ -0,0 +1,48 @@
+import { Writable } from "node:stream";
+class Collector extends Writable {
+    bufferedBytes = [];
+    _write(chunk, encoding, callback) {
+        this.bufferedBytes.push(chunk);
+        callback();
+    }
+}
+const isReadableStreamInstance = (stream) => typeof ReadableStream === "function" && stream instanceof ReadableStream;
+async function collectReadableStream(stream) {
+    const chunks = [];
+    const reader = stream.getReader();
+    let isDone = false;
+    let length = 0;
+    while (!isDone) {
+        const { done, value } = await reader.read();
+        if (value) {
+            chunks.push(value);
+            length += value.length;
+        }
+        isDone = done;
+    }
+    const collected = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+        collected.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return collected;
+}
+export const streamCollector = (stream) => {
+    if (isReadableStreamInstance(stream)) {
+        return collectReadableStream(stream);
+    }
+    return new Promise((resolve, reject) => {
+        const collector = new Collector();
+        stream.pipe(collector);
+        stream.on("error", (err) => {
+            collector.end();
+            reject(err);
+        });
+        collector.on("error", reject);
+        collector.on("finish", function () {
+            const bytes = new Uint8Array(Buffer.concat(this.bufferedBytes));
+            resolve(bytes);
+        });
+    });
+};

package/node_modules/@smithy/core/dist-es/submodules/serde/util-utf8/fromUtf8.js

@@ -0,0 +1,5 @@
+import { fromString } from "../util-buffer-from/buffer-from";
+export const fromUtf8 = (input) => {
+    const buf = fromString(input, "utf8");
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+};

package/node_modules/@smithy/core/dist-es/submodules/serde/util-utf8/toUtf8.js

@@ -0,0 +1,10 @@
+import { fromArrayBuffer } from "../util-buffer-from/buffer-from";
+export const toUtf8 = (input) => {
+    if (typeof input === "string") {
+        return input;
+    }
+    if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
+        throw new Error("@smithy/util-utf8: toUtf8 encoder function only accepts string | Uint8Array.");
+    }
+    return fromArrayBuffer(input.buffer, input.byteOffset, input.byteLength).toString("utf8");
+};

package/node_modules/@smithy/core/dist-es/submodules/serde/uuid/v4.js

@@ -0,0 +1,32 @@
+const decimalToHex = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+export function bindV4(getRandomValues) {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+        return () => crypto.randomUUID();
+    }
+    return () => {
+        const rnds = new Uint8Array(16);
+        getRandomValues(rnds);
+        rnds[6] = (rnds[6] & 0x0f) | 0x40;
+        rnds[8] = (rnds[8] & 0x3f) | 0x80;
+        return (decimalToHex[rnds[0]] +
+            decimalToHex[rnds[1]] +
+            decimalToHex[rnds[2]] +
+            decimalToHex[rnds[3]] +
+            "-" +
+            decimalToHex[rnds[4]] +
+            decimalToHex[rnds[5]] +
+            "-" +
+            decimalToHex[rnds[6]] +
+            decimalToHex[rnds[7]] +
+            "-" +
+            decimalToHex[rnds[8]] +
+            decimalToHex[rnds[9]] +
+            "-" +
+            decimalToHex[rnds[10]] +
+            decimalToHex[rnds[11]] +
+            decimalToHex[rnds[12]] +
+            decimalToHex[rnds[13]] +
+            decimalToHex[rnds[14]] +
+            decimalToHex[rnds[15]]);
+    };
+}

package/node_modules/@smithy/core/dist-es/util-identity-and-auth/httpAuthSchemes/httpApiKeyAuth.js

@@ -1,5 +1,5 @@
-import { HttpRequest } from "@smithy/protocol-http";
-import { HttpApiKeyAuthLocation } from "@smithy/types";
+import { HttpRequest } from "@smithy/core/protocols";
+import { HttpApiKeyAuthLocation, } from "@smithy/types";
 export class HttpApiKeyAuthSigner {
     async sign(httpRequest, identity, signingProperties) {
         if (!signingProperties) {

package/node_modules/@smithy/core/dist-es/util-identity-and-auth/httpAuthSchemes/httpBearerAuth.js

@@ -1,4 +1,4 @@
-import { HttpRequest } from "@smithy/protocol-http";
+import { HttpRequest } from "@smithy/core/protocols";
 export class HttpBearerAuthSigner {
     async sign(httpRequest, identity, signingProperties) {
         const clonedRequest = HttpRequest.clone(httpRequest);

package/node_modules/@smithy/core/dist-types/getSmithyContext.d.ts

@@ -1,4 +1,4 @@
-import type { HandlerExecutionContext } from "@smithy/types";
+import { type HandlerExecutionContext } from "@smithy/types";
 /**
  * @internal
  */

package/node_modules/@smithy/core/dist-types/middleware-http-auth-scheme/getHttpAuthSchemeEndpointRuleSetPlugin.d.ts

@@ -1,5 +1,5 @@
 import type { HandlerExecutionContext, HttpAuthSchemeParameters, HttpAuthSchemeParametersProvider, IdentityProviderConfig, Pluggable, RelativeMiddlewareOptions, SerializeHandlerOptions } from "@smithy/types";
-import type { PreviouslyResolved } from "./httpAuthSchemeMiddleware";
+import { type PreviouslyResolved } from "./httpAuthSchemeMiddleware";
 /**
  * @internal
  */

package/node_modules/@smithy/core/dist-types/middleware-http-auth-scheme/getHttpAuthSchemePlugin.d.ts

@@ -1,5 +1,5 @@
 import type { HandlerExecutionContext, HttpAuthSchemeParameters, HttpAuthSchemeParametersProvider, IdentityProviderConfig, Pluggable, RelativeMiddlewareOptions, SerializeHandlerOptions } from "@smithy/types";
-import type { PreviouslyResolved } from "./httpAuthSchemeMiddleware";
+import { type PreviouslyResolved } from "./httpAuthSchemeMiddleware";
 /**
  * @internal
  */

package/node_modules/@smithy/core/dist-types/middleware-http-auth-scheme/httpAuthSchemeMiddleware.d.ts

@@ -1,4 +1,4 @@
-import type { HandlerExecutionContext, HttpAuthScheme, HttpAuthSchemeParameters, HttpAuthSchemeParametersProvider, HttpAuthSchemeProvider, IdentityProviderConfig, Provider, SelectedHttpAuthScheme, SerializeMiddleware, SMITHY_CONTEXT_KEY } from "@smithy/types";
+import type { HandlerExecutionContext, HttpAuthScheme, HttpAuthSchemeParameters, HttpAuthSchemeParametersProvider, HttpAuthSchemeProvider, IdentityProviderConfig, Provider, SMITHY_CONTEXT_KEY, SelectedHttpAuthScheme, SerializeMiddleware } from "@smithy/types";
 /**
  * @internal
  */

package/node_modules/@smithy/core/dist-types/pagination/createPaginator.d.ts

@@ -1,7 +1,7 @@
 import type { PaginationConfiguration, Paginator } from "@smithy/types";
 /**
- * @internal
- *
  * Creates a paginator.
+ *
+ * @internal
  */
 export declare function createPaginator<PaginationConfigType extends PaginationConfiguration, InputType extends object, OutputType extends object>(ClientCtor: any, CommandCtor: any, inputTokenName: string, outputTokenName: string, pageSizeTokenName?: string): (config: PaginationConfigType, input: InputType, ...additionalArguments: any[]) => Paginator<OutputType>;

package/node_modules/@smithy/core/dist-types/request-builder/requestBuilder.d.ts

@@ -1,5 +1,6 @@
 /**
- * @internal
  * Backwards compatibility re-export.
+ *
+ * @internal
  */
 export { requestBuilder } from "@smithy/core/protocols";

package/node_modules/@smithy/core/dist-types/setFeature.d.ts

@@ -1,12 +1,12 @@
 import type { HandlerExecutionContext, SmithyFeatures } from "@smithy/types";
 /**
- * @internal
  * Indicates to the request context that a given feature is active.
+ * specification asks the library not to include a runtime lookup of all
+ * the feature identifiers.
  *
+ * @internal
  * @param context - handler execution context.
  * @param feature - readable name of feature.
  * @param value - encoding value of feature. This is required because the
- * specification asks the library not to include a runtime lookup of all
- * the feature identifiers.
  */
 export declare function setFeature<F extends keyof SmithyFeatures>(context: HandlerExecutionContext, feature: F, value: SmithyFeatures[F]): void;

package/node_modules/@smithy/core/dist-types/submodules/cbor/cbor-decode.d.ts

@@ -1,14 +1,15 @@
-import type { CborValueType, Float32, Uint8, Uint32 } from "./cbor-types";
+import { type CborValueType, type Float32, type Uint8, type Uint32 } from "./cbor-types";
 /**
+ * Sets the decode bytearray source and its data view.
+ *
  * @internal
  * @param bytes - to be set as the decode source.
- *
- * Sets the decode bytearray source and its data view.
  */
 export declare function setPayload(bytes: Uint8Array): void;
 /**
- * @internal
  * Decodes the data between the two indices.
+ *
+ * @internal
  */
 export declare function decode(at: Uint32, to: Uint32): CborValueType;
 /**

package/node_modules/@smithy/core/dist-types/submodules/cbor/cbor-types.d.ts

@@ -39,17 +39,17 @@ export declare const extendedFloat64 = 27;
 export declare const minorIndefinite = 31;
 export declare function alloc(size: number): Uint8Array;
 /**
- * @public
- *
  * The presence of this symbol as an object key indicates it should be considered a tag
  * for CBOR serialization purposes.
- *
  * The object must also have the properties "tag" and "value".
+ *
+ * @public
  */
 export declare const tagSymbol: unique symbol;
 /**
- * @public
  * Applies the tag symbol to the object.
+ *
+ * @public
  */
 export declare function tag(data: {
     tag: number | bigint;

package/node_modules/@smithy/core/dist-types/submodules/cbor/cbor.d.ts

@@ -12,15 +12,14 @@ export declare const cbor: {
     deserialize(payload: Uint8Array): any;
     serialize(input: any): Uint8Array;
     /**
-     * @public
-     * @param size - byte length to allocate.
-     *
      * This may be used to garbage collect the CBOR
      * shared encoding buffer space,
      * e.g. resizeEncodingBuffer(0);
-     *
      * This may also be used to pre-allocate more space for
      * CBOR encoding, e.g. resizeEncodingBuffer(100_000_000);
+     *
+     * @public
+     * @param size - byte length to allocate.
      */
     resizeEncodingBuffer(size: number): void;
 };

package/node_modules/@smithy/core/dist-types/submodules/cbor/parseCborBody.d.ts

@@ -1,6 +1,6 @@
-import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
-import type { HeaderBag as __HeaderBag, HttpResponse, SerdeContext as __SerdeContext, SerdeContext } from "@smithy/types";
-import type { tagSymbol } from "./cbor-types";
+import { HttpRequest as __HttpRequest } from "@smithy/core/protocols";
+import type { HttpResponse, SerdeContext, HeaderBag as __HeaderBag, SerdeContext as __SerdeContext } from "@smithy/types";
+import { type tagSymbol } from "./cbor-types";
 /**
  * @internal
  */

package/node_modules/@smithy/core/dist-types/submodules/checksum/chunked-blob-reader/chunked-blob-reader.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Reads the blob data into the onChunk consumer.
+ *
+ * @internal
+ */
+export declare function blobReader(blob: Blob, onChunk: (chunk: Uint8Array) => void, chunkSize?: number): Promise<void>;

package/node_modules/@smithy/core/dist-types/submodules/checksum/chunked-blob-reader/chunked-blob-reader.native.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @internal
+ */
+export declare function blobReader(blob: Blob, onChunk: (chunk: Uint8Array) => void, chunkSize?: number): Promise<void>;