gremlin 4.0.0-beta.2 → 4.0.0-beta.3

package/build/cjs/structure/io/binary/internals/EnumSerializer.d.cts

@@ -17,8 +17,23 @@ export default class EnumSerializer {
     };
     canBeUsedFor(value: any): boolean;
     serialize(item: any, fullyQualifiedFormat?: boolean): any;
-    deserialize(buffer: any, fullyQualifiedFormat?: boolean, ...args: any[]): {
-        v: any;
-        len: number;
-    };
+    /**
+     * Resolve the type_code (already read by AnySerializer) to a typeName.
+     * Called by AnySerializer before dispatching.
+     */
+    _typeNameForCode(type_code: any): "Direction" | "Merge" | "T" | undefined;
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - already consumed by AnySerializer
+     * @param {number} typeCode - the type_code byte already read by AnySerializer
+     * @returns {Promise<EnumValue>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<EnumValue>;
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<EnumValue|null>}
+     */
+    deserialize(reader: StreamReader): Promise<EnumValue | null>;
 }
+import { EnumValue } from '../../../../process/traversal.cjs';

package/build/cjs/structure/io/binary/internals/FloatSerializer.cjs

@@ -46,46 +46,32 @@ class FloatSerializer {
         bufs.push(v);
         return buffer_1.Buffer.concat(bufs);
     }
-    deserialize(buffer, fullyQualifiedFormat = true) {
-        let len = 0;
-        let cursor = buffer;
-        try {
-            if (buffer === undefined || buffer === null || !(buffer instanceof buffer_1.Buffer)) {
-                throw new Error('buffer is missing');
-            }
-            if (buffer.length < 1) {
-                throw new Error('buffer is empty');
-            }
-            if (fullyQualifiedFormat) {
-                const type_code = cursor.readUInt8();
-                len++;
-                if (type_code !== this.ioc.DataType.FLOAT) {
-                    throw new Error('unexpected {type_code}');
-                }
-                cursor = cursor.slice(1);
-                if (cursor.length < 1) {
-                    throw new Error('{value_flag} is missing');
-                }
-                const value_flag = cursor.readUInt8();
-                len++;
-                if (value_flag === 1) {
-                    return { v: null, len };
-                }
-                if (value_flag !== 0) {
-                    throw new Error('unexpected {value_flag}');
-                }
-                cursor = cursor.slice(1);
-            }
-            if (cursor.length < 4) {
-                throw new Error('unexpected {value} length');
-            }
-            len += 4;
-            const v = cursor.readFloatBE();
-            return { v, len };
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<number>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        return await reader.readFloatBE();
+    }
+    /**
+     * @param {StreamReader} reader
+     * @returns {Promise<number|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.FLOAT) {
+            throw new Error(`FloatSerializer: unexpected {type_code}=0x${type_code.toString(16)}`);
+        }
+        const value_flag = await reader.readUInt8();
+        if (value_flag === 0x01) {
+            return null;
         }
-        catch (err) {
-            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        if (value_flag !== 0x00) {
+            throw new Error(`FloatSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
         }
+        return this.deserializeValue(reader, value_flag, type_code);
     }
 }
 exports.default = FloatSerializer;

package/build/cjs/structure/io/binary/internals/FloatSerializer.d.cts

@@ -3,9 +3,17 @@ export default class FloatSerializer {
     ioc: any;
     canBeUsedFor(value: any): void;
     serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
-    deserialize(buffer: any, fullyQualifiedFormat?: boolean, ...args: any[]): {
-        v: any;
-        len: number;
-    };
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<number>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<number>;
+    /**
+     * @param {StreamReader} reader
+     * @returns {Promise<number|null>}
+     */
+    deserialize(reader: StreamReader): Promise<number | null>;
 }
 import { Buffer } from 'buffer';

package/build/cjs/structure/io/binary/internals/GraphBinaryReader.cjs

@@ -17,22 +17,42 @@
  *  specific language governing permissions and limitations
  *  under the License.
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * @author Igor Ostapenko
  */
 const buffer_1 = require("node:buffer");
+const StreamReader_js_1 = __importDefault(require("./StreamReader.cjs"));
+const MarkerSerializer_js_1 = require("./MarkerSerializer.cjs");
+const traversal_js_1 = require("../../../../process/traversal.cjs");
+const response_error_js_1 = __importDefault(require("../../../../driver/response-error.cjs"));
+/** GraphBinary response status codes. */
+const StatusCode = {
+    SUCCESS: 200,
+    NO_CONTENT: 204,
+    PARTIAL_CONTENT: 206,
+};
 /**
  * GraphBinary reader.
  */
 class GraphBinaryReader {
     constructor(ioc) {
         this.ioc = ioc;
+        this.pdtRegistry = null;
     }
     get mimeType() {
         return 'application/vnd.graphbinary-v4.0';
     }
-    readResponse(buffer) {
+    /**
+     * 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.');
         }
@@ -42,56 +62,110 @@ class GraphBinaryReader {
         if (buffer.length < 1) {
             throw new Error('Buffer is empty.');
         }
-        let cursor = buffer;
-        let len;
-        // {version} is a Byte representing the protocol version
-        const version = cursor[0];
+        const reader = StreamReader_js_1.default.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}'.`);
         }
-        cursor = cursor.slice(1); // skip version
-        // {bulked} is a Byte: 0x00 = not bulked, 0x01 = bulked
-        const bulked = cursor[0] === 0x01;
-        cursor = cursor.slice(1);
-        // {result_data} stream - read values until marker
-        const data = [];
-        while (cursor[0] !== 0xfd) {
-            const { v, len: valueLen } = this.ioc.anySerializer.deserialize(cursor);
-            cursor = cursor.slice(valueLen);
+        // {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 === MarkerSerializer_js_1.END_OF_STREAM) {
+                break;
+            }
             if (bulked) {
-                const { v: bulk, len: bulkLen } = this.ioc.longSerializer.deserialize(cursor, true);
-                cursor = cursor.slice(bulkLen);
-                data.push({ v, bulk: Number(bulk) });
+                const bulk = await this.ioc.longSerializer.deserialize(reader);
+                yield new traversal_js_1.Traverser(value, Number(bulk));
             }
             else {
-                data.push(v);
+                yield value;
             }
         }
-        // Skip marker [0xFD, 0x00, 0x00]
-        cursor = cursor.slice(3);
-        // {status_code} is an Int bare
-        const { v: code, len: codeLen } = this.ioc.intSerializer.deserialize(cursor, false);
-        cursor = cursor.slice(codeLen);
-        // {status_message} is nullable
-        let message = null;
-        if (cursor[0] === 0x00) {
-            cursor = cursor.slice(1);
-            ({ v: message, len } = this.ioc.stringSerializer.deserialize(cursor, false));
-            cursor = cursor.slice(len);
+        // {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 response_error_js_1.default(`Server error: ${status.message || 'Unknown error'} (${status.code})`, {
+                code: status.code,
+                message: status.message || '',
+                exception: status.exception,
+            });
         }
-        else {
-            cursor = cursor.slice(1); // skip 0x01 null flag
+        // 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}'.`);
         }
-        // {exception} is nullable
-        let exception = null;
-        if (cursor[0] === 0x00) {
-            cursor = cursor.slice(1);
-            ({ v: exception } = this.ioc.stringSerializer.deserialize(cursor, false));
+        // {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 === MarkerSerializer_js_1.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: { code, message, exception },
+            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 };
+    }
 }
 exports.default = GraphBinaryReader;

package/build/cjs/structure/io/binary/internals/GraphBinaryReader.d.cts

@@ -4,8 +4,15 @@
 export default class GraphBinaryReader {
     constructor(ioc: any);
     ioc: any;
+    pdtRegistry: any;
     get mimeType(): string;
-    readResponse(buffer: any): {
+    /**
+     * 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}}>}
+     */
+    readResponse(buffer: Buffer): Promise<{
         status: {
             code: any;
             message: any;
@@ -15,5 +22,22 @@ export default class GraphBinaryReader {
             data: any[];
             bulked: boolean;
         };
-    };
+    }>;
+    /**
+     * 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>}
+     */
+    readResponseStream(reader: StreamReader): AsyncGenerator<any>;
+    #private;
 }
+import { Buffer } from 'buffer';
+import StreamReader from './StreamReader.cjs';

package/build/cjs/structure/io/binary/internals/GraphBinaryWriter.cjs

@@ -44,13 +44,13 @@ class GraphBinaryWriter {
             if (g) {
                 fields.set('g', g);
             }
-            const bindings = requestMessage.getBindings();
-            if (bindings && Object.keys(bindings).length > 0) {
-                fields.set('bindings', bindings);
+            const parameters = requestMessage.getParameters();
+            if (parameters && Object.keys(parameters).length > 0) {
+                fields.set('parameters', parameters);
             }
-            const timeoutMs = requestMessage.getTimeoutMs();
-            if (timeoutMs !== undefined) {
-                fields.set('timeoutMs', timeoutMs);
+            const timeoutMillis = requestMessage.getTimeoutMillis();
+            if (timeoutMillis !== undefined) {
+                fields.set('timeoutMillis', timeoutMillis);
             }
             const materializeProperties = requestMessage.getMaterializeProperties();
             if (materializeProperties) {

package/build/cjs/structure/io/binary/internals/GraphSerializer.cjs

@@ -0,0 +1,184 @@
+"use strict";
+/*
+ *  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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const buffer_1 = require("node:buffer");
+const graph_js_1 = require("../../../graph.cjs");
+class GraphSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.GRAPH] = this;
+    }
+    canBeUsedFor(value) {
+        return value instanceof graph_js_1.Graph;
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return buffer_1.Buffer.from([this.ioc.DataType.GRAPH, 0x01]);
+            }
+            // value-only null fallback: zero vertices + zero edges
+            const zeroInt = [0x00, 0x00, 0x00, 0x00];
+            return buffer_1.Buffer.from([...zeroInt, ...zeroInt]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(buffer_1.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_1.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_js_1.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 graph_js_1.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 graph_js_1.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 graph_js_1.Vertex(inVId, '', []);
+            const outV = graph.vertices.get(outVId) || new graph_js_1.Vertex(outVId, '', []);
+            const edge = new graph_js_1.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);
+    }
+}
+exports.default = GraphSerializer;

package/build/cjs/structure/io/binary/internals/GraphSerializer.d.cts

@@ -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.cjs';
+import { Buffer } from 'buffer';