gremlin 3.8.1 → 4.0.0-beta.3

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

@@ -0,0 +1,79 @@
+/*
+ *  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 LongSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.LONG] = this;
+    }
+    canBeUsedFor() {
+        // it's not expected to be used, see NumberSerializationStrategy
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return Buffer.from([this.ioc.DataType.LONG, 0x01]);
+            }
+            return Buffer.from([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(Buffer.from([this.ioc.DataType.LONG, 0x00]));
+        }
+        const v = Buffer.alloc(8);
+        v.writeBigInt64BE(BigInt(item));
+        bufs.push(v);
+        return Buffer.concat(bufs);
+    }
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - already consumed by AnySerializer
+     * @param {number} typeCode
+     * @returns {Promise<number|bigint>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        let v = await reader.readBigInt64BE();
+        if (v >= Number.MIN_SAFE_INTEGER && v <= Number.MAX_SAFE_INTEGER) {
+            v = Number(v);
+        }
+        return v;
+    }
+    /**
+     * Read a fully-qualified long from the StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<number|bigint|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.LONG) {
+            throw new Error(`LongSerializer: 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(`LongSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
+        }
+        return this.deserializeValue(reader, value_flag, type_code);
+    }
+}

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

@@ -0,0 +1,20 @@
+export default class MapSerializer {
+    constructor(ioc: any);
+    ioc: any;
+    canBeUsedFor(value: any): boolean;
+    serialize(item: any, fullyQualifiedFormat?: boolean): any;
+    /**
+     * Async deserialization of map value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<Map>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<Map<any, any>>;
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Map|null>}
+     */
+    deserialize(reader: StreamReader): Promise<Map<any, any> | null>;
+}

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

@@ -0,0 +1,107 @@
+/*
+ *  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 MapSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.MAP] = this;
+    }
+    canBeUsedFor(value) {
+        if (value === null || value === undefined) {
+            return false;
+        }
+        if (value instanceof Map) {
+            return true;
+        }
+        if (Array.isArray(value)) {
+            return false;
+        }
+        return typeof value === 'object';
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return Buffer.from([this.ioc.DataType.MAP, 0x01]);
+            }
+            return this.ioc.intSerializer.serialize(0, false);
+        }
+        const isMap = item instanceof Map;
+        const keys = isMap ? Array.from(item.keys()) : Object.keys(item);
+        let map_length = keys.length;
+        if (map_length < 0) {
+            map_length = 0;
+        }
+        else if (map_length > this.ioc.intSerializer.INT32_MAX) {
+            map_length = this.ioc.intSerializer.INT32_MAX; // TODO: is it expected to be silenced? or it's better to error instead?
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(Buffer.from([this.ioc.DataType.MAP, 0x00]));
+        }
+        bufs.push(this.ioc.intSerializer.serialize(map_length, false));
+        for (let i = 0; i < map_length; i++) {
+            const key = keys[i];
+            const value = isMap ? item.get(key) : item[key];
+            bufs.push(this.ioc.anySerializer.serialize(key), this.ioc.anySerializer.serialize(value));
+        }
+        return Buffer.concat(bufs);
+    }
+    /**
+     * Async deserialization of map value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<Map>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        const length = await this.ioc.intSerializer.deserializeBare(reader);
+        if (length < 0) {
+            throw new Error(`MapSerializer: {length}=${length} is less than zero`);
+        }
+        const v = new Map();
+        for (let i = 0; i < length; i++) {
+            const key = await this.ioc.anySerializer.deserialize(reader);
+            const value = await this.ioc.anySerializer.deserialize(reader);
+            v.set(key, value);
+        }
+        return v;
+    }
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Map|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.MAP) {
+            throw new Error(`MapSerializer: unexpected {type_code}=0x${type_code.toString(16)}`);
+        }
+        const value_flag = await reader.readUInt8();
+        if (value_flag === 0x01) {
+            return null;
+        }
+        if (value_flag !== 0x00 && value_flag !== 0x02) {
+            throw new Error(`MapSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
+        }
+        return this.deserializeValue(reader, value_flag, type_code);
+    }
+}

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

@@ -0,0 +1,17 @@
+export const END_OF_STREAM: unique symbol;
+export default class MarkerSerializer {
+    constructor(ioc: any);
+    ioc: any;
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - already consumed by AnySerializer
+     * @returns {Promise<symbol>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number): Promise<symbol>;
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<symbol|null>}
+     */
+    deserialize(reader: StreamReader): Promise<symbol | null>;
+}

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

@@ -0,0 +1,56 @@
+/*
+ *  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.
+ */
+export const END_OF_STREAM = Symbol('EndOfStream');
+export default class MarkerSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.MARKER] = this;
+    }
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - already consumed by AnySerializer
+     * @returns {Promise<symbol>}
+     */
+    async deserializeValue(reader, valueFlag) {
+        const value = await reader.readUInt8();
+        if (value !== 0) {
+            throw new Error(`unexpected marker value: ${value}`);
+        }
+        return END_OF_STREAM;
+    }
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<symbol|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.MARKER) {
+            throw new Error(`MarkerSerializer: 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(`MarkerSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
+        }
+        return this.deserializeValue(reader, value_flag);
+    }
+}

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

@@ -0,0 +1,6 @@
+export default class NumberSerializationStrategy {
+    constructor(ioc: any);
+    ioc: any;
+    canBeUsedFor(value: any): boolean;
+    serialize(item: any, fullyQualifiedFormat?: boolean): any;
+}

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

@@ -0,0 +1,89 @@
+/*
+ *  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 { Long, Int, Float, Double, Short, Byte, INT32_MIN, INT32_MAX } from '../../../../utils.js';
+// Based on GraphSON NumberSerializer.serialize().
+// It's tested by AnySerializer.serialize() tests.
+export default class NumberSerializationStrategy {
+    constructor(ioc) {
+        this.ioc = ioc;
+    }
+    canBeUsedFor(value) {
+        if (value instanceof Long ||
+            value instanceof Int ||
+            value instanceof Float ||
+            value instanceof Double ||
+            value instanceof Short ||
+            value instanceof Byte) {
+            return true;
+        }
+        if (Number.isNaN(value) || value === Number.POSITIVE_INFINITY || value === Number.NEGATIVE_INFINITY) {
+            return true;
+        }
+        if (typeof value === 'number') {
+            return true;
+        }
+        if (typeof value === 'bigint') {
+            return true;
+        }
+        return false;
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item instanceof Float) {
+            return this.ioc.floatSerializer.serialize(item.value, fullyQualifiedFormat);
+        }
+        if (item instanceof Double) {
+            return this.ioc.doubleSerializer.serialize(item.value, fullyQualifiedFormat);
+        }
+        if (item instanceof Int) {
+            return this.ioc.intSerializer.serialize(item.value, fullyQualifiedFormat);
+        }
+        if (item instanceof Long) {
+            return this.ioc.longSerializer.serialize(item.value, fullyQualifiedFormat);
+        }
+        if (item instanceof Short) {
+            return this.ioc.shortSerializer.serialize(item.value, fullyQualifiedFormat);
+        }
+        if (item instanceof Byte) {
+            return this.ioc.byteSerializer.serialize(item.value, fullyQualifiedFormat);
+        }
+        if (typeof item === 'number') {
+            if (Number.isNaN(item) ||
+                item === Number.POSITIVE_INFINITY ||
+                item === Number.NEGATIVE_INFINITY ||
+                !Number.isInteger(item) ||
+                Object.is(item, -0)) {
+                return this.ioc.doubleSerializer.serialize(item, fullyQualifiedFormat);
+            }
+            if (item >= INT32_MIN && item <= INT32_MAX) {
+                return this.ioc.intSerializer.serialize(item, fullyQualifiedFormat);
+            }
+            if (item >= Number.MIN_SAFE_INTEGER && item <= Number.MAX_SAFE_INTEGER) {
+                return this.ioc.longSerializer.serialize(item, fullyQualifiedFormat);
+            }
+            // Integers outside safe range are huge doubles that only appear integral due to IEEE 754 precision loss
+            return this.ioc.doubleSerializer.serialize(item, fullyQualifiedFormat);
+        }
+        if (typeof item === 'bigint') {
+            return this.ioc.bigIntegerSerializer.serialize(item, fullyQualifiedFormat);
+        }
+    }
+}

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

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

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

@@ -0,0 +1,85 @@
+/*
+ *  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 { Path } from '../../../graph.js';
+export default class PathSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.PATH] = this;
+    }
+    canBeUsedFor(value) {
+        return value instanceof Path;
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return Buffer.from([this.ioc.DataType.PATH, 0x01]);
+            }
+            return Buffer.concat([
+                this.ioc.listSerializer.serialize([]), // {labels}=[]
+                this.ioc.listSerializer.serialize([]), // {objects}=[]
+            ]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(Buffer.from([this.ioc.DataType.PATH, 0x00]));
+        }
+        // {labels} is a List in which each item is a Set of String
+        bufs.push(this.ioc.listSerializer.serialize(item.labels));
+        // {objects} is a List of fully qualified typed values
+        bufs.push(this.ioc.listSerializer.serialize(item.objects));
+        return Buffer.concat(bufs);
+    }
+    /**
+     * Async deserialization of path value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<Path>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        // {labels} fully qualified list
+        const labels = await this.ioc.anySerializer.deserialize(reader);
+        // {objects} fully qualified list
+        const objects = await this.ioc.anySerializer.deserialize(reader);
+        return new Path(labels, objects);
+    }
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Path|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.PATH) {
+            throw new Error(`PathSerializer: 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(`PathSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
+        }
+        return this.deserializeValue(reader, value_flag, type_code);
+    }
+}

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

@@ -0,0 +1,10 @@
+export default class PrimitivePDTSerializer {
+    constructor(ioc: any);
+    ioc: any;
+    canBeUsedFor(value: any): value is PrimitivePDT;
+    serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
+    deserializeValue(reader: any, valueFlag: any, typeCode: any): Promise<any>;
+    deserialize(reader: any): Promise<any>;
+}
+import { PrimitivePDT } from '../../../graph.js';
+import { Buffer } from 'buffer';

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

@@ -0,0 +1,77 @@
+/*
+ *  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 { PrimitivePDT } from '../../../graph.js';
+export default class PrimitivePDTSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.PRIMITIVEPDT] = this;
+    }
+    canBeUsedFor(value) {
+        return value instanceof PrimitivePDT;
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return Buffer.from([this.ioc.DataType.PRIMITIVEPDT, 0x01]);
+            }
+            const bufs = [];
+            bufs.push(this.ioc.stringSerializer.serialize('', false));
+            bufs.push(this.ioc.stringSerializer.serialize('', false));
+            return Buffer.concat(bufs);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(Buffer.from([this.ioc.DataType.PRIMITIVEPDT, 0x00]));
+        }
+        bufs.push(this.ioc.stringSerializer.serialize(item.name, true));
+        bufs.push(this.ioc.stringSerializer.serialize(item.value, true));
+        return Buffer.concat(bufs);
+    }
+    async deserializeValue(reader, valueFlag, typeCode) {
+        const name = await this.ioc.anySerializer.deserialize(reader);
+        if (!name) {
+            throw new Error('PrimitivePDTSerializer: name cannot be null or empty');
+        }
+        const value = await this.ioc.anySerializer.deserialize(reader);
+        const pdt = new PrimitivePDT(name, value != null ? String(value) : '');
+        const pdtRegistry = reader.pdtRegistry;
+        if (pdtRegistry) {
+            const hydrated = pdtRegistry.hydratePrimitive(pdt);
+            if (!(hydrated instanceof PrimitivePDT)) {
+                return hydrated;
+            }
+        }
+        return pdt;
+    }
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.PRIMITIVEPDT) {
+            throw new Error(`PrimitivePDTSerializer: 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(`PrimitivePDTSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
+        }
+        return this.deserializeValue(reader, value_flag, type_code);
+    }
+}

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

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