@valkey/valkey-glide 2.4.2 → 2.5.0-rc2

package/build-ts/Commands.d.ts

@@ -3,6 +3,7 @@
  */
 import { GlideString, HashDataType, ObjectType } from "./BaseClient";
 import { SingleNodeRoute } from "./GlideClusterClient";
+import { command_request } from "../build-ts/ProtobufMessage";
 /**
  * @test
  */
@@ -131,6 +132,18 @@ export declare enum InfoOptions {
      */
     Everything = "everything"
 }
+/**
+ * Defines the pause mode for {@link GlideClient.clientPause} and
+ *      {@link GlideClusterClient.clientPause} commands.
+ *
+ * @see {@link https://valkey.io/commands/client-pause/|valkey.io} for details.
+ */
+export declare enum ClientPauseMode {
+    /** Pause all client commands. */
+    ALL = "ALL",
+    /** Pause client write commands. */
+    WRITE = "WRITE"
+}
 /**
  * This function converts an input from {@link HashDataType} or `Record` types to `HashDataType`.
  *
@@ -737,6 +750,20 @@ export interface LolwutOptions {
      */
     parameters?: number[];
 }
+/**
+ * Optional arguments for the {@link BaseClient.migrate} command.
+ */
+export interface MigrateOptions {
+    /** If true, do not remove the key from the source instance. */
+    copy?: boolean;
+    /** If true, replace the existing key on the destination instance. */
+    replace?: boolean;
+    /** Authentication password for the destination instance. */
+    password?: string;
+    /** Authentication username for the destination instance (requires password). */
+    username?: string;
+}
+export declare function createMigrate(host: string, port: number, key: GlideString | GlideString[], destinationDB: number, timeout: number, options?: MigrateOptions): command_request.Command;
 /**
  * Optional arguments for `RESTORE` command.
  *
@@ -1129,6 +1156,46 @@ export interface Limit {
     /** The maximum number of elements to include in the range. A negative count returns all elements from the offset. */
     count: number;
 }
+/**
+ * Represents the time and latency for a latency spike.
+ */
+export declare class LatencyEntry {
+    /** The time of the latency spike, as a Unix timestamp in seconds. */
+    readonly time: number;
+    /** The duration of the latency spike, in milliseconds. */
+    readonly latency: number;
+}
+/**
+ * Represents information about an event's latency spike time series.
+ */
+export declare class LatencyEventInfo {
+    /** The name of the event. */
+    readonly eventName: string;
+    /** The time of the latest latency spike, as a Unix timestamp in seconds. */
+    readonly latestTime: number;
+    /** The duration of the latest latency spike, in milliseconds. */
+    readonly latestDuration: number;
+    /** The all-time maximum duration of a latency spike, in milliseconds. */
+    readonly maxDuration: number;
+    /** The sum of all latency spike durations in the event's time series, in milliseconds. Only populated for Valkey 8.1+. */
+    readonly sum?: number;
+    /** The number of latency spikes recorded in the event's time series. Only populated for Valkey 8.1+. */
+    readonly count?: number;
+}
+/**
+ * Represents a `CLIENT TRACKINGINFO` response.
+ *
+ * @see {@link https://valkey.io/commands/client-trackinginfo/|valkey.io} for details.
+ */
+export declare class ClientTrackingInfo {
+    /** Set of tracking flags. */
+    readonly flags: Set<string>;
+    /** Client ID receiving invalidation messages, or -1 if not redirecting. */
+    readonly redirect: number;
+    /** Set of key prefixes monitored for invalidation. */
+    readonly prefixes: Set<string>;
+    constructor(flags: Set<string>, redirect: number, prefixes: Set<string>);
+}
 /**
  * This base class represents the common set of optional arguments for the SCAN family of commands.
  * Concrete implementations of this class are tied to specific SCAN commands (`SCAN`, `SSCAN`).
@@ -1216,6 +1283,22 @@ export declare enum TimeUnit {
      */
     UnixMilliseconds = "PXAT"
 }
+/**
+ * Options for the FAILOVER command.
+ * @see {@link https://valkey.io/commands/failover/|valkey.io} for details.
+ */
+export interface FailoverOptions {
+    /** Target replica to failover to. If `force` is true, forces failover after timeout. */
+    to?: {
+        host: string;
+        port: number;
+        force?: boolean;
+    };
+    /** Abort an ongoing failover. */
+    abort?: boolean;
+    /** Timeout in milliseconds. */
+    timeoutMs?: number;
+}
 /**
  * Base options settings class for sending a batch request. Shared settings for standalone and
  * cluster batch requests.
@@ -1390,4 +1473,100 @@ export interface ClusterBatchRetryStrategy {
      */
     retryConnectionError: boolean;
 }
+/**
+ * Database memory overhead statistics from MEMORY STATS.
+ */
+export interface MemoryStatsDb {
+    /** Overhead of the expires dictionary hashtable. */
+    overheadHashtableExpires: number;
+    /** Overhead of the main dictionary hashtable. */
+    overheadHashtableMain: number;
+}
+/**
+ * Represents a MEMORY STATS response.
+ */
+export interface MemoryStats {
+    /** Per-database overhead keyed by database index. */
+    db: Record<number, MemoryStatsDb>;
+    /** Bytes active (in use) by the allocator. */
+    allocatorActive: number;
+    /** Bytes allocated by the allocator. */
+    allocatorAllocated: number;
+    /** Bytes of allocator fragmentation. */
+    allocatorFragmentationBytes: number;
+    /** Bytes resident (RSS) by the allocator. */
+    allocatorResident: number;
+    /** Bytes of allocator RSS overhead. */
+    allocatorRssBytes: number;
+    /** Memory used for AOF buffer in bytes. */
+    aofBuffer: number;
+    /** Memory used by normal clients in bytes. */
+    clientsNormal: number;
+    /** Memory used by replica clients in bytes. */
+    clientsSlaves: number;
+    /** Memory used to store dataset in bytes. */
+    datasetBytes: number;
+    /** Bytes of overall fragmentation. */
+    fragmentationBytes: number;
+    /** Average bytes per key. */
+    keysBytesPerKey: number;
+    /** Total number of keys across all databases. */
+    keysCount: number;
+    /** Memory used by Lua caches in bytes. */
+    luaCaches: number;
+    /** Total memory overhead in bytes. */
+    overheadTotal: number;
+    /** Peak memory consumed by the server in bytes. */
+    peakAllocated: number;
+    /** Memory used for replication backlog in bytes. */
+    replicationBacklog: number;
+    /** Bytes of RSS overhead. */
+    rssOverheadBytes: number;
+    /** Memory consumed at startup in bytes. */
+    startupAllocated: number;
+    /** Total bytes allocated by the server. */
+    totalAllocated: number;
+    /** Ratio of allocator fragmentation. */
+    allocatorFragmentationRatio: number;
+    /** Ratio of allocator RSS overhead. */
+    allocatorRssRatio: number;
+    /** Percentage of net memory used for dataset. */
+    datasetPercentage: number;
+    /** Overall memory fragmentation ratio. */
+    fragmentation: number;
+    /** Percentage of peak.allocated out of total.allocated. */
+    peakPercentage: number;
+    /** Ratio of RSS overhead. */
+    rssOverheadRatio: number;
+    /**
+     * Memory used by cluster links in bytes.
+     * @remarks Redis 7.0+ only.
+     */
+    clusterLinks?: number;
+    /**
+     * Memory used by functions caches in bytes.
+     * @remarks Redis 7.0+ only.
+     */
+    functionsCaches?: number;
+    /**
+     * Memory used by allocator muzzy pages in bytes.
+     * @remarks Valkey 8.0+ only.
+     */
+    allocatorMuzzy?: number;
+    /**
+     * Count of db dictionaries currently rehashing.
+     * @remarks Valkey 8.0+ only.
+     */
+    dbDictRehashingCount?: number;
+    /**
+     * Overhead of db hashtable LUT in bytes.
+     * @remarks Valkey 8.0+ only.
+     */
+    overheadDbHashtableLut?: number;
+    /**
+     * Overhead of db hashtable rehashing in bytes.
+     * @remarks Valkey 8.0+ only.
+     */
+    overheadDbHashtableRehashing?: number;
+}
 export {};

package/build-ts/Commands.js

@@ -6,7 +6,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TimeUnit = exports.ScoreFilter = exports.SortOrder = exports.GeoUnit = exports.HashExpirationCondition = exports.HashFieldConditionalChange = exports.ConditionalChange = exports.FlushMode = exports.BitmapIndexType = exports.FunctionRestorePolicy = exports.InsertPosition = exports.InfBoundary = exports.UpdateByScore = exports.ExpireOptions = exports.ListDirection = exports.BitFieldOverflow = exports.BitOverflowControl = exports.BitFieldIncrBy = exports.BitFieldSet = exports.BitFieldGet = exports.BitOffsetMultiplier = exports.BitOffset = exports.UnsignedEncoding = exports.SignedEncoding = exports.BitwiseOperation = exports.InfoOptions = void 0;
+exports.TimeUnit = exports.ClientTrackingInfo = exports.LatencyEventInfo = exports.LatencyEntry = exports.ScoreFilter = exports.SortOrder = exports.GeoUnit = exports.HashExpirationCondition = exports.HashFieldConditionalChange = exports.ConditionalChange = exports.FlushMode = exports.BitmapIndexType = exports.FunctionRestorePolicy = exports.InsertPosition = exports.InfBoundary = exports.UpdateByScore = exports.ExpireOptions = exports.ListDirection = exports.BitFieldOverflow = exports.BitOverflowControl = exports.BitFieldIncrBy = exports.BitFieldSet = exports.BitFieldGet = exports.BitOffsetMultiplier = exports.BitOffset = exports.UnsignedEncoding = exports.SignedEncoding = exports.BitwiseOperation = exports.ClientPauseMode = exports.InfoOptions = void 0;
 exports.parseInfoResponse = parseInfoResponse;
 exports.createGet = createGet;
 exports.createGetDel = createGetDel;
@@ -17,6 +17,7 @@ exports.createInfo = createInfo;
 exports.createDel = createDel;
 exports.createSelect = createSelect;
 exports.createClientGetName = createClientGetName;
+exports.createReset = createReset;
 exports.createConfigRewrite = createConfigRewrite;
 exports.createConfigResetStat = createConfigResetStat;
 exports.createMGet = createMGet;
@@ -26,6 +27,8 @@ exports.createIncr = createIncr;
 exports.createIncrBy = createIncrBy;
 exports.createIncrByFloat = createIncrByFloat;
 exports.createClientId = createClientId;
+exports.createClientPause = createClientPause;
+exports.createClientUnpause = createClientUnpause;
 exports.createConfigGet = createConfigGet;
 exports.createConfigSet = createConfigSet;
 exports.createHGet = createHGet;
@@ -179,6 +182,7 @@ exports.createLolwut = createLolwut;
 exports.createFlushAll = createFlushAll;
 exports.createFlushDB = createFlushDB;
 exports.createCopy = createCopy;
+exports.createMigrate = createMigrate;
 exports.createMove = createMove;
 exports.createDump = createDump;
 exports.createRestore = createRestore;
@@ -202,6 +206,18 @@ exports.createHRandField = createHRandField;
 exports.createHScan = createHScan;
 exports.createZRandMember = createZRandMember;
 exports.createLastSave = createLastSave;
+exports.createSave = createSave;
+exports.createBgSave = createBgSave;
+exports.createBgRewriteAof = createBgRewriteAof;
+exports.createLatencyHistory = createLatencyHistory;
+exports.createLatencyLatest = createLatencyLatest;
+exports.createLatencyReset = createLatencyReset;
+exports.createClientTrackingInfo = createClientTrackingInfo;
+exports.parseClientTrackingInfoResponse = parseClientTrackingInfoResponse;
+exports.createMemoryDoctor = createMemoryDoctor;
+exports.createMemoryMallocStats = createMemoryMallocStats;
+exports.createMemoryPurge = createMemoryPurge;
+exports.createMemoryStats = createMemoryStats;
 exports.createLCS = createLCS;
 exports.createTouch = createTouch;
 exports.createRandomKey = createRandomKey;
@@ -240,6 +256,12 @@ exports.createXGroupSetid = createXGroupSetid;
 exports.createScriptExists = createScriptExists;
 exports.createScriptFlush = createScriptFlush;
 exports.createScriptKill = createScriptKill;
+exports.createFailover = createFailover;
+exports.createReplicaOf = createReplicaOf;
+exports.createReplicaOfNoOne = createReplicaOfNoOne;
+exports.parseMemoryStatsResponse = parseMemoryStatsResponse;
+exports.parseLatencyHistoryResponse = parseLatencyHistoryResponse;
+exports.parseLatencyLatestResponse = parseLatencyLatestResponse;
 /**
  * Note: 'eslint-disable-line @typescript-eslint/no-unused-vars' is used intentionally
  * to suppress unused import errors for types referenced only in JSDoc.
@@ -473,6 +495,12 @@ function createSelect(index) {
 function createClientGetName() {
     return createCommand(RequestType.ClientGetName, []);
 }
+/**
+ * @internal
+ */
+function createReset() {
+    return createCommand(RequestType.Reset, []);
+}
 /**
  * @internal
  */
@@ -527,6 +555,35 @@ function createIncrByFloat(key, amount) {
 function createClientId() {
     return createCommand(RequestType.ClientId, []);
 }
+/**
+ * Defines the pause mode for {@link GlideClient.clientPause} and
+ *      {@link GlideClusterClient.clientPause} commands.
+ *
+ * @see {@link https://valkey.io/commands/client-pause/|valkey.io} for details.
+ */
+var ClientPauseMode;
+(function (ClientPauseMode) {
+    /** Pause all client commands. */
+    ClientPauseMode["ALL"] = "ALL";
+    /** Pause client write commands. */
+    ClientPauseMode["WRITE"] = "WRITE";
+})(ClientPauseMode || (exports.ClientPauseMode = ClientPauseMode = {}));
+/**
+ * @internal
+ */
+function createClientPause(timeout, mode) {
+    const args = [timeout.toString()];
+    if (mode !== undefined) {
+        args.push(mode);
+    }
+    return createCommand(RequestType.ClientPause, args);
+}
+/**
+ * @internal
+ */
+function createClientUnpause() {
+    return createCommand(RequestType.ClientUnpause, []);
+}
 /**
  * @internal
  */
@@ -2367,6 +2424,36 @@ function createCopy(source, destination, options) {
     }
     return createCommand(RequestType.Copy, args);
 }
+function createMigrate(host, port, key, destinationDB, timeout, options) {
+    const isArray = Array.isArray(key);
+    if (isArray && key.length === 0)
+        throw new Error("key must not be an empty array");
+    const args = [
+        host,
+        port.toString(),
+        isArray ? "" : key,
+        destinationDB.toString(),
+        timeout.toString(),
+    ];
+    if (options) {
+        if (options.username !== undefined && options.password === undefined) {
+            throw new Error("MigrateOptions: 'username' requires 'password' to be set");
+        }
+        if (options.copy)
+            args.push("COPY");
+        if (options.replace)
+            args.push("REPLACE");
+        if (options.username !== undefined && options.password !== undefined) {
+            args.push("AUTH2", options.username, options.password);
+        }
+        else if (options.password !== undefined) {
+            args.push("AUTH", options.password);
+        }
+    }
+    if (isArray)
+        args.push("KEYS", ...key);
+    return createCommand(RequestType.Migrate, args);
+}
 /**
  * @internal
  */
@@ -2731,6 +2818,118 @@ function createLastSave() {
     return createCommand(RequestType.LastSave, []);
 }
 /** @internal */
+function createSave() {
+    return createCommand(RequestType.Save, []);
+}
+/** @internal */
+function createBgSave(args) {
+    return createCommand(RequestType.BgSave, args ?? []);
+}
+/** @internal */
+function createBgRewriteAof() {
+    return createCommand(RequestType.BgRewriteAof, []);
+}
+/**
+ * Represents the time and latency for a latency spike.
+ */
+class LatencyEntry {
+    /** The time of the latency spike, as a Unix timestamp in seconds. */
+    time;
+    /** The duration of the latency spike, in milliseconds. */
+    latency;
+    /** @internal */
+    constructor(time, latency) {
+        this.time = time;
+        this.latency = latency;
+    }
+}
+exports.LatencyEntry = LatencyEntry;
+/**
+ * Represents information about an event's latency spike time series.
+ */
+class LatencyEventInfo {
+    /** The name of the event. */
+    eventName;
+    /** The time of the latest latency spike, as a Unix timestamp in seconds. */
+    latestTime;
+    /** The duration of the latest latency spike, in milliseconds. */
+    latestDuration;
+    /** The all-time maximum duration of a latency spike, in milliseconds. */
+    maxDuration;
+    /** The sum of all latency spike durations in the event's time series, in milliseconds. Only populated for Valkey 8.1+. */
+    sum;
+    /** The number of latency spikes recorded in the event's time series. Only populated for Valkey 8.1+. */
+    count;
+    /** @internal */
+    constructor(eventName, latestTime, latestDuration, maxDuration, sum, count) {
+        this.eventName = eventName;
+        this.latestTime = latestTime;
+        this.latestDuration = latestDuration;
+        this.maxDuration = maxDuration;
+        this.sum = sum;
+        this.count = count;
+    }
+}
+exports.LatencyEventInfo = LatencyEventInfo;
+/** @internal */
+function createLatencyHistory(event) {
+    return createCommand(RequestType.LatencyHistory, [event]);
+}
+/** @internal */
+function createLatencyLatest() {
+    return createCommand(RequestType.LatencyLatest, []);
+}
+/** @internal */
+function createLatencyReset(events) {
+    return createCommand(RequestType.LatencyReset, events ?? []);
+}
+/**
+ * Represents a `CLIENT TRACKINGINFO` response.
+ *
+ * @see {@link https://valkey.io/commands/client-trackinginfo/|valkey.io} for details.
+ */
+class ClientTrackingInfo {
+    /** Set of tracking flags. */
+    flags;
+    /** Client ID receiving invalidation messages, or -1 if not redirecting. */
+    redirect;
+    /** Set of key prefixes monitored for invalidation. */
+    prefixes;
+    constructor(flags, redirect, prefixes) {
+        this.flags = flags;
+        this.redirect = redirect;
+        this.prefixes = prefixes;
+    }
+}
+exports.ClientTrackingInfo = ClientTrackingInfo;
+/** @internal */
+function createClientTrackingInfo() {
+    return createCommand(RequestType.ClientTrackingInfo, []);
+}
+/**
+ * @internal
+ * Parses a `CLIENT TRACKINGINFO` response.
+ */
+function parseClientTrackingInfoResponse(response) {
+    return new ClientTrackingInfo(new Set(response["flags"]), response["redirect"], new Set(response["prefixes"]));
+}
+/** @internal */
+function createMemoryDoctor() {
+    return createCommand(RequestType.MemoryDoctor, []);
+}
+/** @internal */
+function createMemoryMallocStats() {
+    return createCommand(RequestType.MemoryMallocStats, []);
+}
+/** @internal */
+function createMemoryPurge() {
+    return createCommand(RequestType.MemoryPurge, []);
+}
+/** @internal */
+function createMemoryStats() {
+    return createCommand(RequestType.MemoryStats, []);
+}
+/** @internal */
 function createLCS(key1, key2, options) {
     const args = [key1, key2];
     if (options) {
@@ -3058,3 +3257,114 @@ function createScriptFlush(mode) {
 function createScriptKill() {
     return createCommand(RequestType.ScriptKill, []);
 }
+/** @internal */
+function createFailover(options) {
+    const args = [];
+    if (options?.abort) {
+        args.push("ABORT");
+    }
+    else {
+        if (options?.to) {
+            args.push("TO", options.to.host, options.to.port.toString());
+            if (options.to.force) {
+                args.push("FORCE");
+            }
+        }
+        if (options?.timeoutMs !== undefined) {
+            args.push("TIMEOUT", options.timeoutMs.toString());
+        }
+    }
+    return createCommand(RequestType.FailOver, args);
+}
+/** @internal */
+function createReplicaOf(host, port) {
+    return createCommand(RequestType.ReplicaOf, [host, port.toString()]);
+}
+/** @internal */
+function createReplicaOfNoOne() {
+    return createCommand(RequestType.ReplicaOf, ["NO", "ONE"]);
+}
+/** @internal */
+const _MEMORY_STATS_DB_PREFIX = "db.";
+/** @internal */
+function _parseMemoryStatsDb(raw) {
+    return {
+        overheadHashtableExpires: Number(raw["overhead.hashtable.expires"]),
+        overheadHashtableMain: Number(raw["overhead.hashtable.main"]),
+    };
+}
+/** @internal */
+function parseMemoryStatsResponse(raw) {
+    const db = {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (key.startsWith(_MEMORY_STATS_DB_PREFIX) &&
+            key !== "db.dict.rehashing.count") {
+            const dbIndex = parseInt(key.slice(_MEMORY_STATS_DB_PREFIX.length), 10);
+            db[dbIndex] = _parseMemoryStatsDb(value);
+        }
+    }
+    return {
+        db,
+        allocatorActive: Number(raw["allocator.active"]),
+        allocatorAllocated: Number(raw["allocator.allocated"]),
+        allocatorFragmentationBytes: Number(raw["allocator-fragmentation.bytes"]),
+        allocatorResident: Number(raw["allocator.resident"]),
+        allocatorRssBytes: Number(raw["allocator-rss.bytes"]),
+        aofBuffer: Number(raw["aof.buffer"]),
+        clientsNormal: Number(raw["clients.normal"]),
+        clientsSlaves: Number(raw["clients.slaves"]),
+        datasetBytes: Number(raw["dataset.bytes"]),
+        fragmentationBytes: Number(raw["fragmentation.bytes"]),
+        keysBytesPerKey: Number(raw["keys.bytes-per-key"]),
+        keysCount: Number(raw["keys.count"]),
+        luaCaches: Number(raw["lua.caches"]),
+        overheadTotal: Number(raw["overhead.total"]),
+        peakAllocated: Number(raw["peak.allocated"]),
+        replicationBacklog: Number(raw["replication.backlog"]),
+        rssOverheadBytes: Number(raw["rss-overhead.bytes"]),
+        startupAllocated: Number(raw["startup.allocated"]),
+        totalAllocated: Number(raw["total.allocated"]),
+        allocatorFragmentationRatio: Number(raw["allocator-fragmentation.ratio"]),
+        allocatorRssRatio: Number(raw["allocator-rss.ratio"]),
+        datasetPercentage: Number(raw["dataset.percentage"]),
+        fragmentation: Number(raw["fragmentation"]),
+        peakPercentage: Number(raw["peak.percentage"]),
+        rssOverheadRatio: Number(raw["rss-overhead.ratio"]),
+        // Optional Redis 7.0+ fields
+        clusterLinks: "cluster.links" in raw ? Number(raw["cluster.links"]) : undefined,
+        functionsCaches: "functions.caches" in raw
+            ? Number(raw["functions.caches"])
+            : undefined,
+        // Optional Valkey 8.0+ fields
+        allocatorMuzzy: "allocator.muzzy" in raw
+            ? Number(raw["allocator.muzzy"])
+            : undefined,
+        dbDictRehashingCount: "db.dict.rehashing.count" in raw
+            ? Number(raw["db.dict.rehashing.count"])
+            : undefined,
+        overheadDbHashtableLut: "overhead.db.hashtable.lut" in raw
+            ? Number(raw["overhead.db.hashtable.lut"])
+            : undefined,
+        overheadDbHashtableRehashing: "overhead.db.hashtable.rehashing" in raw
+            ? Number(raw["overhead.db.hashtable.rehashing"])
+            : undefined,
+    };
+}
+/**
+ * Parses a `LATENCY HISTORY` response.
+ * @internal
+ */
+function parseLatencyHistoryResponse(response) {
+    return response.map((entry) => new LatencyEntry(entry[0], entry[1]));
+}
+/**
+ * Parses a `LATENCY LATEST` response.
+ * @internal
+ */
+function parseLatencyLatestResponse(response) {
+    return response.map((entry) => {
+        const sum = entry.length >= 6 ? entry[4] : undefined;
+        const count = entry.length >= 6 ? entry[5] : undefined;
+        return new LatencyEventInfo(entry[0], entry[1], entry[2], entry[3], sum, count);
+    });
+}

package/build-ts/Errors.d.ts

@@ -19,3 +19,5 @@ export declare class ConnectionError extends RequestError {
 }
 export declare class ConfigurationError extends RequestError {
 }
+export declare class CircuitBreakerError extends RequestError {
+}

package/build-ts/Errors.js

@@ -3,7 +3,7 @@
  * Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigurationError = exports.ConnectionError = exports.ExecAbortError = exports.TIMEOUT_ERROR = exports.TimeoutError = exports.RequestError = exports.ClosingError = exports.ValkeyError = void 0;
+exports.CircuitBreakerError = exports.ConfigurationError = exports.ConnectionError = exports.ExecAbortError = exports.TIMEOUT_ERROR = exports.TimeoutError = exports.RequestError = exports.ClosingError = exports.ValkeyError = void 0;
 /// Base class for errors.
 class ValkeyError extends Error {
     message;
@@ -41,3 +41,6 @@ exports.ConnectionError = ConnectionError;
 class ConfigurationError extends RequestError {
 }
 exports.ConfigurationError = ConfigurationError;
+class CircuitBreakerError extends RequestError {
+}
+exports.CircuitBreakerError = CircuitBreakerError;