gremlin 3.8.1 → 4.0.0-beta.3

package/build/esm/structure/io/binary/internals/GraphBinaryReader.js

@@ -0,0 +1,165 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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.
+ */
+/**
+ * @author Igor Ostapenko
+ */
+import { Buffer } from 'buffer';
+import StreamReader from './StreamReader.js';
+import { END_OF_STREAM } from './MarkerSerializer.js';
+import { Traverser } from '../../../../process/traversal.js';
+import ResponseError from '../../../../driver/response-error.js';
+/** GraphBinary response status codes. */
+const StatusCode = {
+    SUCCESS: 200,
+    NO_CONTENT: 204,
+    PARTIAL_CONTENT: 206,
+};
+/**
+ * GraphBinary reader.
+ */
+export default class GraphBinaryReader {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.pdtRegistry = null;
+    }
+    get mimeType() {
+        return 'application/vnd.graphbinary-v4.0';
+    }
+    /**
+     * Read a complete response from a Buffer. Used by the non-streaming submit() path.
+     * Returns the full { status, result } object after reading all data.
+     * @param {Buffer} buffer
+     * @returns {Promise<{status: {code, message, exception}, result: {data: any[], bulked: boolean}}>}
+     */
+    async readResponse(buffer) {
+        if (buffer === undefined || buffer === null) {
+            throw new Error('Buffer is missing.');
+        }
+        if (!(buffer instanceof Buffer)) {
+            throw new Error('Not an instance of Buffer.');
+        }
+        if (buffer.length < 1) {
+            throw new Error('Buffer is empty.');
+        }
+        const reader = StreamReader.fromBuffer(buffer);
+        reader.pdtRegistry = this.pdtRegistry;
+        return await this.#readFromReader(reader);
+    }
+    /**
+     * Stream results from a StreamReader, yielding each value as it's deserialized.
+     * Used by the streaming Connection.stream() path.
+     *
+     * Note: In the GraphBinary v4 streaming protocol, the status (including error codes)
+     * is sent *after* all result data. This means values are yielded to the consumer as
+     * they arrive, and a server error is only thrown after all values have been yielded.
+     * Consumers should be aware that partial results may have been processed before a
+     * ResponseError is thrown.
+     *
+     * @param {StreamReader} reader
+     * @returns {AsyncGenerator<any>}
+     */
+    async *readResponseStream(reader) {
+        reader.pdtRegistry = this.pdtRegistry;
+        // {version}
+        const version = await reader.readUInt8();
+        if (version !== 0x84) {
+            throw new Error(`Unsupported version '${version}'.`);
+        }
+        // {bulked}
+        const bulked = (await reader.readUInt8()) === 0x01;
+        // {result_data} stream — yield values until EndOfStream marker
+        while (true) {
+            const value = await this.ioc.anySerializer.deserialize(reader);
+            if (value === END_OF_STREAM) {
+                break;
+            }
+            if (bulked) {
+                const bulk = await this.ioc.longSerializer.deserialize(reader);
+                yield new Traverser(value, Number(bulk));
+            }
+            else {
+                yield value;
+            }
+        }
+        // {status_code} {status_message} {exception}
+        const status = await this.#readStatus(reader);
+        if (status.code &&
+            status.code !== StatusCode.SUCCESS &&
+            status.code !== StatusCode.NO_CONTENT &&
+            status.code !== StatusCode.PARTIAL_CONTENT) {
+            throw new ResponseError(`Server error: ${status.message || 'Unknown error'} (${status.code})`, {
+                code: status.code,
+                message: status.message || '',
+                exception: status.exception,
+            });
+        }
+        // Attach status to the generator's return value
+        return status;
+    }
+    /**
+     * Internal: read the full response into a collected result (non-streaming).
+     */
+    async #readFromReader(reader) {
+        // {version}
+        const version = await reader.readUInt8();
+        if (version !== 0x84) {
+            throw new Error(`Unsupported version '${version}'.`);
+        }
+        // {bulked}
+        const bulked = (await reader.readUInt8()) === 0x01;
+        // {result_data} — collect all values
+        const data = [];
+        while (true) {
+            const value = await this.ioc.anySerializer.deserialize(reader);
+            if (value === END_OF_STREAM) {
+                break;
+            }
+            if (bulked) {
+                const bulk = await this.ioc.longSerializer.deserialize(reader);
+                data.push({ v: value, bulk: Number(bulk) });
+            }
+            else {
+                data.push(value);
+            }
+        }
+        // {status}
+        const status = await this.#readStatus(reader);
+        return {
+            status,
+            result: { data, bulked },
+        };
+    }
+    /**
+     * Read the status block: {code:Int bare}{message:nullable String}{exception:nullable String}
+     */
+    async #readStatus(reader) {
+        const code = await reader.readInt32BE();
+        let message = null;
+        const msgFlag = await reader.readUInt8();
+        if (msgFlag === 0x00) {
+            message = await this.ioc.stringSerializer.deserializeValue(reader, 0x00, this.ioc.DataType.STRING);
+        }
+        let exception = null;
+        const excFlag = await reader.readUInt8();
+        if (excFlag === 0x00) {
+            exception = await this.ioc.stringSerializer.deserializeValue(reader, 0x00, this.ioc.DataType.STRING);
+        }
+        return { code, message, exception };
+    }
+}

package/build/esm/structure/io/binary/internals/GraphBinaryWriter.d.ts

@@ -0,0 +1,9 @@
+/**
+ * GraphBinary writer.
+ */
+export default class GraphBinaryWriter {
+    constructor(ioc: any);
+    ioc: any;
+    get mimeType(): string;
+    writeRequest(requestMessage: any): Uint8Array<ArrayBuffer>;
+}

package/build/esm/structure/io/binary/internals/GraphBinaryWriter.js

@@ -0,0 +1,82 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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.
+ */
+/**
+ * @author Igor Ostapenko
+ */
+import { Buffer } from 'buffer';
+/**
+ * GraphBinary writer.
+ */
+export default class GraphBinaryWriter {
+    constructor(ioc) {
+        this.ioc = ioc;
+    }
+    get mimeType() {
+        return 'application/vnd.graphbinary-v4.0';
+    }
+    writeRequest(requestMessage) {
+        const fields = new Map();
+        // Extract fields from RequestMessage if it has getter methods
+        if (typeof requestMessage.getLanguage === 'function') {
+            const language = requestMessage.getLanguage();
+            if (language) {
+                fields.set('language', language);
+            }
+            const g = requestMessage.getG();
+            if (g) {
+                fields.set('g', g);
+            }
+            const parameters = requestMessage.getParameters();
+            if (parameters && Object.keys(parameters).length > 0) {
+                fields.set('parameters', parameters);
+            }
+            const timeoutMillis = requestMessage.getTimeoutMillis();
+            if (timeoutMillis !== undefined) {
+                fields.set('timeoutMillis', timeoutMillis);
+            }
+            const materializeProperties = requestMessage.getMaterializeProperties();
+            if (materializeProperties) {
+                fields.set('materializeProperties', materializeProperties);
+            }
+            const bulkResults = requestMessage.getBulkResults();
+            if (bulkResults !== undefined) {
+                fields.set('bulkResults', bulkResults);
+            }
+            // Add any custom fields
+            const customFields = requestMessage.getFields();
+            if (customFields) {
+                customFields.forEach((v, k) => fields.set(k, v));
+            }
+            const gremlin = requestMessage.getGremlin();
+            const bufs = [
+                Buffer.from([0x84]),
+                this.ioc.mapSerializer.serialize(fields, false),
+                this.ioc.stringSerializer.serialize(gremlin, false),
+            ];
+            return new Uint8Array(Buffer.concat(bufs));
+        }
+        // Legacy path: plain object with { gremlin, fields }
+        const bufs = [
+            Buffer.from([0x84]),
+            this.ioc.mapSerializer.serialize(requestMessage.fields || new Map(), false),
+            this.ioc.stringSerializer.serialize(requestMessage.gremlin, false),
+        ];
+        return new Uint8Array(Buffer.concat(bufs));
+    }
+}

package/build/esm/structure/io/binary/internals/GraphSerializer.d.ts

@@ -0,0 +1,22 @@
+export default class GraphSerializer {
+    constructor(ioc: any);
+    ioc: any;
+    canBeUsedFor(value: any): value is Graph;
+    serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
+    /**
+     * Async deserialization of graph value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<Graph>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<Graph>;
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Graph|null>}
+     */
+    deserialize(reader: StreamReader): Promise<Graph | null>;
+}
+import { Graph } from '../../../graph.js';
+import { Buffer } from 'buffer';

package/build/esm/structure/io/binary/internals/GraphSerializer.js

@@ -0,0 +1,181 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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.
+ */
+import { Buffer } from 'buffer';
+import { Graph, Vertex, Edge, VertexProperty } from '../../../graph.js';
+export default class GraphSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.GRAPH] = this;
+    }
+    canBeUsedFor(value) {
+        return value instanceof Graph;
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return Buffer.from([this.ioc.DataType.GRAPH, 0x01]);
+            }
+            // value-only null fallback: zero vertices + zero edges
+            const zeroInt = [0x00, 0x00, 0x00, 0x00];
+            return Buffer.from([...zeroInt, ...zeroInt]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(Buffer.from([this.ioc.DataType.GRAPH, 0x00]));
+        }
+        const vertices = item.vertices ? Array.from(item.vertices.values()) : [];
+        const edges = item.edges ? Array.from(item.edges.values()) : [];
+        // {vertex_count}
+        bufs.push(this.ioc.intSerializer.serialize(vertices.length, false));
+        // vertices
+        for (const v of vertices) {
+            // {id}
+            bufs.push(this.ioc.anySerializer.serialize(v.id));
+            // {label} as list (value-only)
+            const vLabels = v.labels instanceof Set ? Array.from(v.labels) : [v.label];
+            bufs.push(this.ioc.listSerializer.serialize(vLabels, false));
+            const vps = Array.isArray(v.properties) ? v.properties : [];
+            // {vp_count}
+            bufs.push(this.ioc.intSerializer.serialize(vps.length, false));
+            for (const vp of vps) {
+                // {vp_id}
+                bufs.push(this.ioc.anySerializer.serialize(vp.id));
+                // {vp_label} as 1-element list (value-only)
+                bufs.push(this.ioc.listSerializer.serialize([vp.label], false));
+                // {vp_value}
+                bufs.push(this.ioc.anySerializer.serialize(vp.value));
+                // {parent} (always null)
+                bufs.push(this.ioc.unspecifiedNullSerializer.serialize(null));
+                // {meta_props} as value-only List<Property>
+                const metaProps = Array.isArray(vp.properties) ? vp.properties : [];
+                bufs.push(this.ioc.listSerializer.serialize(metaProps, false));
+            }
+        }
+        // {edge_count}
+        bufs.push(this.ioc.intSerializer.serialize(edges.length, false));
+        // edges
+        for (const e of edges) {
+            // {id}
+            bufs.push(this.ioc.anySerializer.serialize(e.id));
+            // {label} as list (value-only)
+            const eLabels = e.labels instanceof Set ? Array.from(e.labels) : [e.label];
+            bufs.push(this.ioc.listSerializer.serialize(eLabels, false));
+            // {inV_id}
+            bufs.push(this.ioc.anySerializer.serialize(e.inV && e.inV.id));
+            // {inV_label} (always null placeholder, fully-qualified)
+            bufs.push(this.ioc.unspecifiedNullSerializer.serialize(null));
+            // {outV_id}
+            bufs.push(this.ioc.anySerializer.serialize(e.outV && e.outV.id));
+            // {outV_label} (always null placeholder, fully-qualified)
+            bufs.push(this.ioc.unspecifiedNullSerializer.serialize(null));
+            // {parent} (always null)
+            bufs.push(this.ioc.unspecifiedNullSerializer.serialize(null));
+            // {edge_props} as value-only List<Property>
+            const props = Array.isArray(e.properties) ? e.properties : [];
+            bufs.push(this.ioc.listSerializer.serialize(props, false));
+        }
+        return Buffer.concat(bufs);
+    }
+    /**
+     * Async deserialization of graph value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<Graph>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        const graph = new Graph();
+        // {vertex_count} bare int
+        const vertexCount = await this.ioc.intSerializer.deserializeBare(reader);
+        for (let i = 0; i < vertexCount; i++) {
+            // {id} fully qualified
+            const vId = await this.ioc.anySerializer.deserialize(reader);
+            // {label} value-only list - full multi-label list
+            const vLabelList = await this.ioc.listSerializer.deserializeValue(reader, 0x00, this.ioc.DataType.LIST);
+            const vLabels = Array.isArray(vLabelList) ? vLabelList : vLabelList ? [vLabelList] : [];
+            const vLabel = vLabels.length > 0 ? vLabels[0] : 'vertex';
+            const vertex = new Vertex(vId, vLabel, [], vLabels);
+            graph.vertices.set(vId, vertex);
+            // {vp_count} bare int
+            const vpCount = await this.ioc.intSerializer.deserializeBare(reader);
+            for (let j = 0; j < vpCount; j++) {
+                // {vp_id} fully qualified
+                const vpId = await this.ioc.anySerializer.deserialize(reader);
+                // {vp_label} value-only list, first element
+                const vpLabelList = await this.ioc.listSerializer.deserializeValue(reader, 0x00, this.ioc.DataType.LIST);
+                const vpLabel = Array.isArray(vpLabelList) && vpLabelList.length > 0 ? vpLabelList[0] : vpLabelList;
+                // {vp_value} fully qualified
+                const vpValue = await this.ioc.anySerializer.deserialize(reader);
+                // {parent} fully qualified (always null)
+                await this.ioc.anySerializer.deserialize(reader);
+                // {meta_props} value-only list
+                const metaProps = await this.ioc.listSerializer.deserializeValue(reader, 0x00, this.ioc.DataType.LIST);
+                const vp = new VertexProperty(vpId, vpLabel, vpValue, metaProps || []);
+                vertex.properties.push(vp);
+            }
+        }
+        // {edge_count} bare int
+        const edgeCount = await this.ioc.intSerializer.deserializeBare(reader);
+        for (let i = 0; i < edgeCount; i++) {
+            // {id} fully qualified
+            const eId = await this.ioc.anySerializer.deserialize(reader);
+            // {label} value-only list - full multi-label list
+            const eLabelList = await this.ioc.listSerializer.deserializeValue(reader, 0x00, this.ioc.DataType.LIST);
+            const eLabels = Array.isArray(eLabelList) ? eLabelList : eLabelList ? [eLabelList] : [];
+            const eLabel = eLabels.length > 0 ? eLabels[0] : 'edge';
+            // {inV_id} fully qualified
+            const inVId = await this.ioc.anySerializer.deserialize(reader);
+            // {inV_label} fully qualified (always null placeholder) — discard
+            await this.ioc.anySerializer.deserialize(reader);
+            // {outV_id} fully qualified
+            const outVId = await this.ioc.anySerializer.deserialize(reader);
+            // {outV_label} fully qualified (always null placeholder) — discard
+            await this.ioc.anySerializer.deserialize(reader);
+            // {parent} fully qualified (always null) — discard
+            await this.ioc.anySerializer.deserialize(reader);
+            // {edge_props} value-only list
+            const edgeProps = await this.ioc.listSerializer.deserializeValue(reader, 0x00, this.ioc.DataType.LIST);
+            // Reuse vertex instances already in graph.vertices, otherwise build stand-ins
+            const inV = graph.vertices.get(inVId) || new Vertex(inVId, '', []);
+            const outV = graph.vertices.get(outVId) || new Vertex(outVId, '', []);
+            const edge = new Edge(eId, outV, eLabel, inV, edgeProps || [], eLabels);
+            graph.edges.set(eId, edge);
+        }
+        return graph;
+    }
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Graph|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.GRAPH) {
+            throw new Error(`GraphSerializer: unexpected {type_code}=0x${type_code.toString(16)}`);
+        }
+        const value_flag = await reader.readUInt8();
+        if (value_flag === 0x01) {
+            return null;
+        }
+        if (value_flag !== 0x00) {
+            throw new Error(`GraphSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
+        }
+        return this.deserializeValue(reader, value_flag, type_code);
+    }
+}

package/build/esm/structure/io/binary/internals/IntSerializer.d.ts

@@ -0,0 +1,28 @@
+export default class IntSerializer {
+    constructor(ioc: any);
+    get INT32_MIN(): number;
+    get INT32_MAX(): number;
+    ioc: any;
+    canBeUsedFor(value: any): boolean;
+    serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
+    /**
+     * Read a bare int32 value from the StreamReader (no type_code or value_flag).
+     * @param {StreamReader} reader
+     * @returns {Promise<number>}
+     */
+    deserializeBare(reader: StreamReader): Promise<number>;
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - already consumed by AnySerializer
+     * @param {number} typeCode
+     * @returns {Promise<number>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<number>;
+    /**
+     * Read a fully-qualified int from the StreamReader (type_code + value_flag + value).
+     * @param {StreamReader} reader
+     * @returns {Promise<number|null>}
+     */
+    deserialize(reader: StreamReader): Promise<number | null>;
+}
+import { Buffer } from 'buffer';

package/build/esm/structure/io/binary/internals/IntSerializer.js

@@ -0,0 +1,95 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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.
+ */
+/**
+ * @author Igor Ostapenko
+ */
+import { Buffer } from 'buffer';
+export default class IntSerializer {
+    get INT32_MIN() {
+        return -2147483648;
+    }
+    get INT32_MAX() {
+        return 2147483647;
+    }
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.INT] = this;
+    }
+    canBeUsedFor(value) {
+        if (typeof value !== 'number') {
+            return false;
+        }
+        if (value < this.INT32_MIN || value > this.INT32_MAX) {
+            return false;
+        }
+        return true;
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return Buffer.from([this.ioc.DataType.INT, 0x01]);
+            }
+            return Buffer.from([0x00, 0x00, 0x00, 0x00]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(Buffer.from([this.ioc.DataType.INT, 0x00]));
+        }
+        const v = Buffer.alloc(4);
+        v.writeInt32BE(item); // if item is not within int32 limits writeInt32BE will error
+        bufs.push(v);
+        return Buffer.concat(bufs);
+    }
+    /**
+     * Read a bare int32 value from the StreamReader (no type_code or value_flag).
+     * @param {StreamReader} reader
+     * @returns {Promise<number>}
+     */
+    async deserializeBare(reader) {
+        return await reader.readInt32BE();
+    }
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - already consumed by AnySerializer
+     * @param {number} typeCode
+     * @returns {Promise<number>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        return await reader.readInt32BE();
+    }
+    /**
+     * Read a fully-qualified int from the StreamReader (type_code + value_flag + value).
+     * @param {StreamReader} reader
+     * @returns {Promise<number|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.INT) {
+            throw new Error(`IntSerializer: unexpected {type_code}=0x${type_code.toString(16)}`);
+        }
+        const value_flag = await reader.readUInt8();
+        if (value_flag === 0x01) {
+            return null;
+        }
+        if (value_flag !== 0x00) {
+            throw new Error(`IntSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
+        }
+        return this.deserializeValue(reader, value_flag, type_code);
+    }
+}

package/build/esm/structure/io/binary/internals/LongSerializer.d.ts

@@ -0,0 +1,20 @@
+export default class LongSerializer {
+    constructor(ioc: any);
+    ioc: any;
+    canBeUsedFor(): void;
+    serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - already consumed by AnySerializer
+     * @param {number} typeCode
+     * @returns {Promise<number|bigint>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<number | bigint>;
+    /**
+     * Read a fully-qualified long from the StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<number|bigint|null>}
+     */
+    deserialize(reader: StreamReader): Promise<number | bigint | null>;
+}
+import { Buffer } from 'buffer';