@openclaw/amazon-bedrock-provider 2026.9.8 → 2026.10.1-beta.2

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/utils/evaluateTemplate.js

@@ -1,33 +0,0 @@
-import { getAttr } from "../lib";
-export const evaluateTemplate = (template, options) => {
-    const evaluatedTemplateArr = [];
-    const { referenceRecord, endpointParams } = options;
-    let currentIndex = 0;
-    while (currentIndex < template.length) {
-        const openingBraceIndex = template.indexOf("{", currentIndex);
-        if (openingBraceIndex === -1) {
-            evaluatedTemplateArr.push(template.slice(currentIndex));
-            break;
-        }
-        evaluatedTemplateArr.push(template.slice(currentIndex, openingBraceIndex));
-        const closingBraceIndex = template.indexOf("}", openingBraceIndex);
-        if (closingBraceIndex === -1) {
-            evaluatedTemplateArr.push(template.slice(openingBraceIndex));
-            break;
-        }
-        if (template[openingBraceIndex + 1] === "{" && template[closingBraceIndex + 1] === "}") {
-            evaluatedTemplateArr.push(template.slice(openingBraceIndex + 1, closingBraceIndex));
-            currentIndex = closingBraceIndex + 2;
-        }
-        const parameterName = template.substring(openingBraceIndex + 1, closingBraceIndex);
-        if (parameterName.includes("#")) {
-            const [refName, attrName] = parameterName.split("#");
-            evaluatedTemplateArr.push(getAttr((referenceRecord[refName] ?? endpointParams[refName]), attrName));
-        }
-        else {
-            evaluatedTemplateArr.push((referenceRecord[parameterName] ?? endpointParams[parameterName]));
-        }
-        currentIndex = closingBraceIndex + 1;
-    }
-    return evaluatedTemplateArr.join("");
-};

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/utils/evaluateTreeRule.js

@@ -1 +0,0 @@
-export { evaluateTreeRule } from "./evaluateRules";

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/utils/getEndpointHeaders.js

@@ -1,12 +0,0 @@
-import { EndpointError } from "../types";
-import { evaluateExpression } from "./evaluateExpression";
-export const getEndpointHeaders = (headers, options) => Object.entries(headers ?? {}).reduce((acc, [headerKey, headerVal]) => {
-    acc[headerKey] = headerVal.map((headerValEntry) => {
-        const processedExpr = evaluateExpression(headerValEntry, "Header value entry", options);
-        if (typeof processedExpr !== "string") {
-            throw new EndpointError(`Header '${headerKey}' value '${processedExpr}' is not a string`);
-        }
-        return processedExpr;
-    });
-    return acc;
-}, {});

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/utils/getEndpointProperties.js

@@ -1,28 +0,0 @@
-import { EndpointError } from "../types";
-import { evaluateTemplate } from "./evaluateTemplate";
-export const getEndpointProperties = (properties, options) => Object.entries(properties).reduce((acc, [propertyKey, propertyVal]) => {
-    acc[propertyKey] = group.getEndpointProperty(propertyVal, options);
-    return acc;
-}, {});
-export const getEndpointProperty = (property, options) => {
-    if (Array.isArray(property)) {
-        return property.map((propertyEntry) => getEndpointProperty(propertyEntry, options));
-    }
-    switch (typeof property) {
-        case "string":
-            return evaluateTemplate(property, options);
-        case "object":
-            if (property === null) {
-                throw new EndpointError(`Unexpected endpoint property: ${property}`);
-            }
-            return group.getEndpointProperties(property, options);
-        case "boolean":
-            return property;
-        default:
-            throw new EndpointError(`Unexpected endpoint property type: ${typeof property}`);
-    }
-};
-export const group = {
-    getEndpointProperty,
-    getEndpointProperties,
-};

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/utils/getEndpointProperty.js

@@ -1 +0,0 @@
-export { getEndpointProperty } from "./getEndpointProperties";

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/utils/getEndpointUrl.js

@@ -1,15 +0,0 @@
-import { EndpointError } from "../types";
-import { evaluateExpression } from "./evaluateExpression";
-export const getEndpointUrl = (endpointUrl, options) => {
-    const expression = evaluateExpression(endpointUrl, "Endpoint URL", options);
-    if (typeof expression === "string") {
-        try {
-            return new URL(expression);
-        }
-        catch (error) {
-            console.error(`Failed to construct URL with ${expression}`, error);
-            throw error;
-        }
-    }
-    throw new EndpointError(`Endpoint URL must be a string, got ${typeof expression}`);
-};

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/utils/getReferenceValue.js

@@ -1,3 +0,0 @@
-export const getReferenceValue = ({ ref }, options) => {
-    return options.referenceRecord[ref] ?? options.endpointParams[ref];
-};

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/utils/index.js

@@ -1,2 +0,0 @@
-export { customEndpointFunctions } from "./customEndpointFunctions";
-export { evaluateRules, evaluateTreeRule, group } from "./evaluateRules";

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/errors/errors.js

@@ -1,18 +0,0 @@
-export class SmithyError extends Error {
-    name = "SmithyError";
-    $source = errors.$source;
-}
-export class SmithyTypeError extends TypeError {
-    name = "SmithyTypeError";
-    $source = errors.$source;
-}
-export class SmithyRangeError extends RangeError {
-    name = "SmithyRangeError";
-    $source = errors.$source;
-}
-export const errors = {
-    $source: "smithy",
-    Error: SmithyError,
-    TypeError: SmithyTypeError,
-    RangeError: SmithyRangeError,
-};

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/errors/index.js

@@ -1 +0,0 @@
-export { errors } from "./errors";

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/event-streams/EventStreamSerde.js

@@ -1,292 +0,0 @@
-import { hasOwn } from "@smithy/core/transport";
-import { TypeRegistry } from "@smithy/core/schema";
-import { fromUtf8, toUtf8 } from "@smithy/core/serde";
-export class EventStreamSerde {
-    marshaller;
-    serializer;
-    deserializer;
-    serdeContext;
-    defaultContentType;
-    compositeErrorRegistry;
-    constructor({ marshaller, serializer, deserializer, serdeContext, defaultContentType, compositeErrorRegistry, }) {
-        this.marshaller = marshaller;
-        this.serializer = serializer;
-        this.deserializer = deserializer;
-        this.serdeContext = serdeContext;
-        this.defaultContentType = defaultContentType;
-        this.compositeErrorRegistry = compositeErrorRegistry;
-    }
-    async serializeEventStream({ eventStream, requestSchema, initialRequest, initialMessageType, }) {
-        const marshaller = this.marshaller;
-        const eventStreamMember = requestSchema.getEventStreamMember();
-        const unionSchema = requestSchema.getMemberSchema(eventStreamMember);
-        const serializer = this.serializer;
-        const defaultContentType = this.defaultContentType;
-        const initialRequestMarker = Symbol("initialRequestMarker");
-        const eventStreamIterable = {
-            async *[Symbol.asyncIterator]() {
-                if (initialRequest) {
-                    const headers = {
-                        ":event-type": { type: "string", value: initialMessageType ?? "initial-request" },
-                        ":message-type": { type: "string", value: "event" },
-                        ":content-type": { type: "string", value: defaultContentType },
-                    };
-                    serializer.write(requestSchema, initialRequest);
-                    const body = serializer.flush();
-                    yield {
-                        [initialRequestMarker]: true,
-                        headers,
-                        body,
-                    };
-                }
-                for await (const page of eventStream) {
-                    yield page;
-                }
-            },
-        };
-        return marshaller.serialize(eventStreamIterable, (event) => {
-            if (event[initialRequestMarker]) {
-                return {
-                    headers: event.headers,
-                    body: event.body,
-                };
-            }
-            let unionMember = "";
-            for (const key in event) {
-                if (!hasOwn(event, key))
-                    continue;
-                if (key !== "__type") {
-                    unionMember = key;
-                    break;
-                }
-            }
-            const { additionalHeaders, body, eventType, explicitPayloadContentType } = this.writeEventBody(unionMember, unionSchema, event);
-            const headers = {
-                ":event-type": { type: "string", value: eventType },
-                ":message-type": { type: "string", value: "event" },
-                ":content-type": { type: "string", value: explicitPayloadContentType ?? defaultContentType },
-                ...additionalHeaders,
-            };
-            return {
-                headers,
-                body,
-            };
-        });
-    }
-    async deserializeEventStream({ response, responseSchema, initialResponseContainer, initialMessageType, }) {
-        const marshaller = this.marshaller;
-        const eventStreamMember = responseSchema.getEventStreamMember();
-        const unionSchema = responseSchema.getMemberSchema(eventStreamMember);
-        const memberSchemas = unionSchema.getMemberSchemas();
-        const initialResponseMarker = Symbol("initialResponseMarker");
-        const asyncIterable = marshaller.deserialize(response.body, async (event) => {
-            let unionMember = "";
-            for (const key in event) {
-                if (!hasOwn(event, key))
-                    continue;
-                if (key !== "__type") {
-                    unionMember = key;
-                    break;
-                }
-            }
-            const body = event[unionMember].body;
-            if (unionMember === (initialMessageType ?? "initial-response")) {
-                const dataObject = await this.deserializer.read(responseSchema, body);
-                delete dataObject[eventStreamMember];
-                return {
-                    [initialResponseMarker]: true,
-                    ...dataObject,
-                };
-            }
-            else if (unionMember in memberSchemas) {
-                const eventStreamSchema = memberSchemas[unionMember];
-                if (eventStreamSchema.isStructSchema()) {
-                    const out = {};
-                    let hasBindings = false;
-                    for (const [name, member] of eventStreamSchema.structIterator()) {
-                        const { eventHeader, eventPayload } = member.getMergedTraits();
-                        hasBindings = hasBindings || Boolean(eventHeader || eventPayload);
-                        if (eventPayload) {
-                            if (member.isBlobSchema()) {
-                                out[name] = body;
-                            }
-                            else if (member.isStringSchema()) {
-                                out[name] = (this.serdeContext?.utf8Encoder ?? toUtf8)(body);
-                            }
-                            else if (member.isStructSchema()) {
-                                out[name] = await this.deserializer.read(member, body);
-                            }
-                        }
-                        else if (eventHeader) {
-                            const value = event[unionMember].headers[name]?.value;
-                            if (value != null) {
-                                if (member.isNumericSchema()) {
-                                    if (value && typeof value === "object" && "bytes" in value) {
-                                        out[name] = BigInt(value.toString());
-                                    }
-                                    else {
-                                        out[name] = Number(value);
-                                    }
-                                }
-                                else {
-                                    out[name] = value;
-                                }
-                            }
-                        }
-                    }
-                    return {
-                        [unionMember]: await this.readEventMember(eventStreamSchema, body, hasBindings, out),
-                    };
-                }
-                return {
-                    [unionMember]: await this.deserializer.read(eventStreamSchema, body),
-                };
-            }
-            else {
-                return {
-                    $unknown: event,
-                };
-            }
-        });
-        const asyncIterator = asyncIterable[Symbol.asyncIterator]();
-        const firstEvent = await asyncIterator.next();
-        if (firstEvent.done) {
-            return asyncIterable;
-        }
-        if (firstEvent.value?.[initialResponseMarker]) {
-            if (!responseSchema) {
-                throw new Error("@smithy::core/protocols - initial-response event encountered in event stream but no response schema given.");
-            }
-            for (const key in firstEvent.value) {
-                if (!hasOwn(firstEvent.value, key))
-                    continue;
-                initialResponseContainer[key] = firstEvent.value[key];
-            }
-        }
-        return {
-            async *[Symbol.asyncIterator]() {
-                if (!firstEvent?.value?.[initialResponseMarker]) {
-                    yield firstEvent.value;
-                }
-                while (true) {
-                    const { done, value } = await asyncIterator.next();
-                    if (done) {
-                        break;
-                    }
-                    yield value;
-                }
-            },
-        };
-    }
-    async readEventMember(eventStreamSchema, body, hasBindings, out) {
-        let ErrCtor;
-        const staticStructuralSchema = eventStreamSchema.getSchema();
-        if (Array.isArray(staticStructuralSchema) && staticStructuralSchema[0] === -3) {
-            const namespace = staticStructuralSchema[1];
-            const nsRegistry = TypeRegistry.for(namespace);
-            this.compositeErrorRegistry?.copyFrom(nsRegistry);
-            ErrCtor = (this.compositeErrorRegistry ?? nsRegistry)?.getErrorCtor(staticStructuralSchema);
-        }
-        const dataObject = hasBindings
-            ? out
-            : body.byteLength === 0
-                ? {}
-                : await this.deserializer.read(eventStreamSchema, body);
-        if (ErrCtor) {
-            const message = dataObject.message ?? dataObject.Message ?? "Unknown";
-            const metadata = {};
-            const $fault = eventStreamSchema.getMergedTraits().error;
-            if ($fault) {
-                metadata.$fault = $fault;
-            }
-            return Object.assign(new ErrCtor({}), metadata, {
-                message,
-            }, dataObject);
-        }
-        return dataObject;
-    }
-    writeEventBody(unionMember, unionSchema, event) {
-        const serializer = this.serializer;
-        let eventType = unionMember;
-        let explicitPayloadMember = null;
-        let explicitPayloadContentType;
-        const isKnownSchema = (() => {
-            const struct = unionSchema.getSchema();
-            return struct[4].includes(unionMember);
-        })();
-        const additionalHeaders = {};
-        if (!isKnownSchema) {
-            const [type, value] = event[unionMember];
-            eventType = type;
-            serializer.write(15, value);
-        }
-        else {
-            const eventSchema = unionSchema.getMemberSchema(unionMember);
-            if (eventSchema.isStructSchema()) {
-                for (const [memberName, memberSchema] of eventSchema.structIterator()) {
-                    const { eventHeader, eventPayload } = memberSchema.getMergedTraits();
-                    if (eventPayload) {
-                        explicitPayloadMember = memberName;
-                    }
-                    else if (eventHeader) {
-                        const value = event[unionMember][memberName];
-                        let type = "binary";
-                        if (memberSchema.isNumericSchema()) {
-                            if ((-2) ** 31 <= value && value <= 2 ** 31 - 1) {
-                                type = "integer";
-                            }
-                            else {
-                                type = "long";
-                            }
-                        }
-                        else if (memberSchema.isTimestampSchema()) {
-                            type = "timestamp";
-                        }
-                        else if (memberSchema.isStringSchema()) {
-                            type = "string";
-                        }
-                        else if (memberSchema.isBooleanSchema()) {
-                            type = "boolean";
-                        }
-                        if (value != null) {
-                            additionalHeaders[memberName] = {
-                                type,
-                                value,
-                            };
-                            delete event[unionMember][memberName];
-                        }
-                    }
-                }
-                if (explicitPayloadMember !== null) {
-                    const payloadSchema = eventSchema.getMemberSchema(explicitPayloadMember);
-                    if (payloadSchema.isBlobSchema()) {
-                        explicitPayloadContentType = "application/octet-stream";
-                    }
-                    else if (payloadSchema.isStringSchema()) {
-                        explicitPayloadContentType = "text/plain";
-                    }
-                    serializer.write(payloadSchema, event[unionMember][explicitPayloadMember]);
-                }
-                else {
-                    serializer.write(eventSchema, event[unionMember]);
-                }
-            }
-            else if (eventSchema.isUnitSchema()) {
-                serializer.write(eventSchema, {});
-            }
-            else {
-                throw new Error("@smithy/core/event-streams - non-struct member not supported in event stream union.");
-            }
-        }
-        const messageSerialization = serializer.flush() ?? new Uint8Array();
-        const body = typeof messageSerialization === "string"
-            ? (this.serdeContext?.utf8Decoder ?? fromUtf8)(messageSerialization)
-            : messageSerialization;
-        return {
-            body,
-            eventType,
-            explicitPayloadContentType,
-            additionalHeaders,
-        };
-    }
-}

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-codec/EventStreamCodec.js

@@ -1,67 +0,0 @@
-import { Crc32 } from "@smithy/core/checksum";
-import { HeaderMarshaller } from "./HeaderMarshaller";
-import { splitMessage } from "./splitMessage";
-export class EventStreamCodec {
-    headerMarshaller;
-    messageBuffer;
-    isEndOfStream;
-    constructor(toUtf8, fromUtf8) {
-        this.headerMarshaller = new HeaderMarshaller(toUtf8, fromUtf8);
-        this.messageBuffer = [];
-        this.isEndOfStream = false;
-    }
-    feed(message) {
-        this.messageBuffer.push(this.decode(message));
-    }
-    endOfStream() {
-        this.isEndOfStream = true;
-    }
-    getMessage() {
-        const message = this.messageBuffer.pop();
-        const isEndOfStream = this.isEndOfStream;
-        return {
-            getMessage() {
-                return message;
-            },
-            isEndOfStream() {
-                return isEndOfStream;
-            },
-        };
-    }
-    getAvailableMessages() {
-        const messages = this.messageBuffer;
-        this.messageBuffer = [];
-        const isEndOfStream = this.isEndOfStream;
-        return {
-            getMessages() {
-                return messages;
-            },
-            isEndOfStream() {
-                return isEndOfStream;
-            },
-        };
-    }
-    encode({ headers: rawHeaders, body }) {
-        const headers = this.headerMarshaller.format(rawHeaders);
-        const length = headers.byteLength + body.byteLength + 16;
-        const out = new Uint8Array(length);
-        const view = new DataView(out.buffer, out.byteOffset, out.byteLength);
-        const checksum = new Crc32();
-        view.setUint32(0, length, false);
-        view.setUint32(4, headers.byteLength, false);
-        checksum.update(out.subarray(0, 8));
-        view.setUint32(8, checksum.digestSync(), false);
-        out.set(headers, 12);
-        out.set(body, headers.byteLength + 12);
-        checksum.update(out.subarray(8, length - 4));
-        view.setUint32(length - 4, checksum.digestSync(), false);
-        return out;
-    }
-    decode(message) {
-        const { headers, body } = splitMessage(message);
-        return { headers: this.headerMarshaller.parse(headers), body };
-    }
-    formatHeaders(rawHeaders) {
-        return this.headerMarshaller.format(rawHeaders);
-    }
-}

package/node_modules/@smithy/shared-ini-file-loader/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-codec/HeaderMarshaller.js

@@ -1,187 +0,0 @@
-import { hasOwn } from "@smithy/core/transport";
-import { fromHex, toHex } from "@smithy/core/serde";
-import { Int64 } from "./Int64";
-export class HeaderMarshaller {
-    toUtf8;
-    fromUtf8;
-    constructor(toUtf8, fromUtf8) {
-        this.toUtf8 = toUtf8;
-        this.fromUtf8 = fromUtf8;
-    }
-    format(headers) {
-        const chunks = [];
-        for (const headerName in headers) {
-            if (!hasOwn(headers, headerName))
-                continue;
-            const bytes = this.fromUtf8(headerName);
-            chunks.push(Uint8Array.from([bytes.byteLength]), bytes, this.formatHeaderValue(headers[headerName]));
-        }
-        const out = new Uint8Array(chunks.reduce((carry, bytes) => carry + bytes.byteLength, 0));
-        let position = 0;
-        for (const chunk of chunks) {
-            out.set(chunk, position);
-            position += chunk.byteLength;
-        }
-        return out;
-    }
-    formatHeaderValue(header) {
-        switch (header.type) {
-            case "boolean":
-                return Uint8Array.from([header.value ? 0 : 1]);
-            case "byte":
-                return Uint8Array.from([2, header.value]);
-            case "short":
-                const shortView = new DataView(new ArrayBuffer(3));
-                shortView.setUint8(0, 3);
-                shortView.setInt16(1, header.value, false);
-                return new Uint8Array(shortView.buffer);
-            case "integer":
-                const intView = new DataView(new ArrayBuffer(5));
-                intView.setUint8(0, 4);
-                intView.setInt32(1, header.value, false);
-                return new Uint8Array(intView.buffer);
-            case "long":
-                const longBytes = new Uint8Array(9);
-                longBytes[0] = 5;
-                longBytes.set(header.value.bytes, 1);
-                return longBytes;
-            case "binary":
-                const binView = new DataView(new ArrayBuffer(3 + header.value.byteLength));
-                binView.setUint8(0, 6);
-                binView.setUint16(1, header.value.byteLength, false);
-                const binBytes = new Uint8Array(binView.buffer);
-                binBytes.set(header.value, 3);
-                return binBytes;
-            case "string":
-                const utf8Bytes = this.fromUtf8(header.value);
-                const strView = new DataView(new ArrayBuffer(3 + utf8Bytes.byteLength));
-                strView.setUint8(0, 7);
-                strView.setUint16(1, utf8Bytes.byteLength, false);
-                const strBytes = new Uint8Array(strView.buffer);
-                strBytes.set(utf8Bytes, 3);
-                return strBytes;
-            case "timestamp":
-                const tsBytes = new Uint8Array(9);
-                tsBytes[0] = 8;
-                tsBytes.set(Int64.fromNumber(header.value.valueOf()).bytes, 1);
-                return tsBytes;
-            case "uuid":
-                if (!UUID_PATTERN.test(header.value)) {
-                    throw new Error(`Invalid UUID received: ${header.value}`);
-                }
-                const uuidBytes = new Uint8Array(17);
-                uuidBytes[0] = 9;
-                uuidBytes.set(fromHex(header.value.replace(/-/g, "")), 1);
-                return uuidBytes;
-        }
-    }
-    parse(headers) {
-        const out = {};
-        let position = 0;
-        while (position < headers.byteLength) {
-            const nameLength = headers.getUint8(position++);
-            const name = this.toUtf8(new Uint8Array(headers.buffer, headers.byteOffset + position, nameLength));
-            position += nameLength;
-            switch (headers.getUint8(position++)) {
-                case 0:
-                    out[name] = {
-                        type: BOOLEAN_TAG,
-                        value: true,
-                    };
-                    break;
-                case 1:
-                    out[name] = {
-                        type: BOOLEAN_TAG,
-                        value: false,
-                    };
-                    break;
-                case 2:
-                    out[name] = {
-                        type: BYTE_TAG,
-                        value: headers.getInt8(position++),
-                    };
-                    break;
-                case 3:
-                    out[name] = {
-                        type: SHORT_TAG,
-                        value: headers.getInt16(position, false),
-                    };
-                    position += 2;
-                    break;
-                case 4:
-                    out[name] = {
-                        type: INT_TAG,
-                        value: headers.getInt32(position, false),
-                    };
-                    position += 4;
-                    break;
-                case 5:
-                    out[name] = {
-                        type: LONG_TAG,
-                        value: new Int64(new Uint8Array(headers.buffer, headers.byteOffset + position, 8)),
-                    };
-                    position += 8;
-                    break;
-                case 6:
-                    const binaryLength = headers.getUint16(position, false);
-                    position += 2;
-                    out[name] = {
-                        type: BINARY_TAG,
-                        value: new Uint8Array(headers.buffer, headers.byteOffset + position, binaryLength),
-                    };
-                    position += binaryLength;
-                    break;
-                case 7:
-                    const stringLength = headers.getUint16(position, false);
-                    position += 2;
-                    out[name] = {
-                        type: STRING_TAG,
-                        value: this.toUtf8(new Uint8Array(headers.buffer, headers.byteOffset + position, stringLength)),
-                    };
-                    position += stringLength;
-                    break;
-                case 8:
-                    out[name] = {
-                        type: TIMESTAMP_TAG,
-                        value: new Date(new Int64(new Uint8Array(headers.buffer, headers.byteOffset + position, 8)).valueOf()),
-                    };
-                    position += 8;
-                    break;
-                case 9:
-                    const uuidBytes = new Uint8Array(headers.buffer, headers.byteOffset + position, 16);
-                    position += 16;
-                    out[name] = {
-                        type: UUID_TAG,
-                        value: `${toHex(uuidBytes.subarray(0, 4))}-${toHex(uuidBytes.subarray(4, 6))}-${toHex(uuidBytes.subarray(6, 8))}-${toHex(uuidBytes.subarray(8, 10))}-${toHex(uuidBytes.subarray(10))}`,
-                    };
-                    break;
-                default:
-                    throw new Error(`Unrecognized header type tag`);
-            }
-        }
-        return out;
-    }
-}
-var HEADER_VALUE_TYPE;
-(function (HEADER_VALUE_TYPE) {
-    HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["boolTrue"] = 0] = "boolTrue";
-    HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["boolFalse"] = 1] = "boolFalse";
-    HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["byte"] = 2] = "byte";
-    HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["short"] = 3] = "short";
-    HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["integer"] = 4] = "integer";
-    HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["long"] = 5] = "long";
-    HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["byteArray"] = 6] = "byteArray";
-    HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["string"] = 7] = "string";
-    HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["timestamp"] = 8] = "timestamp";
-    HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["uuid"] = 9] = "uuid";
-})(HEADER_VALUE_TYPE || (HEADER_VALUE_TYPE = {}));
-const BOOLEAN_TAG = "boolean";
-const BYTE_TAG = "byte";
-const SHORT_TAG = "short";
-const INT_TAG = "integer";
-const LONG_TAG = "long";
-const BINARY_TAG = "binary";
-const STRING_TAG = "string";
-const TIMESTAMP_TAG = "timestamp";
-const UUID_TAG = "uuid";
-const UUID_PATTERN = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;