falkordb 6.8.0 → 6.9.1

package/dist/src/commands/CONSTRAINT_CREATE.d.ts

@@ -1,12 +1,6 @@
 import { CommandParser } from '@redis/client';
-export declare enum ConstraintType {
-    MANDATORY = "MANDATORY",
-    UNIQUE = "UNIQUE"
-}
-export declare enum EntityType {
-    NODE = "NODE",
-    RELATIONSHIP = "RELATIONSHIP"
-}
+import { ConstraintType, EntityType } from '../enums';
+export { ConstraintType, EntityType };
 export declare function parseCommand(parser: CommandParser, key: string, constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): void;
 export declare function transformArguments(key: string, constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): Array<string>;
 export declare function transformReply(reply: unknown): 'PENDING';

package/dist/src/commands/CONSTRAINT_CREATE.js

@@ -4,16 +4,9 @@ exports.EntityType = exports.ConstraintType = void 0;
 exports.parseCommand = parseCommand;
 exports.transformArguments = transformArguments;
 exports.transformReply = transformReply;
-var ConstraintType;
-(function (ConstraintType) {
-    ConstraintType["MANDATORY"] = "MANDATORY";
-    ConstraintType["UNIQUE"] = "UNIQUE";
-})(ConstraintType || (exports.ConstraintType = ConstraintType = {}));
-var EntityType;
-(function (EntityType) {
-    EntityType["NODE"] = "NODE";
-    EntityType["RELATIONSHIP"] = "RELATIONSHIP";
-})(EntityType || (exports.EntityType = EntityType = {}));
+const enums_1 = require("../enums");
+Object.defineProperty(exports, "ConstraintType", { enumerable: true, get: function () { return enums_1.ConstraintType; } });
+Object.defineProperty(exports, "EntityType", { enumerable: true, get: function () { return enums_1.EntityType; } });
 // GRAPH.CONSTRAINT CREATE key constraintType {NODE label | RELATIONSHIP reltype} PROPERTIES propCount prop [prop...]
 function parseCommand(parser, key, constraintType, entityType, label, ...properties) {
     parser.push('GRAPH.CONSTRAINT', 'CREATE', key, constraintType, entityType, label, 'PROPERTIES', properties.length.toString(), ...properties);

package/dist/src/commands/CONSTRAINT_DROP.d.ts

@@ -1,5 +1,5 @@
 import { CommandParser } from '@redis/client';
-import { ConstraintType, EntityType } from "./CONSTRAINT_CREATE";
+import { ConstraintType, EntityType } from '../enums';
 export declare function parseCommand(parser: CommandParser, key: string, constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): void;
 export declare function transformArguments(key: string, constraintType: ConstraintType, entityType: EntityType, label: string, ...properties: string[]): Array<string>;
 export declare function transformReply(reply: unknown): 'OK';

package/dist/src/commands/MEMORY_USAGE.d.ts

@@ -1,8 +1,6 @@
 import { CommandParser } from '@redis/client';
-export interface MemoryUsageOptions {
-    SAMPLES?: number;
-}
+import type { MemoryUsageOptions, MemoryUsageReply } from '../types';
+export type { MemoryUsageOptions, MemoryUsageReply };
 export declare function parseCommand(parser: CommandParser, key: string, options?: MemoryUsageOptions): void;
 export declare function transformArguments(key: string, options?: MemoryUsageOptions): Array<string>;
-export type MemoryUsageReply = Array<string | number | MemoryUsageReply>;
 export declare function transformReply(reply: unknown): MemoryUsageReply;

package/dist/src/commands/QUERY.d.ts

@@ -1,26 +1,7 @@
 import { RedisArgument, CommandParser } from '@redis/client';
-import { QueryOptionsBackwardCompatible } from '.';
+import type { QueryOptionsBackwardCompatible, QueryRawReply, QueryReply } from '../types';
+export type { QueryReply };
 export declare const FIRST_KEY_INDEX = 1;
-export declare function parseCommand(parser: CommandParser, graph: RedisArgument, query: RedisArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean): void;
-export declare function transformArguments(graph: RedisArgument, query: RedisArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean): Array<RedisArgument>;
-type Headers = Array<string>;
-type Data = Array<string | number | null | Data>;
-type Metadata = Array<string>;
-type QueryRawReply = [
-    headers: Headers,
-    data: Data,
-    metadata: Metadata
-] | [
-    metadata: Metadata
-];
-export type QueryReply = {
-    headers: undefined;
-    data: undefined;
-    metadata: Metadata;
-} | {
-    headers: Headers;
-    data: Data;
-    metadata: Metadata;
-};
+export declare function parseCommand(parser: CommandParser, graph: RedisArgument, query: RedisArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean, version?: number): void;
+export declare function transformArguments(graph: RedisArgument, query: RedisArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean, version?: number): Array<RedisArgument>;
 export declare function transformReply(reply: QueryRawReply): QueryReply;
-export {};

package/dist/src/commands/QUERY.js

@@ -5,15 +5,25 @@ exports.parseCommand = parseCommand;
 exports.transformArguments = transformArguments;
 exports.transformReply = transformReply;
 const _1 = require(".");
+const errors_1 = require("../errors");
 exports.FIRST_KEY_INDEX = 1;
-function parseCommand(parser, graph, query, options, compact) {
-    const args = (0, _1.pushQueryArguments)(['GRAPH.QUERY'], graph, query, options, compact);
+function parseCommand(parser, graph, query, options, compact, version) {
+    const args = (0, _1.pushQueryArguments)(['GRAPH.QUERY'], graph, query, options, compact, version);
     parser.push(...args);
 }
-function transformArguments(graph, query, options, compact) {
-    return (0, _1.pushQueryArguments)(['GRAPH.QUERY'], graph, query, options, compact);
+function transformArguments(graph, query, options, compact, version) {
+    return (0, _1.pushQueryArguments)(['GRAPH.QUERY'], graph, query, options, compact, version);
 }
 function transformReply(reply) {
+    // A query sent with a stale `version` is rejected with
+    // `[error "version mismatch", current version]` and not executed
+    const [first, second] = reply;
+    if (first instanceof Error) {
+        if (first.message === 'version mismatch') {
+            throw new errors_1.SchemaVersionMismatchError(second);
+        }
+        throw first;
+    }
     return reply.length === 1 ? {
         headers: undefined,
         data: undefined,

package/dist/src/commands/RO_QUERY.d.ts

@@ -2,6 +2,6 @@ import { RedisArgument, CommandParser } from '@redis/client';
 import { QueryOptionsBackwardCompatible } from '.';
 export { FIRST_KEY_INDEX } from './QUERY';
 export declare const IS_READ_ONLY = true;
-export declare function parseCommand(parser: CommandParser, graph: RedisArgument, query: RedisArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean): void;
-export declare function transformArguments(graph: RedisArgument, query: RedisArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean): Array<RedisArgument>;
+export declare function parseCommand(parser: CommandParser, graph: RedisArgument, query: RedisArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean, version?: number): void;
+export declare function transformArguments(graph: RedisArgument, query: RedisArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean, version?: number): Array<RedisArgument>;
 export { transformReply } from './QUERY';

package/dist/src/commands/RO_QUERY.js

@@ -7,12 +7,12 @@ const _1 = require(".");
 var QUERY_1 = require("./QUERY");
 Object.defineProperty(exports, "FIRST_KEY_INDEX", { enumerable: true, get: function () { return QUERY_1.FIRST_KEY_INDEX; } });
 exports.IS_READ_ONLY = true;
-function parseCommand(parser, graph, query, options, compact) {
-    const args = (0, _1.pushQueryArguments)(['GRAPH.RO_QUERY'], graph, query, options, compact);
+function parseCommand(parser, graph, query, options, compact, version) {
+    const args = (0, _1.pushQueryArguments)(['GRAPH.RO_QUERY'], graph, query, options, compact, version);
     parser.push(...args);
 }
-function transformArguments(graph, query, options, compact) {
-    return (0, _1.pushQueryArguments)(['GRAPH.RO_QUERY'], graph, query, options, compact);
+function transformArguments(graph, query, options, compact, version) {
+    return (0, _1.pushQueryArguments)(['GRAPH.RO_QUERY'], graph, query, options, compact, version);
 }
 var QUERY_2 = require("./QUERY");
 Object.defineProperty(exports, "transformReply", { enumerable: true, get: function () { return QUERY_2.transformReply; } });

package/dist/src/commands/SLOWLOG.d.ts

@@ -1,19 +1,7 @@
 import { CommandParser } from '@redis/client';
+import type { SlowLogRawReply, SlowLogReply } from '../types';
 export declare const IS_READ_ONLY = true;
 export declare const FIRST_KEY_INDEX = 1;
 export declare function parseCommand(parser: CommandParser, key: string): void;
 export declare function transformArguments(key: string): string[];
-type SlowLogRawReply = Array<[
-    timestamp: string,
-    command: string,
-    query: string,
-    took: string
-]>;
-type SlowLogReply = Array<{
-    timestamp: Date;
-    command: string;
-    query: string;
-    took: number;
-}>;
 export declare function transformReply(logs: SlowLogRawReply): SlowLogReply;
-export {};

package/dist/src/commands/UDF_LIST.d.ts

@@ -1,7 +1,7 @@
 import { CommandParser } from '@redis/client';
 export declare const IS_READ_ONLY = true;
-export type UdfLibraryEntry = [string, string[]] | [string, string[], string];
-export type UdfListReply = UdfLibraryEntry[];
+import type { UdfListReply } from '../types';
+export type { UdfLibraryEntry, UdfListReply } from '../types';
 export declare function parseCommand(parser: CommandParser, lib?: string, withCode?: boolean): void;
 export declare function transformArguments(lib?: string, withCode?: boolean): Array<string>;
 export declare function transformReply(reply: unknown): UdfListReply;

package/dist/src/commands/index.d.ts

@@ -20,6 +20,7 @@ import * as UDF_LIST from './UDF_LIST';
 import * as UDF_FLUSH from './UDF_FLUSH';
 import * as UDF_DELETE from './UDF_DELETE';
 import { RedisArgument } from '@redis/client';
+import type { QueryOptionsBackwardCompatible } from '../types';
 declare const _default: {
     CONFIG_GET: typeof CONFIG_GET;
     configGet: typeof CONFIG_GET;
@@ -65,14 +66,6 @@ declare const _default: {
     udfDelete: typeof UDF_DELETE;
 };
 export default _default;
-type QueryParam = null | string | number | boolean | QueryParams | Array<QueryParam>;
-type QueryParams = {
-    [key: string]: QueryParam;
-};
-export interface QueryOptions {
-    params?: QueryParams;
-    TIMEOUT?: number;
-}
-export type QueryOptionsBackwardCompatible = QueryOptions | number;
-export declare function pushQueryArguments(args: Array<RedisArgument>, graph: RedisArgument, query: RedisArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean): Array<RedisArgument>;
-export type { UdfListReply, UdfLibraryEntry } from './UDF_LIST';
+export type { QueryOptions, QueryOptionsBackwardCompatible, QueryParam, QueryParams } from '../types';
+export declare function pushQueryArguments(args: Array<RedisArgument>, graph: RedisArgument, query: RedisArgument, options?: QueryOptionsBackwardCompatible, compact?: boolean, version?: number): Array<RedisArgument>;
+export type { UdfListReply, UdfLibraryEntry } from '../types';

package/dist/src/commands/index.js

@@ -1,27 +1,60 @@
 "use strict";
+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;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pushQueryArguments = pushQueryArguments;
-const CONFIG_GET = require("./CONFIG_GET");
-const CONFIG_SET = require("./CONFIG_SET");
-const DELETE = require("./DELETE");
-const EXPLAIN = require("./EXPLAIN");
-const INFO = require("./INFO");
-const LIST = require("./LIST");
-const PROFILE = require("./PROFILE");
-const QUERY = require("./QUERY");
-const RO_QUERY = require("./RO_QUERY");
-const SLOWLOG = require("./SLOWLOG");
-const STUBS = require("./STUBS");
-const CONSTRAINT_CREATE = require("./CONSTRAINT_CREATE");
-const CONSTRAINT_DROP = require("./CONSTRAINT_DROP");
-const COPY = require("./COPY");
-const SENTINEL_MASTER = require("./SENTINEL_MASTER");
-const SENTINEL_MASTERS = require("./SENTINEL_MASTERS");
-const MEMORY_USAGE = require("./MEMORY_USAGE");
-const UDF_LOAD = require("./UDF_LOAD");
-const UDF_LIST = require("./UDF_LIST");
-const UDF_FLUSH = require("./UDF_FLUSH");
-const UDF_DELETE = require("./UDF_DELETE");
+const CONFIG_GET = __importStar(require("./CONFIG_GET"));
+const CONFIG_SET = __importStar(require("./CONFIG_SET"));
+const DELETE = __importStar(require("./DELETE"));
+const EXPLAIN = __importStar(require("./EXPLAIN"));
+const INFO = __importStar(require("./INFO"));
+const LIST = __importStar(require("./LIST"));
+const PROFILE = __importStar(require("./PROFILE"));
+const QUERY = __importStar(require("./QUERY"));
+const RO_QUERY = __importStar(require("./RO_QUERY"));
+const SLOWLOG = __importStar(require("./SLOWLOG"));
+const STUBS = __importStar(require("./STUBS"));
+const CONSTRAINT_CREATE = __importStar(require("./CONSTRAINT_CREATE"));
+const CONSTRAINT_DROP = __importStar(require("./CONSTRAINT_DROP"));
+const COPY = __importStar(require("./COPY"));
+const SENTINEL_MASTER = __importStar(require("./SENTINEL_MASTER"));
+const SENTINEL_MASTERS = __importStar(require("./SENTINEL_MASTERS"));
+const MEMORY_USAGE = __importStar(require("./MEMORY_USAGE"));
+const UDF_LOAD = __importStar(require("./UDF_LOAD"));
+const UDF_LIST = __importStar(require("./UDF_LIST"));
+const UDF_FLUSH = __importStar(require("./UDF_FLUSH"));
+const UDF_DELETE = __importStar(require("./UDF_DELETE"));
 exports.default = {
     CONFIG_GET,
     configGet: CONFIG_GET,
@@ -66,7 +99,7 @@ exports.default = {
     UDF_DELETE,
     udfDelete: UDF_DELETE,
 };
-function pushQueryArguments(args, graph, query, options, compact) {
+function pushQueryArguments(args, graph, query, options, compact, version) {
     args.push(graph);
     if (typeof options === 'number') {
         args.push(query);
@@ -80,6 +113,9 @@ function pushQueryArguments(args, graph, query, options, compact) {
             pushTimeout(args, options.TIMEOUT);
         }
     }
+    if (version !== undefined) {
+        args.push('version', version.toString());
+    }
     if (compact) {
         args.push('--compact');
     }

package/dist/src/enums/constraint-type.d.ts

@@ -0,0 +1,4 @@
+export declare enum ConstraintType {
+    MANDATORY = "MANDATORY",
+    UNIQUE = "UNIQUE"
+}

package/dist/src/enums/constraint-type.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstraintType = void 0;
+var ConstraintType;
+(function (ConstraintType) {
+    ConstraintType["MANDATORY"] = "MANDATORY";
+    ConstraintType["UNIQUE"] = "UNIQUE";
+})(ConstraintType || (exports.ConstraintType = ConstraintType = {}));

package/dist/src/enums/entity-type.d.ts

@@ -0,0 +1,4 @@
+export declare enum EntityType {
+    NODE = "NODE",
+    RELATIONSHIP = "RELATIONSHIP"
+}

package/dist/src/enums/entity-type.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityType = void 0;
+var EntityType;
+(function (EntityType) {
+    EntityType["NODE"] = "NODE";
+    EntityType["RELATIONSHIP"] = "RELATIONSHIP";
+})(EntityType || (exports.EntityType = EntityType = {}));

package/dist/src/enums/graph-value-types.d.ts

@@ -0,0 +1,19 @@
+export declare enum GraphValueTypes {
+    UNKNOWN = 0,
+    NULL = 1,
+    STRING = 2,
+    INTEGER = 3,
+    BOOLEAN = 4,
+    DOUBLE = 5,
+    ARRAY = 6,
+    EDGE = 7,
+    NODE = 8,
+    PATH = 9,
+    MAP = 10,
+    POINT = 11,
+    VECTORF32 = 12,
+    DATETIME = 13,
+    DATE = 14,
+    TIME = 15,
+    DURATION = 16
+}

package/dist/src/enums/graph-value-types.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphValueTypes = void 0;
+// https://github.com/FalkorDB/FalkorDB/blob/master/src/resultset/formatters/resultset_formatter.h#L20
+var GraphValueTypes;
+(function (GraphValueTypes) {
+    GraphValueTypes[GraphValueTypes["UNKNOWN"] = 0] = "UNKNOWN";
+    GraphValueTypes[GraphValueTypes["NULL"] = 1] = "NULL";
+    GraphValueTypes[GraphValueTypes["STRING"] = 2] = "STRING";
+    GraphValueTypes[GraphValueTypes["INTEGER"] = 3] = "INTEGER";
+    GraphValueTypes[GraphValueTypes["BOOLEAN"] = 4] = "BOOLEAN";
+    GraphValueTypes[GraphValueTypes["DOUBLE"] = 5] = "DOUBLE";
+    GraphValueTypes[GraphValueTypes["ARRAY"] = 6] = "ARRAY";
+    GraphValueTypes[GraphValueTypes["EDGE"] = 7] = "EDGE";
+    GraphValueTypes[GraphValueTypes["NODE"] = 8] = "NODE";
+    GraphValueTypes[GraphValueTypes["PATH"] = 9] = "PATH";
+    GraphValueTypes[GraphValueTypes["MAP"] = 10] = "MAP";
+    GraphValueTypes[GraphValueTypes["POINT"] = 11] = "POINT";
+    GraphValueTypes[GraphValueTypes["VECTORF32"] = 12] = "VECTORF32";
+    GraphValueTypes[GraphValueTypes["DATETIME"] = 13] = "DATETIME";
+    GraphValueTypes[GraphValueTypes["DATE"] = 14] = "DATE";
+    GraphValueTypes[GraphValueTypes["TIME"] = 15] = "TIME";
+    GraphValueTypes[GraphValueTypes["DURATION"] = 16] = "DURATION";
+})(GraphValueTypes || (exports.GraphValueTypes = GraphValueTypes = {}));

package/dist/src/enums/index.d.ts

@@ -0,0 +1,3 @@
+export * from './constraint-type';
+export * from './entity-type';
+export * from './graph-value-types';

package/dist/src/enums/index.js

@@ -0,0 +1,19 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constraint-type"), exports);
+__exportStar(require("./entity-type"), exports);
+__exportStar(require("./graph-value-types"), exports);

package/dist/src/errors.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The server rejected a query because the graph's schema (its labels,
+ * relationship types and property keys) no longer matches the version the
+ * client sent with it. The query was not executed.
+ */
+export declare class SchemaVersionMismatchError extends Error {
+    /** The graph's current schema version. */
+    readonly version: number;
+    constructor(version: number);
+}

package/dist/src/errors.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaVersionMismatchError = void 0;
+/**
+ * The server rejected a query because the graph's schema (its labels,
+ * relationship types and property keys) no longer matches the version the
+ * client sent with it. The query was not executed.
+ */
+class SchemaVersionMismatchError extends Error {
+    /** The graph's current schema version. */
+    version;
+    constructor(version) {
+        super('version mismatch');
+        this.name = 'SchemaVersionMismatchError';
+        this.version = version;
+    }
+}
+exports.SchemaVersionMismatchError = SchemaVersionMismatchError;

package/dist/src/falkordb.d.ts

@@ -1,94 +1,20 @@
-import * as tls from 'tls';
-import * as net from 'net';
 import { EventEmitter } from 'events';
-import { RedisClientOptions, RedisFunctions, RedisScripts } from 'redis';
 import Graph from './graph';
-import commands from './commands';
-import { RedisClusterOptions } from '@redis/client';
-import { SingleGraphConnection } from './clients/single';
-type NetSocketOptions = Partial<net.SocketConnectOpts> & {
-    tls?: false;
-};
-export type TypedRedisClientOptions = RedisClientOptions<{
-    falkordb: typeof commands;
-}, RedisFunctions, RedisScripts, 2>;
-export type TypedRedisClusterClientOptions = RedisClusterOptions<{
-    falkordb: typeof commands;
-}, RedisFunctions, RedisScripts, 2>;
-interface TlsSocketOptions extends tls.ConnectionOptions {
-    tls: true;
-}
-interface SocketCommonOptions {
-    /**
-     * Connection Timeout (in milliseconds)
-     */
-    connectTimeout?: number;
-    /**
-     * Toggle [`Nagle's algorithm`](https://nodejs.org/api/net.html#net_socket_setnodelay_nodelay)
-     */
-    noDelay?: boolean;
-    /**
-     * Toggle [`keep-alive`](https://nodejs.org/api/net.html#net_socket_setkeepalive_enable_initialdelay)
-     */
-    keepAlive?: number | false;
-    /**
-     * When the socket closes unexpectedly (without calling `.quit()`/`.disconnect()`), the client uses `reconnectStrategy` to decide what to do. The following values are supported:
-     */
-    tls?: boolean;
-}
-export type SocketOptions = SocketCommonOptions & (NetSocketOptions | TlsSocketOptions);
-export interface FalkorDBOptions {
-    /**
-     * `falkor[s]://[[username][:password]@][host][:port][/db-number]`
-     */
-    url?: string;
-    /**
-     * Socket connection properties
-     */
-    socket?: SocketOptions;
-    /**
-     * Server hostname, shorthand for `socket.host`.
-     * Ignored when `url` or `socket.host` is provided.
-     */
-    host?: string;
-    /**
-     * Server port, shorthand for `socket.port`.
-     * Ignored when `url` or `socket.port` is provided.
-     */
-    port?: number;
-    /**
-     * ACL username ([see ACL guide](https://redis.io/topics/acl))
-     */
-    username?: string;
-    /**
-     * ACL password or the old "--requirepass" password
-     */
-    password?: string;
-    /**
-     * Client name ([see `CLIENT SETNAME`](https://redis.io/commands/client-setname))
-     */
-    name?: string;
-    /**
-     * Connect in [`READONLY`](https://redis.io/commands/readonly) mode
-     */
-    readonly?: boolean;
-    /**
-     * Send `PING` command at interval (in ms).
-     * Useful with Redis deployments that do not use TCP Keep-Alive.
-     */
-    pingInterval?: number;
-    /**
-     * If set to true, disables sending client identifier (user-agent like message) to the redis server
-     */
-    disableClientInfo?: boolean;
-    /**
-     * Tag to append to library name that is sent to the Redis server
-     */
-    clientInfoTag?: string;
-}
+import type { FalkorDBOptions, SingleGraphConnection } from './types';
+export type { FalkorDBOptions, SocketOptions, TypedRedisClientOptions, TypedRedisClusterClientOptions, } from './types';
 export default class FalkorDB extends EventEmitter {
     #private;
     static connect(options?: FalkorDBOptions): Promise<FalkorDB>;
+    /**
+     * Returns the `Graph` for `graphId`. Repeated calls with the same id return
+     * the same instance, so its cached metadata (labels, relationship types and
+     * property keys) is shared instead of being refetched by every new handle.
+     * The instance is released when the graph is deleted through it, or when
+     * more than `MAX_CACHED_GRAPHS` graphs have been selected since its last use.
+     * Each query carries the schema version the cached metadata matches, so a
+     * schema changed by another client (e.g. the graph deleted and recreated) is
+     * rejected by the server and the metadata refreshed before the query is retried.
+     */
     selectGraph(graphId: string): Graph;
     get connection(): Promise<SingleGraphConnection>;
     list(): Promise<string[]>;
@@ -101,7 +27,7 @@ export default class FalkorDB extends EventEmitter {
      * should treat such a rejection as "no offloading support".
      */
     stubs(): Promise<string[]>;
-    configGet(configKey: string): Promise<(string | number)[] | (string | number)[][]>;
+    configGet(configKey: string): Promise<(string | number)[][] | (string | number)[]>;
     configSet(configKey: string, value: number | string): Promise<void>;
     info(section?: string): Promise<(string | string[])[]>;
     udfLoad(name: string, script: string | Function, replace?: boolean): Promise<string>;
@@ -113,4 +39,4 @@ export default class FalkorDB extends EventEmitter {
      */
     close(): Promise<void>;
 }
-export {};
+export { FalkorDB };