js-redis-server 0.0.1 → 0.0.3

package/dist/core/turn-queue.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerialTurnQueue = void 0;
+class SerialTurnQueue {
+    queue = [];
+    locked = false;
+    waitTurn() {
+        return this.waitTurnInternal(false);
+    }
+    waitTurnInternal(priority) {
+        return new Promise(resolve => {
+            const grantTurn = () => {
+                this.locked = true;
+                let active = true;
+                const release = () => {
+                    if (!active)
+                        return;
+                    active = false;
+                    this.locked = false;
+                    this.scheduleNext();
+                };
+                const suspend = async (waitFor) => {
+                    if (!active) {
+                        throw new Error('Turn already released');
+                    }
+                    active = false;
+                    this.locked = false;
+                    this.scheduleNext();
+                    await waitFor;
+                    return this.waitTurnInternal(true);
+                };
+                resolve({ release, suspend });
+            };
+            if (priority) {
+                this.queue.unshift(grantTurn);
+            }
+            else {
+                this.queue.push(grantTurn);
+            }
+            this.scheduleNext();
+        });
+    }
+    scheduleNext() {
+        if (this.locked)
+            return;
+        const next = this.queue.shift();
+        next?.();
+    }
+}
+exports.SerialTurnQueue = SerialTurnQueue;
+//# sourceMappingURL=turn-queue.js.map

package/dist/core/turn-queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn-queue.js","sourceRoot":"","sources":["../../src/core/turn-queue.ts"],"names":[],"mappings":";;;AAWA,MAAa,eAAe;IACT,KAAK,GAAmB,EAAE,CAAA;IACnC,MAAM,GAAG,KAAK,CAAA;IAEtB,QAAQ;QACN,OAAO,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAA;IACrC,CAAC;IAEO,gBAAgB,CAAC,QAAiB;QACxC,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE;YAC3B,MAAM,SAAS,GAAG,GAAG,EAAE;gBACrB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAA;gBAClB,IAAI,MAAM,GAAG,IAAI,CAAA;gBAEjB,MAAM,OAAO,GAAG,GAAG,EAAE;oBACnB,IAAI,CAAC,MAAM;wBAAE,OAAM;oBACnB,MAAM,GAAG,KAAK,CAAA;oBACd,IAAI,CAAC,MAAM,GAAG,KAAK,CAAA;oBACnB,IAAI,CAAC,YAAY,EAAE,CAAA;gBACrB,CAAC,CAAA;gBAED,MAAM,OAAO,GAAG,KAAK,EACnB,OAAyB,EACC,EAAE;oBAC5B,IAAI,CAAC,MAAM,EAAE,CAAC;wBACZ,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAA;oBAC1C,CAAC;oBAED,MAAM,GAAG,KAAK,CAAA;oBACd,IAAI,CAAC,MAAM,GAAG,KAAK,CAAA;oBACnB,IAAI,CAAC,YAAY,EAAE,CAAA;oBACnB,MAAM,OAAO,CAAA;oBACb,OAAO,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAA;gBACpC,CAAC,CAAA;gBAED,OAAO,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAA;YAC/B,CAAC,CAAA;YAED,IAAI,QAAQ,EAAE,CAAC;gBACb,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,CAAA;YAC/B,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;YAC5B,CAAC;YAED,IAAI,CAAC,YAAY,EAAE,CAAA;QACrB,CAAC,CAAC,CAAA;IACJ,CAAC;IAEO,YAAY;QAClB,IAAI,IAAI,CAAC,MAAM;YAAE,OAAM;QAEvB,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAA;QAC/B,IAAI,EAAE,EAAE,CAAA;IACV,CAAC;CACF;AAtDD,0CAsDC"}

package/dist/index.d.ts

@@ -1,347 +1,35 @@
-import { Server } from 'net';
-import { LuaWasmModule, ReplyValue } from 'lua-redis-wasm';
-import { EventEmitter } from 'node:events';
-
-/**
- * Redis command metadata following Redis COMMAND specification
- * @see https://redis.io/commands/command
- */
-interface CommandMetadata {
-    /** Command name (lowercase) */
-    name: string;
-    /**
-     * Number of arguments
-     * Positive: exact count (including command name)
-     * Negative: minimum count (abs value), variable args
-     * Example: GET = 2 (GET key), MGET = -2 (MGET key [key ...])
-     */
-    arity: number;
-    /** Command flags */
-    flags: CommandFlags;
-    /**
-     * First key position (0-indexed in args, not including command name)
-     * -1 means no keys
-     */
-    firstKey: number;
-    /**
-     * Last key position
-     * -1 means last argument is key
-     * -2 means second-to-last, etc.
-     */
-    lastKey: number;
-    /**
-     * Step between keys (usually 1)
-     * Example: MGET has step 1, MSET has step 2 (key val key val)
-     */
-    keyStep: number;
-    /**
-     * Divisor for remaining args when lastKey=-1
-     * @see https://redis.io/docs/latest/develop/reference/key-specs/
-     * 0 or 1: no limit (all remaining args are keys)
-     * 2: half the remaining args are keys (e.g., MSET key val key val)
-     * 3: one-third are keys, etc.
-     */
-    limit: number;
-    /** Redis command categories */
-    categories: CommandCategory[];
-}
-/**
- * Command flags following Redis specification
- */
-interface CommandFlags {
-    /** Command doesn't modify data (safe for replicas) */
-    readonly?: boolean;
-    /** Command modifies data */
-    write?: boolean;
-    /** Deny command when used memory > maxmemory */
-    denyoom?: boolean;
-    /** Administrative command */
-    admin?: boolean;
-    /** Not allowed in Lua scripts */
-    noscript?: boolean;
-    /** Returns random/non-deterministic results */
-    random?: boolean;
-    /** Blocking operation (BLPOP, BRPOP, etc.) */
-    blocking?: boolean;
-    /** O(1) time complexity */
-    fast?: boolean;
-    /** Keys are not in fixed positions (requires key extraction) */
-    movablekeys?: boolean;
-    /** Transaction-related command */
-    transaction?: boolean;
-}
-/**
- * Redis command categories
- * @see https://redis.io/commands#command-categories
- */
-declare enum CommandCategory {
-    STRING = "@string",
-    HASH = "@hash",
-    LIST = "@list",
-    SET = "@set",
-    ZSET = "@zset",
-    KEYS = "@keys",
-    GENERIC = "@generic",
-    SCRIPT = "@scripting",
-    SERVER = "@server",
-    CONNECTION = "@connection",
-    CLUSTER = "@cluster",
-    TRANSACTION = "@transactions",
-    PUBSUB = "@pubsub",
-    STREAM = "@stream"
-}
-
-declare class UserFacedError extends Error {
-    toLuaError(): {
-        err: Buffer;
-    };
-}
-declare class UnknownCommand extends UserFacedError {
-    constructor(cmdName: string | Buffer, args: Buffer[] | string[]);
-}
-
-interface DBCommandExecutor {
-    shutdown(): Promise<void>;
-}
-interface ExecutionContext {
-    execute(transport: Transport, rawCmd: Buffer, args: Buffer[], signal: AbortSignal): ExecutionContext;
-    shutdown(): Promise<void>;
-}
-type CommandResult = string | number | bigint | null | Buffer | UserFacedError | CommandResult[];
-interface Logger {
-    info(msg: unknown, metadata?: Record<string, unknown>): void;
-    error(msg: unknown, metadata?: Record<string, unknown>): void;
-}
-interface Command {
-    /** Command metadata (arity, flags, key positions) */
-    readonly metadata: CommandMetadata;
-    /**
-     * Extract keys from command arguments
-     * Used for cluster slot routing and WATCH tracking
-     */
-    getKeys(rawCmd: Buffer, args: Buffer[]): Buffer[];
-    /**
-     * Execute command
-     */
-    run(rawCmd: Buffer, args: Buffer[], signal: AbortSignal, transport: Transport): CommandResult | void;
-}
-type SlotRange = [number, number];
-type DiscoveryNode = {
-    host: string;
-    port: number;
-    slots: SlotRange[];
-    id: string;
-};
-interface ClusterCommanderFactory {
-    createCommander(mySelfId: string): DBCommandExecutor;
-    createReadOnlyCommander(mySelfId: string): DBCommandExecutor;
-    shutdown(): Promise<void>;
-}
-interface DiscoveryService {
-    getAll(): DiscoveryNode[];
-    isMaster(id: string): boolean;
-    getMaster(id: string): DiscoveryNode;
-    getById(id: string): DiscoveryNode;
-    getBySlot(slot: number): DiscoveryNode;
-}
-interface Transport {
-    write(responseData: CommandResult): void;
-    flush(options?: {
-        close?: boolean;
-    }): void;
-    closeAfterFlush(): void;
-}
-
-declare class Resp2Transport {
-    private readonly logger;
-    private readonly commandExecutor;
-    readonly server: Server;
-    constructor(logger: Logger, commandExecutor: DBCommandExecutor);
-    private handleConnection;
-    listen(port?: number): Promise<void>;
-    close(): Promise<void>;
-    getAddress(): string;
-}
-
-interface LuaCommandContext {
-    luaCommands?: Record<string, Command>;
-    signal: AbortSignal;
-}
-declare class LuaRuntime {
-    private readonly hostState;
-    private engine;
-    constructor(module: LuaWasmModule);
-    eval(script: Buffer, ctx: LuaCommandContext, sha: string): ReplyValue;
-    evalWithArgs(script: Buffer, keys: Buffer[], args: Buffer[], ctx: LuaCommandContext, sha: string): ReplyValue;
-    private runLuaCommand;
-}
-
-declare function createCustomCommander(logger: Logger): Promise<CustomCommanderFactory>;
-declare class CustomCommanderFactory {
-    private readonly logger;
-    private readonly luaRuntime;
-    private readonly db;
-    constructor(logger: Logger, luaRuntime: LuaRuntime);
-    shutdown(): Promise<void>;
-    createCommander(): DBCommandExecutor;
-}
-
-declare class HashDataType {
-    private readonly data;
-    constructor();
-    hset(field: Buffer, value: Buffer): number;
-    hget(field: Buffer): Buffer | null;
-    hdel(field: Buffer): number;
-    hexists(field: Buffer): boolean;
-    hgetall(): Buffer[];
-    hkeys(): Buffer[];
-    hvals(): Buffer[];
-    hlen(): number;
-    hmget(fields: Buffer[]): (Buffer | null)[];
-    hincrby(field: Buffer, increment: number): number;
-    hincrbyfloat(field: Buffer, increment: number): number;
-}
-
-declare class ListDataType {
-    private readonly data;
-    constructor();
-    lpush(value: Buffer): number;
-    rpush(value: Buffer): number;
-    lpop(): Buffer | null;
-    rpop(): Buffer | null;
-    llen(): number;
-    lindex(index: number): Buffer | null;
-    lrange(start: number, stop: number): Buffer[];
-    lset(index: number, value: Buffer): boolean;
-    lrem(count: number, value: Buffer): number;
-    ltrim(start: number, stop: number): void;
-}
-
-declare class SetDataType {
-    private readonly data;
-    constructor();
-    sadd(value: Buffer): number;
-    srem(value: Buffer): number;
-    sismember(value: Buffer): boolean;
-    smembers(): Buffer[];
-    scard(): number;
-    spop(): Buffer | null;
-    srandmember(count?: number): Buffer | Buffer[] | null;
-    sdiff(otherSets: SetDataType[]): Buffer[];
-    sinter(otherSets: SetDataType[]): Buffer[];
-    sunion(otherSets: SetDataType[]): Buffer[];
-    smove(destination: SetDataType, member: Buffer): boolean;
-}
-
-declare class StreamDataType {
-}
-
-declare class StringDataType {
-    readonly data: Buffer;
-    constructor(data: Buffer);
-}
-
-declare class SortedSetDataType {
-    private readonly memberToScore;
-    private readonly scoreToMembers;
-    zadd(score: number, member: Buffer): number;
-    zrem(member: Buffer): number;
-    zscore(member: Buffer): number | null;
-    zcard(): number;
-    zrange(start: number, stop: number, withScores?: boolean): Buffer[];
-    zrevrange(start: number, stop: number, withScores?: boolean): Buffer[];
-    zincrby(member: Buffer, increment: number): number;
-    zrank(member: Buffer): number | null;
-    zrevrank(member: Buffer): number | null;
-    zrangebyscore(min: number, max: number): Buffer[];
-    zremrangebyscore(min: number, max: number): number;
-    private getSortedMembers;
-}
-
-type DataTypes = HashDataType | ListDataType | SetDataType | StreamDataType | StringDataType | SortedSetDataType;
-/**
- * Store event types emitted by the reactive data store
- */
-type StoreEvent = {
-    type: 'set';
-    key: Buffer;
-    value: DataTypes;
-} | {
-    type: 'del';
-    key: Buffer;
-} | {
-    type: 'expire';
-    key: Buffer;
-    expiration: number;
-} | {
-    type: 'evict';
-    key: Buffer;
-} | {
-    type: 'flush';
-};
-/**
- * Event names emitted by the store:
- * - 'change': Emitted on every mutation with StoreEvent payload
- * - 'key:<keyString>': Emitted for key-specific changes (for WATCH)
- */
-interface StoreEvents {
-    change: [event: StoreEvent];
-    [key: `key:${string}`]: [event: StoreEvent];
-}
-declare class DB extends EventEmitter<StoreEvents> {
-    private readonly mapping;
-    private readonly timings;
-    private readonly data;
-    private readonly scriptsStore;
-    constructor();
-    tryEvict(key: Buffer): boolean;
-    get(rawKey: Buffer): DataTypes | null;
-    set(rawKey: Buffer, val: DataTypes, expiration?: number): void;
-    del(rawKey: Buffer): boolean;
-    addScript(script: Buffer): string;
-    getScript(sha: string): Buffer | undefined;
-    flushScripts(): void;
-    getTtl(rawKey: Buffer): number;
-    setExpiration(rawKey: Buffer, expiration: number): boolean;
-    /**
-     * Remove all keys from the current database
-     */
-    flushdb(): void;
-    /**
-     * Remove all keys from all databases (same as flushdb in single-database implementation)
-     */
-    flushall(): void;
-    /**
-     * Get the number of keys in the current database
-     * This excludes expired keys
-     */
-    size(): number;
-}
-
-declare function createCustomClusterCommander(logger: Logger, discoveryService: DiscoveryService): Promise<ClusterCommanderFactory>;
-
-declare function computeSlotRange(index: number, masters: number): SlotRange;
-declare class ClusterNetwork implements DiscoveryService {
-    private readonly logger;
-    private readonly slotMapping;
-    private readonly transports;
-    private commanderFactory?;
-    constructor(logger: Logger);
-    private resolveAddress;
-    private createMasterId;
-    private createReplicaId;
-    getMaster(id: string): DiscoveryNode;
-    isMaster(id: string): boolean;
-    getById(id: string): DiscoveryNode;
-    getAll(): DiscoveryNode[];
-    getBySlot(slot: number): DiscoveryNode;
-    init(params: {
-        masters: number;
-        slaves: number;
-        basePort?: number;
-    }): Promise<void>;
-    shutdown(): Promise<void>;
-}
-
-export { ClusterNetwork, CustomCommanderFactory, DB, Resp2Transport, UnknownCommand, UserFacedError, computeSlotRange, createCustomClusterCommander, createCustomCommander };
-export type { ClusterCommanderFactory, Command, CommandResult, DBCommandExecutor, DiscoveryNode, DiscoveryService, ExecutionContext, Logger, SlotRange, Transport };
+export type { CommandCapabilities, CommandExecutionResult, CommandFlag, CommandDefinition, CommandPlan, } from './core/command-definition';
+export type { CommandSchema, InferSchema, ParseContext, ParseNodeResult, } from './core/command-schema';
+export type { RedisClientSession, ClientSessionMode, ParkHandler, ParkRequest, RedisExecutionContext, } from './core/redis-context';
+export type { ExpirationState, KeyspaceEntry, RedisClusterNode, RedisClusterNodeRole, RedisDataTypeName, RedisDataValue, RedisHashData, RedisHashField, RedisListData, RedisMutationEvent, RedisMutationListener, RedisServerStateOptions, RedisSetData, RedisSortedSetData, RedisSortedSetMember, RedisStreamData, RedisStringData, SetOptions, Unsubscribe, } from './state';
+export type { RedisResultOptions } from './core/redis-result';
+export type { RespEncodeOptions, RespVersion } from './core/resp-encoder';
+export type { ResponseStream } from './core/response-stream';
+export type { RedisTurnHandle, RedisTurnQueue } from './core/turn-queue';
+export type { Logger } from './logger';
+export type { ClientSessionOptions } from './core/client-session';
+export type { ConnectionTransport, ConnectionTransportEvent, ConnectionTransportListener, ConnectionTransportUnsubscribe, } from './core/transports/connection-transport';
+export type { SocketConnectionTransportOptions } from './core/transports/socket-connection-transport';
+export type { Resp2CommandFrame, Resp2SessionAdapterOptions, } from './core/transports/resp2';
+export { ClientSession } from './core/client-session';
+export { CommandExecutor, type ExecutorResult } from './core/command-executor';
+export { CommandRegistry } from './core/command-registry';
+export { defineCommand } from './core/command-definition';
+export { t, parseCommandArgs } from './core/command-schema';
+export { ExpectedFloatError, ExpectedIntegerError, DiscardWithoutMultiError, ExecWithoutMultiError, InvalidExpireTimeError, MinMaxNotFloatError, NoScriptError, OffsetOutOfRangeError, PositiveCountError, RedisClusterDownError, RedisCrossSlotError, RedisCommandError, RedisMovedError, ScriptDebugModeError, ScriptCallNoCommandError, ScriptFlushOptionError, ScriptUnknownCommandError, RedisSyntaxError, TransactionDiscardedError, UnknownClusterSubcommandError, UnknownRedisCommandError, UnknownScriptSubcommandError, WatchInsideMultiError, WrongNumberOfKeysError, WrongNumberOfArgumentsError, WrongTypeRedisError, IndexOutOfRangeError, NoSuchKeyError, HashValueNotIntegerError, HashValueNotFloatError, NoAuthError, NoPasswordConfiguredError, WrongPassError, ZaddGtLtNxConflictError, ZaddIncrPairError, ZaddNxXxConflictError, } from './core/redis-error';
+export { createAuthPolicy, createClusterPolicy, createTransactionPolicy, } from './core/execution-policies';
+export { createDefaultParkHandler, createNoopParkHandler, } from './core/redis-context';
+export { RedisLuaRuntime, createRedisLuaRuntime, getDefaultRedisLuaRuntime, luaReplyToRedisValue, type LuaReplyValue, } from './core/lua-runtime';
+export { RedisValue } from './core/redis-value';
+export { RedisResult } from './core/redis-result';
+export { encodeRedisResult, encodeRedisValue } from './core/resp-encoder';
+export { isResponseStream } from './core/response-stream';
+export { SerialTurnQueue } from './core/turn-queue';
+export { REDIS_CLUSTER_SLOT_COUNT, RedisClusterTopology, RedisDatabase, RedisKeyspace, RedisMutationBus, RedisPubSubBroker, RedisScriptCache, RedisServerState, WrongRedisTypeError, cloneRedisDataValue, createHashData, createListData, createSetData, createSortedSetData, createStringData, } from './state';
+export { connectionCommands, createRedisCommandExecutor, createRedisCommandRegistry, commandCommand, copyCommand, createClusterCommand, createClusterCommands, dbsizeCommand, delCommand, discardCommand, existsCommand, evalCommand, evalshaCommand, execCommand, expireCommand, expiretimeCommand, pexpiretimeCommand, flushallCommand, flushdbCommand, getCommand, hscanCommand, keysCommand, keysCommands, mgetCommand, multiCommand, persistCommand, pexpireCommand, pingCommand, pttlCommand, quitCommand, readonlyCommand, readwriteCommand, redisCommandDefinitions, scanCommand, scanCommands, selectCommand, setCommand, scriptCommand, scriptsCommands, sscanCommand, stringsCommands, transactionCommands, ttlCommand, typeCommand, unwatchCommand, watchCommand, zscanCommand, } from './commands';
+export { Resp2CommandDecoder, Resp2ParseError, Resp2SessionAdapter, } from './core/transports/resp2';
+export { Resp2Server, type Resp2ServerOptions, } from './core/transports/resp2/server';
+export { InMemoryConnectionTransport } from './core/transports/in-memory-connection-transport';
+export { SocketConnectionTransport } from './core/transports/socket-connection-transport';
+export { RedisCluster, buildRedisCluster, computeSlotRange, type RedisClusterNodeHandle, type RedisClusterOptions, } from './cluster';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,YAAY,EACV,OAAO,EACP,aAAa,EACb,iBAAiB,EACjB,gBAAgB,EAChB,MAAM,EACN,SAAS,EACT,aAAa,EACb,gBAAgB,EAChB,uBAAuB,EACvB,SAAS,GACV,MAAM,SAAS,CAAA;AAGhB,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAG9D,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAGxD,OAAO,EACL,qBAAqB,EACrB,sBAAsB,GACvB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,4BAA4B,EAAE,MAAM,sCAAsC,CAAA;AAGnF,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAGzE,OAAO,EAAE,EAAE,EAAE,MAAM,wBAAwB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultRedisLuaRuntime = exports.createRedisLuaRuntime = exports.RedisLuaRuntime = exports.createNoopParkHandler = exports.createDefaultParkHandler = exports.createTransactionPolicy = exports.createClusterPolicy = exports.createAuthPolicy = exports.ZaddNxXxConflictError = exports.ZaddIncrPairError = exports.ZaddGtLtNxConflictError = exports.WrongPassError = exports.NoPasswordConfiguredError = exports.NoAuthError = exports.HashValueNotFloatError = exports.HashValueNotIntegerError = exports.NoSuchKeyError = exports.IndexOutOfRangeError = exports.WrongTypeRedisError = exports.WrongNumberOfArgumentsError = exports.WrongNumberOfKeysError = exports.WatchInsideMultiError = exports.UnknownScriptSubcommandError = exports.UnknownRedisCommandError = exports.UnknownClusterSubcommandError = exports.TransactionDiscardedError = exports.RedisSyntaxError = exports.ScriptUnknownCommandError = exports.ScriptFlushOptionError = exports.ScriptCallNoCommandError = exports.ScriptDebugModeError = exports.RedisMovedError = exports.RedisCommandError = exports.RedisCrossSlotError = exports.RedisClusterDownError = exports.PositiveCountError = exports.OffsetOutOfRangeError = exports.NoScriptError = exports.MinMaxNotFloatError = exports.InvalidExpireTimeError = exports.ExecWithoutMultiError = exports.DiscardWithoutMultiError = exports.ExpectedIntegerError = exports.ExpectedFloatError = exports.parseCommandArgs = exports.t = exports.defineCommand = exports.CommandRegistry = exports.CommandExecutor = exports.ClientSession = void 0;
+exports.pingCommand = exports.pexpireCommand = exports.persistCommand = exports.multiCommand = exports.mgetCommand = exports.keysCommands = exports.keysCommand = exports.hscanCommand = exports.getCommand = exports.flushdbCommand = exports.flushallCommand = exports.pexpiretimeCommand = exports.expiretimeCommand = exports.expireCommand = exports.execCommand = exports.evalshaCommand = exports.evalCommand = exports.existsCommand = exports.discardCommand = exports.delCommand = exports.dbsizeCommand = exports.createClusterCommands = exports.createClusterCommand = exports.copyCommand = exports.commandCommand = exports.createRedisCommandRegistry = exports.createRedisCommandExecutor = exports.connectionCommands = exports.createStringData = exports.createSortedSetData = exports.createSetData = exports.createListData = exports.createHashData = exports.cloneRedisDataValue = exports.WrongRedisTypeError = exports.RedisServerState = exports.RedisScriptCache = exports.RedisPubSubBroker = exports.RedisMutationBus = exports.RedisKeyspace = exports.RedisDatabase = exports.RedisClusterTopology = exports.REDIS_CLUSTER_SLOT_COUNT = exports.SerialTurnQueue = exports.isResponseStream = exports.encodeRedisValue = exports.encodeRedisResult = exports.RedisResult = exports.RedisValue = exports.luaReplyToRedisValue = void 0;
+exports.computeSlotRange = exports.buildRedisCluster = exports.RedisCluster = exports.SocketConnectionTransport = exports.InMemoryConnectionTransport = exports.Resp2Server = exports.Resp2SessionAdapter = exports.Resp2ParseError = exports.Resp2CommandDecoder = exports.zscanCommand = exports.watchCommand = exports.unwatchCommand = exports.typeCommand = exports.ttlCommand = exports.transactionCommands = exports.stringsCommands = exports.sscanCommand = exports.scriptsCommands = exports.scriptCommand = exports.setCommand = exports.selectCommand = exports.scanCommands = exports.scanCommand = exports.redisCommandDefinitions = exports.readwriteCommand = exports.readonlyCommand = exports.quitCommand = exports.pttlCommand = void 0;
+var client_session_1 = require("./core/client-session");
+Object.defineProperty(exports, "ClientSession", { enumerable: true, get: function () { return client_session_1.ClientSession; } });
+var command_executor_1 = require("./core/command-executor");
+Object.defineProperty(exports, "CommandExecutor", { enumerable: true, get: function () { return command_executor_1.CommandExecutor; } });
+var command_registry_1 = require("./core/command-registry");
+Object.defineProperty(exports, "CommandRegistry", { enumerable: true, get: function () { return command_registry_1.CommandRegistry; } });
+var command_definition_1 = require("./core/command-definition");
+Object.defineProperty(exports, "defineCommand", { enumerable: true, get: function () { return command_definition_1.defineCommand; } });
+var command_schema_1 = require("./core/command-schema");
+Object.defineProperty(exports, "t", { enumerable: true, get: function () { return command_schema_1.t; } });
+Object.defineProperty(exports, "parseCommandArgs", { enumerable: true, get: function () { return command_schema_1.parseCommandArgs; } });
+var redis_error_1 = require("./core/redis-error");
+Object.defineProperty(exports, "ExpectedFloatError", { enumerable: true, get: function () { return redis_error_1.ExpectedFloatError; } });
+Object.defineProperty(exports, "ExpectedIntegerError", { enumerable: true, get: function () { return redis_error_1.ExpectedIntegerError; } });
+Object.defineProperty(exports, "DiscardWithoutMultiError", { enumerable: true, get: function () { return redis_error_1.DiscardWithoutMultiError; } });
+Object.defineProperty(exports, "ExecWithoutMultiError", { enumerable: true, get: function () { return redis_error_1.ExecWithoutMultiError; } });
+Object.defineProperty(exports, "InvalidExpireTimeError", { enumerable: true, get: function () { return redis_error_1.InvalidExpireTimeError; } });
+Object.defineProperty(exports, "MinMaxNotFloatError", { enumerable: true, get: function () { return redis_error_1.MinMaxNotFloatError; } });
+Object.defineProperty(exports, "NoScriptError", { enumerable: true, get: function () { return redis_error_1.NoScriptError; } });
+Object.defineProperty(exports, "OffsetOutOfRangeError", { enumerable: true, get: function () { return redis_error_1.OffsetOutOfRangeError; } });
+Object.defineProperty(exports, "PositiveCountError", { enumerable: true, get: function () { return redis_error_1.PositiveCountError; } });
+Object.defineProperty(exports, "RedisClusterDownError", { enumerable: true, get: function () { return redis_error_1.RedisClusterDownError; } });
+Object.defineProperty(exports, "RedisCrossSlotError", { enumerable: true, get: function () { return redis_error_1.RedisCrossSlotError; } });
+Object.defineProperty(exports, "RedisCommandError", { enumerable: true, get: function () { return redis_error_1.RedisCommandError; } });
+Object.defineProperty(exports, "RedisMovedError", { enumerable: true, get: function () { return redis_error_1.RedisMovedError; } });
+Object.defineProperty(exports, "ScriptDebugModeError", { enumerable: true, get: function () { return redis_error_1.ScriptDebugModeError; } });
+Object.defineProperty(exports, "ScriptCallNoCommandError", { enumerable: true, get: function () { return redis_error_1.ScriptCallNoCommandError; } });
+Object.defineProperty(exports, "ScriptFlushOptionError", { enumerable: true, get: function () { return redis_error_1.ScriptFlushOptionError; } });
+Object.defineProperty(exports, "ScriptUnknownCommandError", { enumerable: true, get: function () { return redis_error_1.ScriptUnknownCommandError; } });
+Object.defineProperty(exports, "RedisSyntaxError", { enumerable: true, get: function () { return redis_error_1.RedisSyntaxError; } });
+Object.defineProperty(exports, "TransactionDiscardedError", { enumerable: true, get: function () { return redis_error_1.TransactionDiscardedError; } });
+Object.defineProperty(exports, "UnknownClusterSubcommandError", { enumerable: true, get: function () { return redis_error_1.UnknownClusterSubcommandError; } });
+Object.defineProperty(exports, "UnknownRedisCommandError", { enumerable: true, get: function () { return redis_error_1.UnknownRedisCommandError; } });
+Object.defineProperty(exports, "UnknownScriptSubcommandError", { enumerable: true, get: function () { return redis_error_1.UnknownScriptSubcommandError; } });
+Object.defineProperty(exports, "WatchInsideMultiError", { enumerable: true, get: function () { return redis_error_1.WatchInsideMultiError; } });
+Object.defineProperty(exports, "WrongNumberOfKeysError", { enumerable: true, get: function () { return redis_error_1.WrongNumberOfKeysError; } });
+Object.defineProperty(exports, "WrongNumberOfArgumentsError", { enumerable: true, get: function () { return redis_error_1.WrongNumberOfArgumentsError; } });
+Object.defineProperty(exports, "WrongTypeRedisError", { enumerable: true, get: function () { return redis_error_1.WrongTypeRedisError; } });
+Object.defineProperty(exports, "IndexOutOfRangeError", { enumerable: true, get: function () { return redis_error_1.IndexOutOfRangeError; } });
+Object.defineProperty(exports, "NoSuchKeyError", { enumerable: true, get: function () { return redis_error_1.NoSuchKeyError; } });
+Object.defineProperty(exports, "HashValueNotIntegerError", { enumerable: true, get: function () { return redis_error_1.HashValueNotIntegerError; } });
+Object.defineProperty(exports, "HashValueNotFloatError", { enumerable: true, get: function () { return redis_error_1.HashValueNotFloatError; } });
+Object.defineProperty(exports, "NoAuthError", { enumerable: true, get: function () { return redis_error_1.NoAuthError; } });
+Object.defineProperty(exports, "NoPasswordConfiguredError", { enumerable: true, get: function () { return redis_error_1.NoPasswordConfiguredError; } });
+Object.defineProperty(exports, "WrongPassError", { enumerable: true, get: function () { return redis_error_1.WrongPassError; } });
+Object.defineProperty(exports, "ZaddGtLtNxConflictError", { enumerable: true, get: function () { return redis_error_1.ZaddGtLtNxConflictError; } });
+Object.defineProperty(exports, "ZaddIncrPairError", { enumerable: true, get: function () { return redis_error_1.ZaddIncrPairError; } });
+Object.defineProperty(exports, "ZaddNxXxConflictError", { enumerable: true, get: function () { return redis_error_1.ZaddNxXxConflictError; } });
+var execution_policies_1 = require("./core/execution-policies");
+Object.defineProperty(exports, "createAuthPolicy", { enumerable: true, get: function () { return execution_policies_1.createAuthPolicy; } });
+Object.defineProperty(exports, "createClusterPolicy", { enumerable: true, get: function () { return execution_policies_1.createClusterPolicy; } });
+Object.defineProperty(exports, "createTransactionPolicy", { enumerable: true, get: function () { return execution_policies_1.createTransactionPolicy; } });
+var redis_context_1 = require("./core/redis-context");
+Object.defineProperty(exports, "createDefaultParkHandler", { enumerable: true, get: function () { return redis_context_1.createDefaultParkHandler; } });
+Object.defineProperty(exports, "createNoopParkHandler", { enumerable: true, get: function () { return redis_context_1.createNoopParkHandler; } });
+var lua_runtime_1 = require("./core/lua-runtime");
+Object.defineProperty(exports, "RedisLuaRuntime", { enumerable: true, get: function () { return lua_runtime_1.RedisLuaRuntime; } });
+Object.defineProperty(exports, "createRedisLuaRuntime", { enumerable: true, get: function () { return lua_runtime_1.createRedisLuaRuntime; } });
+Object.defineProperty(exports, "getDefaultRedisLuaRuntime", { enumerable: true, get: function () { return lua_runtime_1.getDefaultRedisLuaRuntime; } });
+Object.defineProperty(exports, "luaReplyToRedisValue", { enumerable: true, get: function () { return lua_runtime_1.luaReplyToRedisValue; } });
+var redis_value_1 = require("./core/redis-value");
+Object.defineProperty(exports, "RedisValue", { enumerable: true, get: function () { return redis_value_1.RedisValue; } });
+var redis_result_1 = require("./core/redis-result");
+Object.defineProperty(exports, "RedisResult", { enumerable: true, get: function () { return redis_result_1.RedisResult; } });
+var resp_encoder_1 = require("./core/resp-encoder");
+Object.defineProperty(exports, "encodeRedisResult", { enumerable: true, get: function () { return resp_encoder_1.encodeRedisResult; } });
+Object.defineProperty(exports, "encodeRedisValue", { enumerable: true, get: function () { return resp_encoder_1.encodeRedisValue; } });
+var response_stream_1 = require("./core/response-stream");
+Object.defineProperty(exports, "isResponseStream", { enumerable: true, get: function () { return response_stream_1.isResponseStream; } });
+var turn_queue_1 = require("./core/turn-queue");
+Object.defineProperty(exports, "SerialTurnQueue", { enumerable: true, get: function () { return turn_queue_1.SerialTurnQueue; } });
+var state_1 = require("./state");
+Object.defineProperty(exports, "REDIS_CLUSTER_SLOT_COUNT", { enumerable: true, get: function () { return state_1.REDIS_CLUSTER_SLOT_COUNT; } });
+Object.defineProperty(exports, "RedisClusterTopology", { enumerable: true, get: function () { return state_1.RedisClusterTopology; } });
+Object.defineProperty(exports, "RedisDatabase", { enumerable: true, get: function () { return state_1.RedisDatabase; } });
+Object.defineProperty(exports, "RedisKeyspace", { enumerable: true, get: function () { return state_1.RedisKeyspace; } });
+Object.defineProperty(exports, "RedisMutationBus", { enumerable: true, get: function () { return state_1.RedisMutationBus; } });
+Object.defineProperty(exports, "RedisPubSubBroker", { enumerable: true, get: function () { return state_1.RedisPubSubBroker; } });
+Object.defineProperty(exports, "RedisScriptCache", { enumerable: true, get: function () { return state_1.RedisScriptCache; } });
+Object.defineProperty(exports, "RedisServerState", { enumerable: true, get: function () { return state_1.RedisServerState; } });
+Object.defineProperty(exports, "WrongRedisTypeError", { enumerable: true, get: function () { return state_1.WrongRedisTypeError; } });
+Object.defineProperty(exports, "cloneRedisDataValue", { enumerable: true, get: function () { return state_1.cloneRedisDataValue; } });
+Object.defineProperty(exports, "createHashData", { enumerable: true, get: function () { return state_1.createHashData; } });
+Object.defineProperty(exports, "createListData", { enumerable: true, get: function () { return state_1.createListData; } });
+Object.defineProperty(exports, "createSetData", { enumerable: true, get: function () { return state_1.createSetData; } });
+Object.defineProperty(exports, "createSortedSetData", { enumerable: true, get: function () { return state_1.createSortedSetData; } });
+Object.defineProperty(exports, "createStringData", { enumerable: true, get: function () { return state_1.createStringData; } });
+var commands_1 = require("./commands");
+Object.defineProperty(exports, "connectionCommands", { enumerable: true, get: function () { return commands_1.connectionCommands; } });
+Object.defineProperty(exports, "createRedisCommandExecutor", { enumerable: true, get: function () { return commands_1.createRedisCommandExecutor; } });
+Object.defineProperty(exports, "createRedisCommandRegistry", { enumerable: true, get: function () { return commands_1.createRedisCommandRegistry; } });
+Object.defineProperty(exports, "commandCommand", { enumerable: true, get: function () { return commands_1.commandCommand; } });
+Object.defineProperty(exports, "copyCommand", { enumerable: true, get: function () { return commands_1.copyCommand; } });
+Object.defineProperty(exports, "createClusterCommand", { enumerable: true, get: function () { return commands_1.createClusterCommand; } });
+Object.defineProperty(exports, "createClusterCommands", { enumerable: true, get: function () { return commands_1.createClusterCommands; } });
+Object.defineProperty(exports, "dbsizeCommand", { enumerable: true, get: function () { return commands_1.dbsizeCommand; } });
+Object.defineProperty(exports, "delCommand", { enumerable: true, get: function () { return commands_1.delCommand; } });
+Object.defineProperty(exports, "discardCommand", { enumerable: true, get: function () { return commands_1.discardCommand; } });
+Object.defineProperty(exports, "existsCommand", { enumerable: true, get: function () { return commands_1.existsCommand; } });
+Object.defineProperty(exports, "evalCommand", { enumerable: true, get: function () { return commands_1.evalCommand; } });
+Object.defineProperty(exports, "evalshaCommand", { enumerable: true, get: function () { return commands_1.evalshaCommand; } });
+Object.defineProperty(exports, "execCommand", { enumerable: true, get: function () { return commands_1.execCommand; } });
+Object.defineProperty(exports, "expireCommand", { enumerable: true, get: function () { return commands_1.expireCommand; } });
+Object.defineProperty(exports, "expiretimeCommand", { enumerable: true, get: function () { return commands_1.expiretimeCommand; } });
+Object.defineProperty(exports, "pexpiretimeCommand", { enumerable: true, get: function () { return commands_1.pexpiretimeCommand; } });
+Object.defineProperty(exports, "flushallCommand", { enumerable: true, get: function () { return commands_1.flushallCommand; } });
+Object.defineProperty(exports, "flushdbCommand", { enumerable: true, get: function () { return commands_1.flushdbCommand; } });
+Object.defineProperty(exports, "getCommand", { enumerable: true, get: function () { return commands_1.getCommand; } });
+Object.defineProperty(exports, "hscanCommand", { enumerable: true, get: function () { return commands_1.hscanCommand; } });
+Object.defineProperty(exports, "keysCommand", { enumerable: true, get: function () { return commands_1.keysCommand; } });
+Object.defineProperty(exports, "keysCommands", { enumerable: true, get: function () { return commands_1.keysCommands; } });
+Object.defineProperty(exports, "mgetCommand", { enumerable: true, get: function () { return commands_1.mgetCommand; } });
+Object.defineProperty(exports, "multiCommand", { enumerable: true, get: function () { return commands_1.multiCommand; } });
+Object.defineProperty(exports, "persistCommand", { enumerable: true, get: function () { return commands_1.persistCommand; } });
+Object.defineProperty(exports, "pexpireCommand", { enumerable: true, get: function () { return commands_1.pexpireCommand; } });
+Object.defineProperty(exports, "pingCommand", { enumerable: true, get: function () { return commands_1.pingCommand; } });
+Object.defineProperty(exports, "pttlCommand", { enumerable: true, get: function () { return commands_1.pttlCommand; } });
+Object.defineProperty(exports, "quitCommand", { enumerable: true, get: function () { return commands_1.quitCommand; } });
+Object.defineProperty(exports, "readonlyCommand", { enumerable: true, get: function () { return commands_1.readonlyCommand; } });
+Object.defineProperty(exports, "readwriteCommand", { enumerable: true, get: function () { return commands_1.readwriteCommand; } });
+Object.defineProperty(exports, "redisCommandDefinitions", { enumerable: true, get: function () { return commands_1.redisCommandDefinitions; } });
+Object.defineProperty(exports, "scanCommand", { enumerable: true, get: function () { return commands_1.scanCommand; } });
+Object.defineProperty(exports, "scanCommands", { enumerable: true, get: function () { return commands_1.scanCommands; } });
+Object.defineProperty(exports, "selectCommand", { enumerable: true, get: function () { return commands_1.selectCommand; } });
+Object.defineProperty(exports, "setCommand", { enumerable: true, get: function () { return commands_1.setCommand; } });
+Object.defineProperty(exports, "scriptCommand", { enumerable: true, get: function () { return commands_1.scriptCommand; } });
+Object.defineProperty(exports, "scriptsCommands", { enumerable: true, get: function () { return commands_1.scriptsCommands; } });
+Object.defineProperty(exports, "sscanCommand", { enumerable: true, get: function () { return commands_1.sscanCommand; } });
+Object.defineProperty(exports, "stringsCommands", { enumerable: true, get: function () { return commands_1.stringsCommands; } });
+Object.defineProperty(exports, "transactionCommands", { enumerable: true, get: function () { return commands_1.transactionCommands; } });
+Object.defineProperty(exports, "ttlCommand", { enumerable: true, get: function () { return commands_1.ttlCommand; } });
+Object.defineProperty(exports, "typeCommand", { enumerable: true, get: function () { return commands_1.typeCommand; } });
+Object.defineProperty(exports, "unwatchCommand", { enumerable: true, get: function () { return commands_1.unwatchCommand; } });
+Object.defineProperty(exports, "watchCommand", { enumerable: true, get: function () { return commands_1.watchCommand; } });
+Object.defineProperty(exports, "zscanCommand", { enumerable: true, get: function () { return commands_1.zscanCommand; } });
+// Transport
+var resp2_1 = require("./core/transports/resp2");
+Object.defineProperty(exports, "Resp2CommandDecoder", { enumerable: true, get: function () { return resp2_1.Resp2CommandDecoder; } });
+Object.defineProperty(exports, "Resp2ParseError", { enumerable: true, get: function () { return resp2_1.Resp2ParseError; } });
+Object.defineProperty(exports, "Resp2SessionAdapter", { enumerable: true, get: function () { return resp2_1.Resp2SessionAdapter; } });
+var server_1 = require("./core/transports/resp2/server");
+Object.defineProperty(exports, "Resp2Server", { enumerable: true, get: function () { return server_1.Resp2Server; } });
+var in_memory_connection_transport_1 = require("./core/transports/in-memory-connection-transport");
+Object.defineProperty(exports, "InMemoryConnectionTransport", { enumerable: true, get: function () { return in_memory_connection_transport_1.InMemoryConnectionTransport; } });
+var socket_connection_transport_1 = require("./core/transports/socket-connection-transport");
+Object.defineProperty(exports, "SocketConnectionTransport", { enumerable: true, get: function () { return socket_connection_transport_1.SocketConnectionTransport; } });
+// Cluster builder (new core)
+var cluster_1 = require("./cluster");
+Object.defineProperty(exports, "RedisCluster", { enumerable: true, get: function () { return cluster_1.RedisCluster; } });
+Object.defineProperty(exports, "buildRedisCluster", { enumerable: true, get: function () { return cluster_1.buildRedisCluster; } });
+Object.defineProperty(exports, "computeSlotRange", { enumerable: true, get: function () { return cluster_1.computeSlotRange; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;AA+DA,wDAAqD;AAA5C,+GAAA,aAAa,OAAA;AACtB,4DAA8E;AAArE,mHAAA,eAAe,OAAA;AACxB,4DAAyD;AAAhD,mHAAA,eAAe,OAAA;AACxB,gEAAyD;AAAhD,mHAAA,aAAa,OAAA;AACtB,wDAA2D;AAAlD,mGAAA,CAAC,OAAA;AAAE,kHAAA,gBAAgB,OAAA;AAC5B,kDAqC2B;AApCzB,iHAAA,kBAAkB,OAAA;AAClB,mHAAA,oBAAoB,OAAA;AACpB,uHAAA,wBAAwB,OAAA;AACxB,oHAAA,qBAAqB,OAAA;AACrB,qHAAA,sBAAsB,OAAA;AACtB,kHAAA,mBAAmB,OAAA;AACnB,4GAAA,aAAa,OAAA;AACb,oHAAA,qBAAqB,OAAA;AACrB,iHAAA,kBAAkB,OAAA;AAClB,oHAAA,qBAAqB,OAAA;AACrB,kHAAA,mBAAmB,OAAA;AACnB,gHAAA,iBAAiB,OAAA;AACjB,8GAAA,eAAe,OAAA;AACf,mHAAA,oBAAoB,OAAA;AACpB,uHAAA,wBAAwB,OAAA;AACxB,qHAAA,sBAAsB,OAAA;AACtB,wHAAA,yBAAyB,OAAA;AACzB,+GAAA,gBAAgB,OAAA;AAChB,wHAAA,yBAAyB,OAAA;AACzB,4HAAA,6BAA6B,OAAA;AAC7B,uHAAA,wBAAwB,OAAA;AACxB,2HAAA,4BAA4B,OAAA;AAC5B,oHAAA,qBAAqB,OAAA;AACrB,qHAAA,sBAAsB,OAAA;AACtB,0HAAA,2BAA2B,OAAA;AAC3B,kHAAA,mBAAmB,OAAA;AACnB,mHAAA,oBAAoB,OAAA;AACpB,6GAAA,cAAc,OAAA;AACd,uHAAA,wBAAwB,OAAA;AACxB,qHAAA,sBAAsB,OAAA;AACtB,0GAAA,WAAW,OAAA;AACX,wHAAA,yBAAyB,OAAA;AACzB,6GAAA,cAAc,OAAA;AACd,sHAAA,uBAAuB,OAAA;AACvB,gHAAA,iBAAiB,OAAA;AACjB,oHAAA,qBAAqB,OAAA;AAEvB,gEAIkC;AAHhC,sHAAA,gBAAgB,OAAA;AAChB,yHAAA,mBAAmB,OAAA;AACnB,6HAAA,uBAAuB,OAAA;AAEzB,sDAG6B;AAF3B,yHAAA,wBAAwB,OAAA;AACxB,sHAAA,qBAAqB,OAAA;AAEvB,kDAM2B;AALzB,8GAAA,eAAe,OAAA;AACf,oHAAA,qBAAqB,OAAA;AACrB,wHAAA,yBAAyB,OAAA;AACzB,mHAAA,oBAAoB,OAAA;AAGtB,kDAA+C;AAAtC,yGAAA,UAAU,OAAA;AACnB,oDAAiD;AAAxC,2GAAA,WAAW,OAAA;AACpB,oDAAyE;AAAhE,iHAAA,iBAAiB,OAAA;AAAE,gHAAA,gBAAgB,OAAA;AAC5C,0DAAyD;AAAhD,mHAAA,gBAAgB,OAAA;AACzB,gDAAmD;AAA1C,6GAAA,eAAe,OAAA;AACxB,iCAgBgB;AAfd,iHAAA,wBAAwB,OAAA;AACxB,6GAAA,oBAAoB,OAAA;AACpB,sGAAA,aAAa,OAAA;AACb,sGAAA,aAAa,OAAA;AACb,yGAAA,gBAAgB,OAAA;AAChB,0GAAA,iBAAiB,OAAA;AACjB,yGAAA,gBAAgB,OAAA;AAChB,yGAAA,gBAAgB,OAAA;AAChB,4GAAA,mBAAmB,OAAA;AACnB,4GAAA,mBAAmB,OAAA;AACnB,uGAAA,cAAc,OAAA;AACd,uGAAA,cAAc,OAAA;AACd,sGAAA,aAAa,OAAA;AACb,4GAAA,mBAAmB,OAAA;AACnB,yGAAA,gBAAgB,OAAA;AAElB,uCAgDmB;AA/CjB,8GAAA,kBAAkB,OAAA;AAClB,sHAAA,0BAA0B,OAAA;AAC1B,sHAAA,0BAA0B,OAAA;AAC1B,0GAAA,cAAc,OAAA;AACd,uGAAA,WAAW,OAAA;AACX,gHAAA,oBAAoB,OAAA;AACpB,iHAAA,qBAAqB,OAAA;AACrB,yGAAA,aAAa,OAAA;AACb,sGAAA,UAAU,OAAA;AACV,0GAAA,cAAc,OAAA;AACd,yGAAA,aAAa,OAAA;AACb,uGAAA,WAAW,OAAA;AACX,0GAAA,cAAc,OAAA;AACd,uGAAA,WAAW,OAAA;AACX,yGAAA,aAAa,OAAA;AACb,6GAAA,iBAAiB,OAAA;AACjB,8GAAA,kBAAkB,OAAA;AAClB,2GAAA,eAAe,OAAA;AACf,0GAAA,cAAc,OAAA;AACd,sGAAA,UAAU,OAAA;AACV,wGAAA,YAAY,OAAA;AACZ,uGAAA,WAAW,OAAA;AACX,wGAAA,YAAY,OAAA;AACZ,uGAAA,WAAW,OAAA;AACX,wGAAA,YAAY,OAAA;AACZ,0GAAA,cAAc,OAAA;AACd,0GAAA,cAAc,OAAA;AACd,uGAAA,WAAW,OAAA;AACX,uGAAA,WAAW,OAAA;AACX,uGAAA,WAAW,OAAA;AACX,2GAAA,eAAe,OAAA;AACf,4GAAA,gBAAgB,OAAA;AAChB,mHAAA,uBAAuB,OAAA;AACvB,uGAAA,WAAW,OAAA;AACX,wGAAA,YAAY,OAAA;AACZ,yGAAA,aAAa,OAAA;AACb,sGAAA,UAAU,OAAA;AACV,yGAAA,aAAa,OAAA;AACb,2GAAA,eAAe,OAAA;AACf,wGAAA,YAAY,OAAA;AACZ,2GAAA,eAAe,OAAA;AACf,+GAAA,mBAAmB,OAAA;AACnB,sGAAA,UAAU,OAAA;AACV,uGAAA,WAAW,OAAA;AACX,0GAAA,cAAc,OAAA;AACd,wGAAA,YAAY,OAAA;AACZ,wGAAA,YAAY,OAAA;AAGd,YAAY;AACZ,iDAIgC;AAH9B,4GAAA,mBAAmB,OAAA;AACnB,wGAAA,eAAe,OAAA;AACf,4GAAA,mBAAmB,OAAA;AAErB,yDAGuC;AAFrC,qGAAA,WAAW,OAAA;AAGb,mGAA8F;AAArF,6IAAA,2BAA2B,OAAA;AACpC,6FAAyF;AAAhF,wIAAA,yBAAyB,OAAA;AAElC,6BAA6B;AAC7B,qCAMkB;AALhB,uGAAA,YAAY,OAAA;AACZ,4GAAA,iBAAiB,OAAA;AACjB,2GAAA,gBAAgB,OAAA"}

package/dist/logger.d.ts

@@ -0,0 +1,6 @@
+export interface Logger {
+    info(msg: unknown, metadata?: Record<string, unknown>): void;
+    error(msg: unknown, metadata?: Record<string, unknown>): void;
+    debug(msg: unknown, metadata?: Record<string, unknown>): void;
+}
+//# sourceMappingURL=logger.d.ts.map