gremlin 3.8.0 → 4.0.0-beta.2

package/build/cjs/process/traversal.d.cts

@@ -0,0 +1,186 @@
+/**
+ * @author Jorge Bay Gondra
+ */
+import { Graph } from '../structure/graph.cjs';
+import { TraversalStrategies } from './traversal-strategy.cjs';
+import GremlinLang from './gremlin-lang.cjs';
+declare const asyncIteratorSymbol: symbol;
+export declare class Traversal {
+    /**
+     * Async iterable method implementation.
+     */
+    [asyncIteratorSymbol]: () => this;
+    graph: Graph | null;
+    traversalStrategies: TraversalStrategies | null;
+    gremlinLang: GremlinLang;
+    results: any[] | null;
+    sideEffects?: any;
+    private _traversalStrategiesPromise;
+    private _resultsIteratorIndex;
+    constructor(graph: Graph | null, traversalStrategies: TraversalStrategies | null, gremlinLang?: GremlinLang);
+    /** @returns {GremlinLang} */
+    getGremlinLang(): GremlinLang;
+    /**
+     * Returns an Array containing the traverser objects.
+     * @returns {Promise.<Array>}
+     */
+    toList<T>(): Promise<T[]>;
+    /**
+     * Determines if there are any more items to iterate from the traversal.
+     * @returns {Promise.<boolean>}
+     */
+    hasNext(): Promise<boolean>;
+    /**
+     * Iterates all Traverser instances in the traversal.
+     * @returns {Promise}
+     */
+    iterate(): Promise<void>;
+    /**
+     * Async iterator method implementation.
+     * Returns a promise containing an iterator item.
+     * @returns {Promise.<{value, done}>}
+     */
+    next<T>(): Promise<IteratorResult<T, null>>;
+    /**
+     * Synchronous iterator of traversers including
+     * @private
+     */
+    _getNext<T>(): IteratorResult<T, null>;
+    _applyStrategies(): Promise<void>;
+    /**
+     * Returns step instructions during JSON serialization
+     * @returns {Array}
+     */
+    toJSON(): string;
+    /**
+     * Returns the GremlinLang representation of the traversal
+     * @returns {String}
+     */
+    toString(): string;
+}
+export declare class IO {
+    static get graphml(): string;
+    static get graphson(): string;
+    static get gryo(): string;
+    static get reader(): string;
+    static get registry(): string;
+    static get writer(): string;
+}
+export declare class P<T1 = any, T2 = any> {
+    operator: string;
+    value: T1;
+    other: T2;
+    /**
+     * Represents an operation.
+     */
+    constructor(operator: string, value: T1, other: T2);
+    /**
+     * Returns the string representation of the instance.
+     * @returns {string}
+     */
+    toString(): string;
+    and(arg?: any): P<this, any>;
+    or(arg?: any): P<this, any>;
+    static within(...args: any[]): P<any[], null>;
+    static without(...args: any[]): P<any[], null>;
+    /** @param {...Object} args */
+    static between(...args: any[]): any;
+    /** @param {...Object} args */
+    static eq(...args: any[]): any;
+    /** @param {...Object} args */
+    static gt(...args: any[]): any;
+    /** @param {...Object} args */
+    static gte(...args: any[]): any;
+    /** @param {...Object} args */
+    static inside(...args: any[]): any;
+    /** @param {...Object} args */
+    static lt(...args: any[]): any;
+    /** @param {...Object} args */
+    static lte(...args: any[]): any;
+    /** @param {...Object} args */
+    static neq(...args: any[]): any;
+    /** @param {...Object} args */
+    static not(...args: any[]): any;
+    /** @param {...Object} args */
+    static outside(...args: any[]): any;
+    /** @param {...Object} args */
+    static typeOf(...args: any[]): any;
+    /** @param {...Object} args */
+    static test(...args: any[]): any;
+}
+export declare class TextP<T1 = any, T2 = any> {
+    operator: string;
+    value: T1;
+    other: T2;
+    /**
+     * Represents an operation.
+     */
+    constructor(operator: string, value: T1, other: T2);
+    /**
+     * Returns the string representation of the instance.
+     * @returns {string}
+     */
+    toString(): string;
+    and(arg: any): P<this, any>;
+    or(arg: any): P<this, any>;
+    /** @param {...Object} args */
+    static containing(...args: any[]): any;
+    /** @param {...Object} args */
+    static endingWith(...args: any[]): any;
+    /** @param {...Object} args */
+    static notContaining(...args: any[]): any;
+    /** @param {...Object} args */
+    static notEndingWith(...args: any[]): any;
+    /** @param {...Object} args */
+    static notStartingWith(...args: any[]): any;
+    /** @param {...Object} args */
+    static startingWith(...args: any[]): any;
+    /** @param {...Object} args */
+    static regex(...args: any[]): any;
+    /** @param {...Object} args */
+    static notRegex(...args: any[]): any;
+}
+export declare class Traverser<T = any> {
+    object: T;
+    bulk: number;
+    constructor(object: T, bulk: number);
+}
+export declare class TraversalSideEffects {
+}
+export declare const withOptions: {
+    tokens: string;
+    none: number;
+    ids: number;
+    labels: number;
+    keys: number;
+    values: number;
+    all: number;
+    indexer: string;
+    list: number;
+    map: number;
+};
+export declare class EnumValue {
+    typeName: string;
+    elementName: string;
+    constructor(typeName: string, elementName: string);
+    toString(): string;
+}
+export declare const barrier: Record<string, EnumValue>;
+export declare const cardinality: Record<string, EnumValue>;
+export declare const column: Record<string, EnumValue>;
+export declare const direction: Record<string, EnumValue>;
+export declare const dt: Record<string, EnumValue>;
+export declare const gType: {
+    [key: string]: any;
+};
+export declare const graphSONVersion: Record<string, EnumValue>;
+export declare const gryoVersion: Record<string, EnumValue>;
+export declare const merge: Record<string, EnumValue>;
+export declare const operator: Record<string, EnumValue>;
+export declare const order: Record<string, EnumValue>;
+export declare const pick: Record<string, EnumValue>;
+export declare const pop: Record<string, EnumValue>;
+export declare const scope: Record<string, EnumValue>;
+export declare const t: Record<string, EnumValue>;
+export declare const n: Record<string, EnumValue>;
+export {};

package/build/cjs/structure/graph.cjs

@@ -0,0 +1,157 @@
+"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 });
+exports.Path = exports.Property = exports.VertexProperty = exports.Edge = exports.Vertex = exports.Graph = void 0;
+/**
+ * @author Jorge Bay Gondra
+ */
+/**
+ * An "empty" graph object to server only as a reference.
+ */
+class Graph {
+    toString() {
+        return 'graph[]';
+    }
+}
+exports.Graph = Graph;
+class Element {
+    id;
+    label;
+    properties;
+    // properties are stored as list of property objects
+    constructor(id, label, properties = []) {
+        this.id = id;
+        this.label = label;
+        this.properties = properties;
+        this.properties = properties ?? [];
+    }
+    /**
+     * Compares this instance to another and determines if they can be considered as equal.
+     */
+    equals(other) {
+        return other instanceof Element && this.id === other.id;
+    }
+}
+class Vertex extends Element {
+    constructor(id, label, properties = []) {
+        super(id, label, properties ?? []);
+    }
+    toString() {
+        return `v[${this.id}]`;
+    }
+}
+exports.Vertex = Vertex;
+class Edge extends Element {
+    outV;
+    label;
+    inV;
+    constructor(id, outV, label, inV, properties = []) {
+        super(id, label, properties ?? []);
+        this.outV = outV;
+        this.label = label;
+        this.inV = inV;
+    }
+    toString() {
+        const outVId = this.outV ? this.outV.id : '?';
+        const inVId = this.inV ? this.inV.id : '?';
+        return `e[${this.id}][${outVId}-${this.label}->${inVId}]`;
+    }
+}
+exports.Edge = Edge;
+class VertexProperty extends Element {
+    value;
+    key;
+    constructor(id, label, value, properties = []) {
+        super(id, label, properties ?? []);
+        this.value = value;
+        this.value = value;
+        this.key = this.label;
+    }
+    toString() {
+        return `vp[${this.label}->${summarize(this.value)}]`;
+    }
+}
+exports.VertexProperty = VertexProperty;
+class Property {
+    key;
+    value;
+    constructor(key, value) {
+        this.key = key;
+        this.value = value;
+    }
+    toString() {
+        return `p[${this.key}->${summarize(this.value)}]`;
+    }
+    equals(other) {
+        return other instanceof Property && this.key === other.key && this.value === other.value;
+    }
+}
+exports.Property = Property;
+/**
+ * Represents a walk through a graph as defined by a traversal.
+ */
+class Path {
+    labels;
+    objects;
+    constructor(labels, objects) {
+        this.labels = labels;
+        this.objects = objects;
+    }
+    toString() {
+        return `path[${(this.objects || []).join(', ')}]`;
+    }
+    equals(other) {
+        if (!(other instanceof Path)) {
+            return false;
+        }
+        if (other === this) {
+            return true;
+        }
+        return areEqual(this.objects, other.objects) && areEqual(this.labels, other.labels);
+    }
+}
+exports.Path = Path;
+function areEqual(obj1, obj2) {
+    if (obj1 === obj2) {
+        return true;
+    }
+    if (typeof obj1.equals === 'function') {
+        return obj1.equals(obj2);
+    }
+    if (Array.isArray(obj1) && Array.isArray(obj2)) {
+        if (obj1.length !== obj2.length) {
+            return false;
+        }
+        for (let i = 0; i < obj1.length; i++) {
+            if (!areEqual(obj1[i], obj2[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+function summarize(value) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    const strValue = value.toString();
+    return strValue.length > 20 ? strValue.substr(0, 20) : strValue;
+}

package/build/cjs/structure/graph.d.cts

@@ -0,0 +1,57 @@
+/**
+ * @author Jorge Bay Gondra
+ */
+/**
+ * An "empty" graph object to server only as a reference.
+ */
+export declare class Graph {
+    toString(): string;
+}
+declare class Element<TLabel extends string = string, TId = any> {
+    readonly id: TId;
+    readonly label: TLabel;
+    readonly properties: Property[];
+    constructor(id: TId, label: TLabel, properties?: Property[]);
+    /**
+     * Compares this instance to another and determines if they can be considered as equal.
+     */
+    equals(other: any): boolean;
+}
+export declare class Vertex<TLabel extends string = string, TProperties extends Record<string, any> = Record<string, any>, TId = number, TVertexProperties = {
+    [P in keyof TProperties]: P extends string ? VertexProperties<P, TProperties[P]> : never;
+}> extends Element<TLabel, TId> {
+    constructor(id: TId, label: TLabel, properties?: Property[] | null);
+    toString(): string;
+}
+export declare class Edge<TOutVertex extends Vertex = Vertex, TLabel extends string = string, TInVertex extends Vertex = Vertex, TProperties extends Record<string, any> = Record<string, any>, TId = number> extends Element<TLabel, TId> {
+    readonly outV: TOutVertex;
+    readonly label: TLabel;
+    readonly inV: TInVertex;
+    constructor(id: TId, outV: TOutVertex, label: TLabel, inV: TInVertex, properties?: Property[] | null);
+    toString(): string;
+}
+export declare class VertexProperty<TLabel extends string = string, TValue = any, TProperties extends Record<string, any> | null | undefined = Record<string, any>, TId = any> extends Element<TLabel, TId> {
+    readonly value: TValue;
+    readonly key: string;
+    constructor(id: TId, label: TLabel, value: TValue, properties?: Property[] | null);
+    toString(): string;
+}
+export type VertexProperties<TLabel extends string = string, TValue = any, TProperties extends Record<string, any> = Record<string, any>, TId = any> = [VertexProperty<TLabel, TValue, TProperties, TId>, ...Array<VertexProperty<TLabel, TValue, TProperties, TId>>];
+export declare class Property<T = any> {
+    readonly key: string;
+    readonly value: T;
+    constructor(key: string, value: T);
+    toString(): string;
+    equals(other: any): boolean;
+}
+/**
+ * Represents a walk through a graph as defined by a traversal.
+ */
+export declare class Path {
+    readonly labels: string[][];
+    readonly objects: any[];
+    constructor(labels: string[][], objects: any[]);
+    toString(): string;
+    equals(other: any): any;
+}
+export {};

package/build/cjs/structure/io/binary/GraphBinary.cjs

@@ -0,0 +1,148 @@
+"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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphBinaryWriter = exports.graphBinaryReader = exports.anySerializer = exports.numberSerializationStrategy = exports.enumSerializer = exports.unspecifiedNullSerializer = exports.markerSerializer = exports.booleanSerializer = exports.shortSerializer = exports.binarySerializer = exports.byteSerializer = exports.bigIntegerSerializer = exports.vertexPropertySerializer = exports.vertexSerializer = exports.propertySerializer = exports.pathSerializer = exports.edgeSerializer = exports.uuidSerializer = exports.setSerializer = exports.mapSerializer = exports.listSerializer = exports.floatSerializer = exports.doubleSerializer = exports.dateTimeSerializer = exports.stringSerializer = exports.longSerializer = exports.intSerializer = exports.serializers = exports.DataType = void 0;
+/**
+ * GraphBinary 4.0 support implementation.
+ *
+ * The officially expected entrypoint is GraphBinaryReader/GraphBinaryWriter pair of classes,
+ * examine lib/driver/** for use cases.
+ *
+ * See AnySerializer.serialize() for the mechanism of serializer selection for a given JavaScript value,
+ * also consider AnySerializer.serialize() unit tests for real examples.
+ * See NumberSerializationStrategy to understand how it deals with JavaScript numbers' serialization.
+ *
+ * TODO: it has the following open topics:
+ * Core Data Types support:
+ * - [] 0x22: BigDecimal
+ * - [] 0x2b: Tree
+ * Extended Types support:
+ * - [] 0x80: Char
+ * - [] 0x81: Duration
+ *
+ * @author Igor Ostapenko
+ */
+/*eslint-disable*/
+const DataType_js_1 = __importDefault(require("./internals/DataType.cjs"));
+const utils = __importStar(require("./internals/utils.cjs"));
+const IntSerializer_js_1 = __importDefault(require("./internals/IntSerializer.cjs"));
+const LongSerializer_js_1 = __importDefault(require("./internals/LongSerializer.cjs"));
+const StringSerializer_js_1 = __importDefault(require("./internals/StringSerializer.cjs"));
+const DateTimeSerializer_js_1 = __importDefault(require("./internals/DateTimeSerializer.cjs"));
+const DoubleSerializer_js_1 = __importDefault(require("./internals/DoubleSerializer.cjs"));
+const FloatSerializer_js_1 = __importDefault(require("./internals/FloatSerializer.cjs"));
+const ArraySerializer_js_1 = __importDefault(require("./internals/ArraySerializer.cjs"));
+const MapSerializer_js_1 = __importDefault(require("./internals/MapSerializer.cjs"));
+const SetSerializer_js_1 = __importDefault(require("./internals/SetSerializer.cjs"));
+const UuidSerializer_js_1 = __importDefault(require("./internals/UuidSerializer.cjs"));
+const EdgeSerializer_js_1 = __importDefault(require("./internals/EdgeSerializer.cjs"));
+const PathSerializer_js_1 = __importDefault(require("./internals/PathSerializer.cjs"));
+const PropertySerializer_js_1 = __importDefault(require("./internals/PropertySerializer.cjs"));
+const VertexSerializer_js_1 = __importDefault(require("./internals/VertexSerializer.cjs"));
+const VertexPropertySerializer_js_1 = __importDefault(require("./internals/VertexPropertySerializer.cjs"));
+const BigIntegerSerializer_js_1 = __importDefault(require("./internals/BigIntegerSerializer.cjs"));
+const ByteSerializer_js_1 = __importDefault(require("./internals/ByteSerializer.cjs"));
+const BinarySerializer_js_1 = __importDefault(require("./internals/BinarySerializer.cjs"));
+const ShortSerializer_js_1 = __importDefault(require("./internals/ShortSerializer.cjs"));
+const BooleanSerializer_js_1 = __importDefault(require("./internals/BooleanSerializer.cjs"));
+const MarkerSerializer_js_1 = __importDefault(require("./internals/MarkerSerializer.cjs"));
+const UnspecifiedNullSerializer_js_1 = __importDefault(require("./internals/UnspecifiedNullSerializer.cjs"));
+const EnumSerializer_js_1 = __importDefault(require("./internals/EnumSerializer.cjs"));
+const StubSerializer_js_1 = __importDefault(require("./internals/StubSerializer.cjs"));
+const NumberSerializationStrategy_js_1 = __importDefault(require("./internals/NumberSerializationStrategy.cjs"));
+const AnySerializer_js_1 = __importDefault(require("./internals/AnySerializer.cjs"));
+const GraphBinaryReader_js_1 = __importDefault(require("./internals/GraphBinaryReader.cjs"));
+const GraphBinaryWriter_js_1 = __importDefault(require("./internals/GraphBinaryWriter.cjs"));
+const ioc = {};
+ioc.DataType = DataType_js_1.default;
+ioc.utils = utils;
+ioc.serializers = {};
+ioc.intSerializer = new IntSerializer_js_1.default(ioc);
+ioc.longSerializer = new LongSerializer_js_1.default(ioc);
+ioc.stringSerializer = new StringSerializer_js_1.default(ioc, ioc.DataType.STRING);
+ioc.dateTimeSerializer = new DateTimeSerializer_js_1.default(ioc);
+ioc.doubleSerializer = new DoubleSerializer_js_1.default(ioc);
+ioc.floatSerializer = new FloatSerializer_js_1.default(ioc);
+ioc.listSerializer = new ArraySerializer_js_1.default(ioc, ioc.DataType.LIST);
+ioc.mapSerializer = new MapSerializer_js_1.default(ioc);
+ioc.setSerializer = new SetSerializer_js_1.default(ioc, ioc.DataType.SET);
+ioc.uuidSerializer = new UuidSerializer_js_1.default(ioc);
+ioc.edgeSerializer = new EdgeSerializer_js_1.default(ioc);
+ioc.pathSerializer = new PathSerializer_js_1.default(ioc);
+ioc.propertySerializer = new PropertySerializer_js_1.default(ioc);
+ioc.vertexSerializer = new VertexSerializer_js_1.default(ioc);
+ioc.vertexPropertySerializer = new VertexPropertySerializer_js_1.default(ioc);
+ioc.bigIntegerSerializer = new BigIntegerSerializer_js_1.default(ioc);
+ioc.byteSerializer = new ByteSerializer_js_1.default(ioc);
+ioc.binarySerializer = new BinarySerializer_js_1.default(ioc);
+ioc.shortSerializer = new ShortSerializer_js_1.default(ioc);
+ioc.booleanSerializer = new BooleanSerializer_js_1.default(ioc);
+ioc.markerSerializer = new MarkerSerializer_js_1.default(ioc);
+ioc.unspecifiedNullSerializer = new UnspecifiedNullSerializer_js_1.default(ioc);
+ioc.enumSerializer = new EnumSerializer_js_1.default(ioc);
+// Register stub serializers for unimplemented v4 types
+new StubSerializer_js_1.default(ioc, ioc.DataType.TREE, 'Tree');
+new StubSerializer_js_1.default(ioc, ioc.DataType.GRAPH, 'Graph');
+new StubSerializer_js_1.default(ioc, ioc.DataType.COMPOSITEPDT, 'CompositePDT');
+new StubSerializer_js_1.default(ioc, ioc.DataType.PRIMITIVEPDT, 'PrimitivePDT');
+ioc.numberSerializationStrategy = new NumberSerializationStrategy_js_1.default(ioc);
+ioc.anySerializer = new AnySerializer_js_1.default(ioc);
+ioc.graphBinaryReader = new GraphBinaryReader_js_1.default(ioc);
+ioc.graphBinaryWriter = new GraphBinaryWriter_js_1.default(ioc);
+var DataType_js_2 = require("./internals/DataType.cjs");
+Object.defineProperty(exports, "DataType", { enumerable: true, get: function () { return __importDefault(DataType_js_2).default; } });
+exports.serializers = ioc.serializers, exports.intSerializer = ioc.intSerializer, exports.longSerializer = ioc.longSerializer, exports.stringSerializer = ioc.stringSerializer, exports.dateTimeSerializer = ioc.dateTimeSerializer, exports.doubleSerializer = ioc.doubleSerializer, exports.floatSerializer = ioc.floatSerializer, exports.listSerializer = ioc.listSerializer, exports.mapSerializer = ioc.mapSerializer, exports.setSerializer = ioc.setSerializer, exports.uuidSerializer = ioc.uuidSerializer, exports.edgeSerializer = ioc.edgeSerializer, exports.pathSerializer = ioc.pathSerializer, exports.propertySerializer = ioc.propertySerializer, exports.vertexSerializer = ioc.vertexSerializer, exports.vertexPropertySerializer = ioc.vertexPropertySerializer, exports.bigIntegerSerializer = ioc.bigIntegerSerializer, exports.byteSerializer = ioc.byteSerializer, exports.binarySerializer = ioc.binarySerializer, exports.shortSerializer = ioc.shortSerializer, exports.booleanSerializer = ioc.booleanSerializer, exports.markerSerializer = ioc.markerSerializer, exports.unspecifiedNullSerializer = ioc.unspecifiedNullSerializer, exports.enumSerializer = ioc.enumSerializer, exports.numberSerializationStrategy = ioc.numberSerializationStrategy, exports.anySerializer = ioc.anySerializer, exports.graphBinaryReader = ioc.graphBinaryReader, exports.graphBinaryWriter = ioc.graphBinaryWriter;
+exports.default = ioc;

package/build/cjs/structure/io/binary/GraphBinary.d.cts

@@ -0,0 +1,91 @@
+export { default as DataType } from "./internals/DataType.cjs";
+export const serializers: {};
+export const intSerializer: IntSerializer;
+export const longSerializer: LongSerializer;
+export const stringSerializer: StringSerializer;
+export const dateTimeSerializer: DateTimeSerializer;
+export const doubleSerializer: DoubleSerializer;
+export const floatSerializer: FloatSerializer;
+export const listSerializer: ArraySerializer;
+export const mapSerializer: MapSerializer;
+export const setSerializer: SetSerializer;
+export const uuidSerializer: UuidSerializer;
+export const edgeSerializer: EdgeSerializer;
+export const pathSerializer: PathSerializer;
+export const propertySerializer: PropertySerializer;
+export const vertexSerializer: VertexSerializer;
+export const vertexPropertySerializer: VertexPropertySerializer;
+export const bigIntegerSerializer: BigIntegerSerializer;
+export const byteSerializer: ByteSerializer;
+export const binarySerializer: BinarySerializer;
+export const shortSerializer: ShortSerializer;
+export const booleanSerializer: BooleanSerializer;
+export const markerSerializer: MarkerSerializer;
+export const unspecifiedNullSerializer: UnspecifiedNullSerializer;
+export const enumSerializer: EnumSerializer;
+export const numberSerializationStrategy: NumberSerializationStrategy;
+export const anySerializer: AnySerializer;
+export const graphBinaryReader: GraphBinaryReader;
+export const graphBinaryWriter: GraphBinaryWriter;
+export default ioc;
+import IntSerializer from './internals/IntSerializer.cjs';
+import LongSerializer from './internals/LongSerializer.cjs';
+import StringSerializer from './internals/StringSerializer.cjs';
+import DateTimeSerializer from './internals/DateTimeSerializer.cjs';
+import DoubleSerializer from './internals/DoubleSerializer.cjs';
+import FloatSerializer from './internals/FloatSerializer.cjs';
+import ArraySerializer from './internals/ArraySerializer.cjs';
+import MapSerializer from './internals/MapSerializer.cjs';
+import SetSerializer from './internals/SetSerializer.cjs';
+import UuidSerializer from './internals/UuidSerializer.cjs';
+import EdgeSerializer from './internals/EdgeSerializer.cjs';
+import PathSerializer from './internals/PathSerializer.cjs';
+import PropertySerializer from './internals/PropertySerializer.cjs';
+import VertexSerializer from './internals/VertexSerializer.cjs';
+import VertexPropertySerializer from './internals/VertexPropertySerializer.cjs';
+import BigIntegerSerializer from './internals/BigIntegerSerializer.cjs';
+import ByteSerializer from './internals/ByteSerializer.cjs';
+import BinarySerializer from './internals/BinarySerializer.cjs';
+import ShortSerializer from './internals/ShortSerializer.cjs';
+import BooleanSerializer from './internals/BooleanSerializer.cjs';
+import MarkerSerializer from './internals/MarkerSerializer.cjs';
+import UnspecifiedNullSerializer from './internals/UnspecifiedNullSerializer.cjs';
+import EnumSerializer from './internals/EnumSerializer.cjs';
+import NumberSerializationStrategy from './internals/NumberSerializationStrategy.cjs';
+import AnySerializer from './internals/AnySerializer.cjs';
+import GraphBinaryReader from './internals/GraphBinaryReader.cjs';
+import GraphBinaryWriter from './internals/GraphBinaryWriter.cjs';
+declare namespace ioc {
+    export { DataType };
+    export { utils };
+    export let serializers: {};
+    export let intSerializer: IntSerializer;
+    export let longSerializer: LongSerializer;
+    export let stringSerializer: StringSerializer;
+    export let dateTimeSerializer: DateTimeSerializer;
+    export let doubleSerializer: DoubleSerializer;
+    export let floatSerializer: FloatSerializer;
+    export let listSerializer: ArraySerializer;
+    export let mapSerializer: MapSerializer;
+    export let setSerializer: SetSerializer;
+    export let uuidSerializer: UuidSerializer;
+    export let edgeSerializer: EdgeSerializer;
+    export let pathSerializer: PathSerializer;
+    export let propertySerializer: PropertySerializer;
+    export let vertexSerializer: VertexSerializer;
+    export let vertexPropertySerializer: VertexPropertySerializer;
+    export let bigIntegerSerializer: BigIntegerSerializer;
+    export let byteSerializer: ByteSerializer;
+    export let binarySerializer: BinarySerializer;
+    export let shortSerializer: ShortSerializer;
+    export let booleanSerializer: BooleanSerializer;
+    export let markerSerializer: MarkerSerializer;
+    export let unspecifiedNullSerializer: UnspecifiedNullSerializer;
+    export let enumSerializer: EnumSerializer;
+    export let numberSerializationStrategy: NumberSerializationStrategy;
+    export let anySerializer: AnySerializer;
+    export let graphBinaryReader: GraphBinaryReader;
+    export let graphBinaryWriter: GraphBinaryWriter;
+}
+import DataType from './internals/DataType.cjs';
+import * as utils from './internals/utils.cjs';