/**
 * Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0
 */
import { Script } from "glide-rs";
import * as net from "net";
import { Buffer, Writer } from "protobufjs";
import { AggregationType, BaseScanOptions, BitFieldGet, // eslint-disable-line @typescript-eslint/no-unused-vars
BitFieldSubCommands, // eslint-disable-line @typescript-eslint/no-unused-vars
BitOffsetOptions, BitwiseOperation, Boundary, // eslint-disable-line @typescript-eslint/no-unused-vars
ExpireOptions, GeoAddOptions, // eslint-disable-line @typescript-eslint/no-unused-vars
GeoSearchResultOptions, GeoSearchShape, GeoSearchStoreResultOptions, GeoUnit, GeospatialData, HScanOptions, InsertPosition, KeyWeight, LPosOptions, ListDirection, // eslint-disable-line @typescript-eslint/no-unused-vars
RangeByIndex, RangeByLex, RangeByScore, RestoreOptions, ScoreFilter, SearchOrigin, SetOptions, SortOptions, StreamAddOptions, StreamClaimOptions, StreamGroupOptions, StreamPendingOptions, StreamReadGroupOptions, StreamReadOptions, StreamTrimOptions, TimeUnit, ZAddOptions, ZScanOptions } from "./Commands";
import { ConnectionError, ValkeyError } from "./Errors";
import { GlideClientConfiguration } from "./GlideClient";
import { GlideClusterClientConfiguration, RouteOption, Routes } from "./GlideClusterClient";
import { command_request, connection_request, response } from "./ProtobufMessage";
type PromiseFunction = (value?: any) => void;
type ErrorFunction = (error: ValkeyError) => void;
export type ReturnTypeRecord = {
    [key: string]: GlideReturnType;
};
export type ReturnTypeMap = Map<string, GlideReturnType>;
export interface ReturnTypeAttribute {
    value: GlideReturnType;
    attributes: ReturnTypeRecord;
}
export declare enum ProtocolVersion {
    /** Use RESP2 to communicate with the server nodes. */
    RESP2 = 1,
    /** Use RESP3 to communicate with the server nodes. */
    RESP3 = 0
}
export type GlideReturnType = "OK" | string | number | null | boolean | bigint | Buffer | Set<GlideReturnType> | ReturnTypeRecord | ReturnTypeMap | ReturnTypeAttribute | GlideReturnType[];
/**
 * Union type that can store either a valid UTF-8 string or array of bytes.
 */
export type GlideString = string | Buffer;
/**
 * Enum representing the different types of decoders.
 */
export declare enum Decoder {
    /**
     * Decodes the response into a buffer array.
     */
    Bytes = 0,
    /**
     * Decodes the response into a string.
     */
    String = 1
}
/** An extension to command option types with {@link Decoder}. */
export interface DecoderOption {
    /**
     * {@link Decoder} type which defines how to handle the response.
     * If not set, the {@link BaseClientConfiguration.defaultDecoder|default decoder} will be used.
     */
    decoder?: Decoder;
}
/** A replacement for `Record<GlideString, T>` - array of key-value pairs. */
export type GlideRecord<T> = {
    /** The value name. */
    key: GlideString;
    /** The value itself. */
    value: T;
}[];
/**
 * Data type which represents sorted sets data, including elements and their respective scores.
 * Similar to `Record<GlideString, number>` - see {@link GlideRecord}.
 */
export type SortedSetDataType = {
    /** The sorted set element name. */
    element: GlideString;
    /** The element score. */
    score: number;
}[];
/**
 * Data type which represents how data are returned from hashes or insterted there.
 * Similar to `Record<GlideString, GlideString>` - see {@link GlideRecord}.
 */
export type HashDataType = {
    /** The hash element name. */
    field: GlideString;
    /** The hash element value. */
    value: GlideString;
}[];
/**
 * Data type which reflects now stream entries are returned.
 * The keys of the record are stream entry IDs, which are mapped to key-value pairs of the data.
 */
export type StreamEntryDataType = Record<string, [GlideString, GlideString][]>;
/**
 * Union type that can store either a number or positive/negative infinity.
 */
export type Score = number | "+inf" | "-inf";
/**
 * Data type which represents sorted sets data for input parameter of ZADD command,
 * including element and its respective score.
 */
export type ElementAndScore = {
    /** The sorted set element name. */
    element: GlideString;
    /** The element score. */
    score: Score;
};
/**
 * @internal
 * This function converts an input from GlideRecord or Record types to GlideRecord.
 *
 * @param keysAndValues - key names and their values.
 * @returns GlideRecord array containing keys and their values.
 */
export declare function convertGlideRecord(keysAndValues: GlideRecord<GlideString> | Record<string, GlideString>): GlideRecord<GlideString>;
/**
 * @internal
 * Recursively downcast `GlideRecord` to `Record`. Use if `data` keys are always strings.
 */
export declare function convertGlideRecordToRecord<T>(data: GlideRecord<T>): Record<string, T>;
/**
 * @internal
 * Check whether an object is a `GlideRecord` (see {@link GlideRecord}).
 */
export declare function isGlideRecord(obj?: unknown): boolean;
/** Represents the return type of {@link xinfoStream} command. */
export type ReturnTypeXinfoStream = Record<string, StreamEntries | Record<string, StreamEntries | Record<string, StreamEntries>[]>[]>;
/**
 * Represents an array of Stream Entires in the response of {@link xinfoStream} command.
 * See {@link ReturnTypeXinfoStream}.
 */
export type StreamEntries = GlideString | number | (GlideString | number | GlideString[])[][];
/**
 * @internal
 * Reverse of {@link convertGlideRecordToRecord}.
 */
export declare function convertRecordToGlideRecord<T>(data: Record<string, T>): GlideRecord<T>;
/** Represents the credentials for connecting to a server. */
export interface ServerCredentials {
    /**
     * The username that will be used for authenticating connections to the Valkey servers.
     * If not supplied, "default" will be used.
     */
    username?: string;
    /**
     * The password that will be used for authenticating connections to the Valkey servers.
     */
    password: string;
}
/** Represents the client's read from strategy. */
export type ReadFrom = 
/** Always get from primary, in order to get the freshest data.*/
"primary"
/** Spread the requests between all replicas in a round robin manner.
    If no replica is available, route the requests to the primary.*/
 | "preferReplica"
/** Spread the requests between replicas in the same client's Aviliablity zone in a round robin manner.
    If no replica is available, route the requests to the primary.*/
 | "AZAffinity"
/** Spread the read requests among all nodes within the client's Availability Zone (AZ) in a round robin manner,
     prioritizing local replicas, then the local primary, and falling back to any replica or the primary if needed.*/
 | "AZAffinityReplicasAndPrimary";
/**
 * Configuration settings for creating a client. Shared settings for standalone and cluster clients.
 *
 * @remarks
 * The `BaseClientConfiguration` interface defines the foundational configuration options used when creating a client to connect to a Valkey server or cluster. It includes connection details, authentication, communication protocols, and various settings that influence the client's behavior and interaction with the server.
 *
 * ### Connection Details
 *
 * - **Addresses**: Use the `addresses` property to specify the hostnames and ports of the server(s) to connect to.
 *   - **Cluster Mode**: In cluster mode, the client will discover other nodes based on the provided addresses.
 *   - **Standalone Mode**: In standalone mode, only the provided nodes will be used.
 *
 * ### Security Settings
 *
 * - **TLS**: Enable secure communication using `useTLS`.
 * - **Authentication**: Provide `credentials` to authenticate with the server.
 *
 * ### Communication Settings
 *
 * - **Request Timeout**: Set `requestTimeout` to specify how long the client should wait for a request to complete.
 * - **Protocol Version**: Choose the serialization protocol using `protocol`.
 *
 * ### Client Identification
 *
 * - **Client Name**: Set `clientName` to identify the client connection.
 *
 * ### Read Strategy
 *
 * - Use `readFrom` to specify the client's read strategy (e.g., primary, preferReplica, AZAffinity, AZAffinityReplicasAndPrimary).
 *
 * ### Availability Zone
 *
 * - Use `clientAz` to specify the client's availability zone, which can influence read operations when using `readFrom: 'AZAffinity'or `readFrom: 'AZAffinityReplicasAndPrimary'`.
 *
 * ### Decoder Settings
 *
 * - **Default Decoder**: Set `defaultDecoder` to specify how responses are decoded by default.
 *
 * ### Concurrency Control
 *
 * - **Inflight Requests Limit**: Control the number of concurrent requests using `inflightRequestsLimit`.
 *
 * @example
 * ```typescript
 * const config: BaseClientConfiguration = {
 *   addresses: [
 *     { host: 'redis-node-1.example.com', port: 6379 },
 *     { host: 'redis-node-2.example.com' }, // Defaults to port 6379
 *   ],
 *   useTLS: true,
 *   credentials: {
 *     username: 'myUser',
 *     password: 'myPassword',
 *   },
 *   requestTimeout: 5000, // 5 seconds
 *   protocol: ProtocolVersion.RESP3,
 *   clientName: 'myValkeyClient',
 *   readFrom: ReadFrom.AZAffinity,
 *   clientAz: 'us-east-1a',
 *   defaultDecoder: Decoder.String,
 *   inflightRequestsLimit: 1000,
 * };
 * ```
 */
export interface BaseClientConfiguration {
    /**
     * DNS Addresses and ports of known nodes in the cluster.
     * If the server is in cluster mode the list can be partial, as the client will attempt to map out the cluster and find all nodes.
     * If the server is in standalone mode, only nodes whose addresses were provided will be used by the client.
     *
     * @example
     * ```typescript
     * configuration.addresses =
     * [
     *   { address: sample-address-0001.use1.cache.amazonaws.com, port:6378 },
     *   { address: sample-address-0002.use2.cache.amazonaws.com }
     *   { address: sample-address-0003.use2.cache.amazonaws.com, port:6380 }
     * ]
     * ```
     */
    addresses: {
        host: string;
        /**
         * If port isn't supplied, 6379 will be used
         */
        port?: number;
    }[];
    /**
     * True if communication with the cluster should use Transport Level Security.
     * Should match the TLS configuration of the server/cluster,
     * otherwise the connection attempt will fail.
     */
    useTLS?: boolean;
    /**
     * Credentials for authentication process.
     * If none are set, the client will not authenticate itself with the server.
     */
    credentials?: ServerCredentials;
    /**
     * The duration in milliseconds that the client should wait for a request to complete.
     * This duration encompasses sending the request, awaiting for a response from the server, and any required reconnections or retries.
     * If the specified timeout is exceeded for a pending request, it will result in a timeout error.
     * If not explicitly set, a default value of 250 milliseconds will be used.
     * Value must be an integer.
     */
    requestTimeout?: number;
    /**
     * The client's read from strategy.
     * If not set, `Primary` will be used.
     */
    readFrom?: ReadFrom;
    /**
     * Serialization protocol to be used.
     * If not set, `RESP3` will be used.
     */
    protocol?: ProtocolVersion;
    /**
     * Client name to be used for the client. Will be used with CLIENT SETNAME command during connection establishment.
     */
    clientName?: string;
    /**
     * Default decoder when decoder is not set per command.
     * If not set, 'Decoder.String' will be used.
     */
    defaultDecoder?: Decoder;
    /**
     * The maximum number of concurrent requests allowed to be in-flight (sent but not yet completed).
     * This limit is used to control the memory usage and prevent the client from overwhelming the
     * server or getting stuck in case of a queue backlog. If not set, a default value of 1000 will be
     * used.
     */
    inflightRequestsLimit?: number;
    /**
     * Availability Zone of the client.
     * If ReadFrom strategy is AZAffinity or AZAffinityReplicasAndPrimary, this setting ensures that readonly commands are directed to nodes within the specified AZ if they exist.
     *
     * @example
     * ```typescript
     * // Example configuration for setting client availability zone and read strategy
     * configuration.clientAz = 'us-east-1a'; // Sets the client's availability zone
     * configuration.readFrom = 'AZAffinity'; // Directs read operations to nodes within the same AZ
     * Or
     * configuration.readFrom = 'AZAffinityReplicasAndPrimary'; // Directs read operations to any node (primary or replica) within the same AZ
     * ```
     */
    clientAz?: string;
}
/**
 * Represents advanced configuration settings for a client, including connection-related options.
 *
 * @remarks
 * The `AdvancedBaseClientConfiguration` interface defines advanced configuration settings for managing the client's connection behavior.
 *
 * ### Connection Timeout
 *
 * - **Connection Timeout**: The `connectionTimeout` property specifies the duration (in milliseconds) the client should wait for a connection to be established.
 *
 * @example
 * ```typescript
 * const config: AdvancedBaseClientConfiguration = {
 *   connectionTimeout: 5000, // 5 seconds
 * };
 * ```
 */
export interface AdvancedBaseClientConfiguration {
    /**
     * The duration in milliseconds to wait for a TCP/TLS connection to complete.
     * This applies both during initial client creation and any reconnections that may occur during request processing.
     * **Note**: A high connection timeout may lead to prolonged blocking of the entire command pipeline.
     * If not explicitly set, a default value of 250 milliseconds will be used.
     */
    connectionTimeout?: number;
}
/**
 * Enum of Valkey data types
 * `STRING`
 * `LIST`
 * `SET`
 * `ZSET`
 * `HASH`
 * `STREAM`
 */
export declare enum ObjectType {
    STRING = "String",
    LIST = "List",
    SET = "Set",
    ZSET = "ZSet",
    HASH = "Hash",
    STREAM = "Stream"
}
export interface PubSubMsg {
    message: GlideString;
    channel: GlideString;
    pattern?: GlideString | null;
}
/**
 * @internal
 * A type to combine RouterOption and DecoderOption to be used for creating write promises for the command.
 * See - {@link DecoderOption} and {@link RouteOption}
 */
export type WritePromiseOptions = RouteOption & DecoderOption;
export declare class BaseClient {
    private socket;
    protected readonly promiseCallbackFunctions: [PromiseFunction, ErrorFunction, Decoder | undefined][] | [PromiseFunction, ErrorFunction][];
    private readonly availableCallbackSlots;
    private requestWriter;
    private writeInProgress;
    private remainingReadData;
    private readonly requestTimeout;
    protected isClosed: boolean;
    protected defaultDecoder: Decoder;
    private readonly pubsubFutures;
    private pendingPushNotification;
    private readonly inflightRequestsLimit;
    private config;
    protected configurePubsub(options: GlideClusterClientConfiguration | GlideClientConfiguration, configuration: connection_request.IConnectionRequest): void;
    private handleReadData;
    protected toProtobufRoute(route: Routes | undefined): command_request.Routes | undefined;
    processResponse(message: response.Response): void;
    processPush(response: response.Response): void;
    /**
     * @internal
     */
    protected constructor(socket: net.Socket, options?: BaseClientConfiguration);
    protected getCallbackIndex(): number;
    private writeBufferedRequestsToSocket;
    protected ensureClientIsOpen(): void;
    /**
     * @internal
     */
    protected createWritePromise<T>(command: command_request.Command | command_request.Command[], options?: WritePromiseOptions): Promise<T>;
    protected createUpdateConnectionPasswordPromise(command: command_request.UpdateConnectionPassword): Promise<GlideString>;
    protected createScriptInvocationPromise<T = GlideString>(command: command_request.ScriptInvocation, options?: {
        keys?: GlideString[];
        args?: GlideString[];
    } & DecoderOption): Promise<T>;
    protected writeOrBufferCommandRequest(callbackIdx: number, command: command_request.Command | command_request.Command[], route?: command_request.Routes): void;
    protected writeOrBufferRequest<TRequest>(message: TRequest, encodeDelimited: (message: TRequest, writer: Writer) => void): void;
    /**
     * @internal
     */
    protected processResultWithSetCommands(result: GlideReturnType[] | null, setCommandsIndexes: number[]): GlideReturnType[] | null;
    cancelPubSubFuturesWithExceptionSafe(exception: ConnectionError): void;
    isPubsubConfigured(config: GlideClientConfiguration | GlideClusterClientConfiguration): boolean;
    getPubsubCallbackAndContext(config: GlideClientConfiguration | GlideClusterClientConfiguration): [((msg: PubSubMsg, context: any) => void) | null | undefined, any];
    getPubSubMessage(): Promise<PubSubMsg>;
    tryGetPubSubMessage(decoder?: Decoder): PubSubMsg | null;
    notificationToPubSubMessageSafe(pushNotification: response.Response, decoder?: Decoder): PubSubMsg | null;
    completePubSubFuturesSafe(): void;
    /** Get the value associated with the given key, or null if no such value exists.
     *
     * @see {@link https://valkey.io/commands/get/|valkey.io} for details.
     *
     * @param key - The key to retrieve from the database.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns If `key` exists, returns the value of `key`. Otherwise, return null.
     *
     * @example
     * ```typescript
     * // Example usage of get method to retrieve the value of a key
     * const result = await client.get("key");
     * console.log(result); // Output: 'value'
     * // Example usage of get method to retrieve the value of a key with Bytes decoder
     * const result = await client.get("key", Decoder.Bytes);
     * console.log(result); // Output: {"data": [118, 97, 108, 117, 101], "type": "Buffer"}
     * ```
     */
    get(key: GlideString, options?: DecoderOption): Promise<GlideString | null>;
    /**
     * Get the value of `key` and optionally set its expiration. `GETEX` is similar to {@link get}.
     *
     * @see {@link https://valkey.io/commands/getex/|valkey.op} for more details.
     * @remarks Since Valkey version 6.2.0.
     *
     * @param key - The key to retrieve from the database.
     * @param options - (Optional) Additional Parameters:
     * - (Optional) `expiry`: expiriation to the given key:
     * `"persist"` will retain the time to live associated with the key. Equivalent to `PERSIST` in the VALKEY API.
     * Otherwise, a {@link TimeUnit} and duration of the expire time should be specified.
     * - (Optional) `decoder`: see {@link DecoderOption}.
     * @returns If `key` exists, returns the value of `key` as a `string`. Otherwise, return `null`.
     *
     * @example
     * ```typescript
     * const result = await client.getex("key", {expiry: { type: TimeUnit.Seconds, count: 5 }});
     * console.log(result); // Output: 'value'
     * ```
     */
    getex(key: GlideString, options?: {
        expiry: "persist" | {
            type: TimeUnit;
            duration: number;
        };
    } & DecoderOption): Promise<GlideString | null>;
    /**
     * Gets a string value associated with the given `key`and deletes the key.
     *
     * @see {@link https://valkey.io/commands/getdel/|valkey.io} for details.
     *
     * @param key - The key to retrieve from the database.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns If `key` exists, returns the `value` of `key`. Otherwise, return `null`.
     *
     * @example
     * ```typescript
     * const result = client.getdel("key");
     * console.log(result); // Output: 'value'
     *
     * const value = client.getdel("key");  // value is null
     * ```
     */
    getdel(key: GlideString, options?: DecoderOption): Promise<GlideString | null>;
    /**
     * Returns the substring of the string value stored at `key`, determined by the byte offsets
     * `start` and `end` (both are inclusive). Negative offsets can be used in order to provide
     * an offset starting from the end of the string. So `-1` means the last character, `-2` the
     * penultimate and so forth. If `key` does not exist, an empty string is returned. If `start`
     * or `end` are out of range, returns the substring within the valid range of the string.
     *
     * @see {@link https://valkey.io/commands/getrange/|valkey.io} for details.
     *
     * @param key - The key of the string.
     * @param start - The starting byte offset.
     * @param end - The ending byte offset.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns A substring extracted from the value stored at `key`.
     *
     * @example
     * ```typescript
     * await client.set("mykey", "This is a string")
     * let result = await client.getrange("mykey", 0, 3)
     * console.log(result); // Output: "This"
     * result = await client.getrange("mykey", -3, -1)
     * console.log(result); // Output: "ing" - extracted last 3 characters of a string
     * result = await client.getrange("mykey", 0, 100)
     * console.log(result); // Output: "This is a string"
     * result = await client.getrange("mykey", 5, 6)
     * console.log(result); // Output: ""
     * ```
     */
    getrange(key: GlideString, start: number, end: number, options?: DecoderOption): Promise<GlideString | null>;
    /** Set the given key with the given value. Return value is dependent on the passed options.
     *
     * @see {@link https://valkey.io/commands/set/|valkey.io} for details.
     *
     * @param key - The key to store.
     * @param value - The value to store with the given key.
     * @param options - (Optional) See {@link SetOptions} and {@link DecoderOption}.
     * @returns - If the value is successfully set, return OK.
     * If `conditional` in `options` is not set, the value will be set regardless of prior value existence.
     * If value isn't set because of `onlyIfExists` or `onlyIfDoesNotExist` or `onlyIfEqual` conditions, return `null`.
     * If `returnOldValue` is set, return the old value as a string.
     *
     * @example
     * ```typescript
     * // Example usage of set method to set a key-value pair
     * const result = await client.set("my_key", "my_value");
     * console.log(result); // Output: 'OK'
     *
     * // Example usage of set method with conditional options and expiration
     * const result2 = await client.set("key", "new_value", {conditionalSet: "onlyIfExists", expiry: { type: TimeUnit.Seconds, count: 5 }});
     * console.log(result2); // Output: 'OK' - Set "new_value" to "key" only if "key" already exists, and set the key expiration to 5 seconds.
     *
     * // Example usage of set method with conditional options and returning old value
     * const result3 = await client.set("key", "value", {conditionalSet: "onlyIfDoesNotExist", returnOldValue: true});
     * console.log(result3); // Output: 'new_value' - Returns the old value of "key".
     *
     * // Example usage of get method to retrieve the value of a key
     * const result4 = await client.get("key");
     * console.log(result4); // Output: 'new_value' - Value wasn't modified back to being "value" because of "NX" flag.
     *
     * // Example usage of set method with conditional option IFEQ
     * await client.set("key", "value we will compare to");
     * const result5 = await client.set("key", "new_value", {conditionalSet: "onlyIfEqual", comparisonValue: "value we will compare to"});
     * console.log(result5); // Output: 'OK' - Set "new_value" to "key" only if comparisonValue is equal to the current value of "key".
     * const result6 = await client.set("key", "another_new_value", {conditionalSet: "onlyIfEqual", comparisonValue: "value we will compare to"});
     * console.log(result6); // Output: `null` - Value wasn't set because the comparisonValue is not equal to the current value of "key". Value of "key" remains "new_value".
     * ```
     */
    set(key: GlideString, value: GlideString, options?: SetOptions & DecoderOption): Promise<"OK" | GlideString | null>;
    /**
     * Removes the specified keys. A key is ignored if it does not exist.
     *
     * @see {@link https://valkey.io/commands/del/|valkey.io} for details.
     *
     * @remarks In cluster mode, if keys in `keys` map to different hash slots,
     * the command will be split across these slots and executed separately for each.
     * This means the command is atomic only at the slot level. If one or more slot-specific
     * requests fail, the entire call will return the first encountered error, even
     * though some requests may have succeeded while others did not.
     * If this behavior impacts your application logic, consider splitting the
     * request into sub-requests per slot to ensure atomicity.
     *
     * @param keys - The keys we wanted to remove.
     * @returns The number of keys that were removed.
     *
     * @example
     * ```typescript
     * // Example usage of del method to delete an existing key
     * await client.set("my_key", "my_value");
     * const result = await client.del(["my_key"]);
     * console.log(result); // Output: 1
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of del method for a non-existing key
     * const result = await client.del(["non_existing_key"]);
     * console.log(result); // Output: 0
     * ```
     */
    del(keys: GlideString[]): Promise<number>;
    /**
     * Serialize the value stored at `key` in a Valkey-specific format and return it to the user.
     *
     * @see {@link https://valkey.io/commands/dump/|valkey.io} for details.
     *
     * @param key - The `key` to serialize.
     * @returns The serialized value of the data stored at `key`. If `key` does not exist, `null` will be returned.
     *
     * @example
     * ```typescript
     * let result = await client.dump("myKey");
     * console.log(result); // Output: the serialized value of "myKey"
     * ```
     *
     * @example
     * ```typescript
     * result = await client.dump("nonExistingKey");
     * console.log(result); // Output: `null`
     * ```
     */
    dump(key: GlideString): Promise<Buffer | null>;
    /**
     * Create a `key` associated with a `value` that is obtained by deserializing the provided
     * serialized `value` (obtained via {@link dump}).
     *
     * @see {@link https://valkey.io/commands/restore/|valkey.io} for details.
     * @remarks `options.idletime` and `options.frequency` modifiers cannot be set at the same time.
     *
     * @param key - The `key` to create.
     * @param ttl - The expiry time (in milliseconds). If `0`, the `key` will persist.
     * @param value - The serialized value to deserialize and assign to `key`.
     * @param options - (Optional) Restore options {@link RestoreOptions}.
     * @returns Return "OK" if the `key` was successfully restored with a `value`.
     *
     * @example
     * ```typescript
     * const result = await client.restore("myKey", 0, value);
     * console.log(result); // Output: "OK"
     * ```
     *
     * @example
     * ```typescript
     * const result = await client.restore("myKey", 1000, value, {replace: true, absttl: true});
     * console.log(result); // Output: "OK"
     * ```
     *
     * @example
     * ```typescript
     * const result = await client.restore("myKey", 0, value, {replace: true, idletime: 10});
     * console.log(result); // Output: "OK"
     * ```
     *
     * @example
     * ```typescript
     * const result = await client.restore("myKey", 0, value, {replace: true, frequency: 10});
     * console.log(result); // Output: "OK"
     * ```
     */
    restore(key: GlideString, ttl: number, value: Buffer, options?: RestoreOptions): Promise<"OK">;
    /** Retrieve the values of multiple keys.
     *
     * @see {@link https://valkey.io/commands/mget/|valkey.io} for details.
     *
     * @remarks In cluster mode, if keys in `keys` map to different hash slots,
     * the command will be split across these slots and executed separately for each.
     * This means the command is atomic only at the slot level. If one or more slot-specific
     * requests fail, the entire call will return the first encountered error, even
     * though some requests may have succeeded while others did not.
     * If this behavior impacts your application logic, consider splitting the
     * request into sub-requests per slot to ensure atomicity.
     *
     * @param keys - A list of keys to retrieve values for.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns A list of values corresponding to the provided keys. If a key is not found,
     * its corresponding value in the list will be null.
     *
     * @example
     * ```typescript
     * // Example usage of mget method to retrieve values of multiple keys
     * await client.set("key1", "value1");
     * await client.set("key2", "value2");
     * const result = await client.mget(["key1", "key2"]);
     * console.log(result); // Output: ['value1', 'value2']
     * ```
     */
    mget(keys: GlideString[], options?: DecoderOption): Promise<(GlideString | null)[]>;
    /** Set multiple keys to multiple values in a single operation.
     *
     * @see {@link https://valkey.io/commands/mset/|valkey.io} for details.
     *
     * @remarks In cluster mode, if keys in `keyValueMap` map to different hash slots,
     * the command will be split across these slots and executed separately for each.
     * This means the command is atomic only at the slot level. If one or more slot-specific
     * requests fail, the entire call will return the first encountered error, even
     * though some requests may have succeeded while others did not.
     * If this behavior impacts your application logic, consider splitting the
     * request into sub-requests per slot to ensure atomicity.
     *
     * @param keysAndValues - A list of key-value pairs to set.
     *
     * @returns A simple "OK" response.
     *
     * @example
     * ```typescript
     * // Example usage of mset method to set values for multiple keys
     * const result = await client.mset({"key1": "value1", "key2": "value2"});
     * console.log(result); // Output: 'OK'
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of mset method to set values for multiple keys (GlideRecords allow binary data in the key)
     * const result = await client.mset([{key: "key1", value: "value1"}, {key: "key2", value: "value2"}]);
     * console.log(result); // Output: 'OK'
     * ```
     */
    mset(keysAndValues: Record<string, GlideString> | GlideRecord<GlideString>): Promise<"OK">;
    /**
     * Sets multiple keys to values if the key does not exist. The operation is atomic, and if one or
     * more keys already exist, the entire operation fails.
     *
     * @see {@link https://valkey.io/commands/msetnx/|valkey.io} for more details.
     * @remarks When in cluster mode, all keys in `keyValueMap` must map to the same hash slot.
     *
     * @param keysAndValues  - A list of key-value pairs to set.
     * @returns `true` if all keys were set. `false` if no key was set.
     *
     * @example
     * ```typescript
     * const result1 = await client.msetnx({"key1": "value1", "key2": "value2"});
     * console.log(result1); // Output: `true`
     *
     * const result2 = await client.msetnx({"key2": "value4", "key3": "value5"});
     * console.log(result2); // Output: `false`
     * ```
     */
    msetnx(keysAndValues: Record<string, GlideString> | GlideRecord<GlideString>): Promise<boolean>;
    /** Increments the number stored at `key` by one. If `key` does not exist, it is set to 0 before performing the operation.
     *
     * @see {@link https://valkey.io/commands/incr/|valkey.io} for details.
     *
     * @param key - The key to increment its value.
     * @returns the value of `key` after the increment.
     *
     * @example
     * ```typescript
     * // Example usage of incr method to increment the value of a key
     * await client.set("my_counter", "10");
     * const result = await client.incr("my_counter");
     * console.log(result); // Output: 11
     * ```
     */
    incr(key: GlideString): Promise<number>;
    /** Increments the number stored at `key` by `amount`. If `key` does not exist, it is set to 0 before performing the operation.
     *
     * @see {@link https://valkey.io/commands/incrby/|valkey.io} for details.
     *
     * @param key - The key to increment its value.
     * @param amount - The amount to increment.
     * @returns the value of `key` after the increment.
     *
     * @example
     * ```typescript
     * // Example usage of incrBy method to increment the value of a key by a specified amount
     * await client.set("my_counter", "10");
     * const result = await client.incrBy("my_counter", 5);
     * console.log(result); // Output: 15
     * ```
     */
    incrBy(key: GlideString, amount: number): Promise<number>;
    /** Increment the string representing a floating point number stored at `key` by `amount`.
     * By using a negative increment value, the result is that the value stored at `key` is decremented.
     * If `key` does not exist, it is set to 0 before performing the operation.
     *
     * @see {@link https://valkey.io/commands/incrbyfloat/|valkey.io} for details.
     *
     * @param key - The key to increment its value.
     * @param amount - The amount to increment.
     * @returns the value of `key` after the increment.
     *
     * @example
     * ```typescript
     * // Example usage of incrByFloat method to increment the value of a floating point key by a specified amount
     * await client.set("my_float_counter", "10.5");
     * const result = await client.incrByFloat("my_float_counter", 2.5);
     * console.log(result); // Output: 13.0
     * ```
     */
    incrByFloat(key: GlideString, amount: number): Promise<number>;
    /** Decrements the number stored at `key` by one. If `key` does not exist, it is set to 0 before performing the operation.
     *
     * @see {@link https://valkey.io/commands/decr/|valkey.io} for details.
     *
     * @param key - The key to decrement its value.
     * @returns the value of `key` after the decrement.
     *
     * @example
     * ```typescript
     * // Example usage of decr method to decrement the value of a key by 1
     * await client.set("my_counter", "10");
     * const result = await client.decr("my_counter");
     * console.log(result); // Output: 9
     * ```
     */
    decr(key: GlideString): Promise<number>;
    /** Decrements the number stored at `key` by `amount`. If `key` does not exist, it is set to 0 before performing the operation.
     *
     * @see {@link https://valkey.io/commands/decrby/|valkey.io} for details.
     *
     * @param key - The key to decrement its value.
     * @param amount - The amount to decrement.
     * @returns the value of `key` after the decrement.
     *
     * @example
     * ```typescript
     * // Example usage of decrby method to decrement the value of a key by a specified amount
     * await client.set("my_counter", "10");
     * const result = await client.decrby("my_counter", 5);
     * console.log(result); // Output: 5
     * ```
     */
    decrBy(key: GlideString, amount: number): Promise<number>;
    /**
     * Perform a bitwise operation between multiple keys (containing string values) and store the result in the
     * `destination`.
     *
     * @see {@link https://valkey.io/commands/bitop/|valkey.io} for more details.
     * @remarks When in cluster mode, `destination` and all `keys` must map to the same hash slot.
     *
     * @param operation - The bitwise operation to perform.
     * @param destination - The key that will store the resulting string.
     * @param keys - The list of keys to perform the bitwise operation on.
     * @returns The size of the string stored in `destination`.
     *
     * @example
     * ```typescript
     * await client.set("key1", "A"); // "A" has binary value 01000001
     * await client.set("key2", "B"); // "B" has binary value 01000010
     * const result1 = await client.bitop(BitwiseOperation.AND, "destination", ["key1", "key2"]);
     * console.log(result1); // Output: 1 - The size of the resulting string stored in "destination" is 1.
     *
     * const result2 = await client.get("destination");
     * console.log(result2); // Output: "@" - "@" has binary value 01000000
     * ```
     */
    bitop(operation: BitwiseOperation, destination: GlideString, keys: GlideString[]): Promise<number>;
    /**
     * Returns the bit value at `offset` in the string value stored at `key`. `offset` must be greater than or equal
     * to zero.
     *
     * @see {@link https://valkey.io/commands/getbit/|valkey.io} for more details.
     *
     * @param key - The key of the string.
     * @param offset - The index of the bit to return.
     * @returns The bit at the given `offset` of the string. Returns `0` if the key is empty or if the `offset` exceeds
     * the length of the string.
     *
     * @example
     * ```typescript
     * const result = await client.getbit("key", 1);
     * console.log(result); // Output: 1 - The second bit of the string stored at "key" is set to 1.
     * ```
     */
    getbit(key: GlideString, offset: number): Promise<number>;
    /**
     * Sets or clears the bit at `offset` in the string value stored at `key`. The `offset` is a zero-based index, with
     * `0` being the first element of the list, `1` being the next element, and so on. The `offset` must be less than
     * `2^32` and greater than or equal to `0`. If a key is non-existent then the bit at `offset` is set to `value` and
     * the preceding bits are set to `0`.
     *
     * @see {@link https://valkey.io/commands/setbit/|valkey.io} for more details.
     *
     * @param key - The key of the string.
     * @param offset - The index of the bit to be set.
     * @param value - The bit value to set at `offset`. The value must be `0` or `1`.
     * @returns The bit value that was previously stored at `offset`.
     *
     * @example
     * ```typescript
     * const result = await client.setbit("key", 1, 1);
     * console.log(result); // Output: 0 - The second bit value was 0 before setting to 1.
     * ```
     */
    setbit(key: GlideString, offset: number, value: number): Promise<number>;
    /**
     * Returns the position of the first bit matching the given `bit` value. The optional starting offset
     * `start` is a zero-based index, with `0` being the first byte of the list, `1` being the next byte and so on.
     * The offset can also be a negative number indicating an offset starting at the end of the list, with `-1` being
     * the last byte of the list, `-2` being the penultimate, and so on.
     *
     * @see {@link https://valkey.io/commands/bitpos/|valkey.io} for details.
     *
     * @param key - The key of the string.
     * @param bit - The bit value to match. Must be `0` or `1`.
     * @param options - (Optional) The {@link BitOffsetOptions}.
     *
     * @returns The position of the first occurrence of `bit` in the binary value of the string held at `key`.
     *      If `start` was provided, the search begins at the offset indicated by `start`.
     *
     * @example
     * ```typescript
     * await client.set("key1", "A1");  // "A1" has binary value 01000001 00110001
     * const result1 = await client.bitpos("key1", 1);
     * console.log(result1); // Output: 1 - The first occurrence of bit value 1 in the string stored at "key1" is at the second position.
     *
     * const result2 = await client.bitpos("key1", 1, { start: -1 });
     * console.log(result2); // Output: 10 - The first occurrence of bit value 1, starting at the last byte in the string stored at "key1", is at the eleventh position.
     *
     * await client.set("key1", "A12");  // "A12" has binary value 01000001 00110001 00110010
     * const result3 = await client.bitpos("key1", 1, { start: 1, end: -1 });
     * console.log(result3); // Output: 10 - The first occurrence of bit value 1 in the second byte to the last byte of the string stored at "key1" is at the eleventh position.
     *
     * const result4 = await client.bitpos("key1", 1, { start: 2, end: 9, indexType: BitmapIndexType.BIT });
     * console.log(result4); // Output: 7 - The first occurrence of bit value 1 in the third to tenth bits of the string stored at "key1" is at the eighth position.
     * ```
     */
    bitpos(key: GlideString, bit: number, options?: BitOffsetOptions): Promise<number>;
    /**
     * Reads or modifies the array of bits representing the string that is held at `key` based on the specified
     * `subcommands`.
     *
     * @see {@link https://valkey.io/commands/bitfield/|valkey.io} for more details.
     *
     * @param key - The key of the string.
     * @param subcommands - The subcommands to be performed on the binary value of the string at `key`, which could be
     *      any of the following:
     *
     * - {@link BitFieldGet}
     * - {@link BitFieldSet}
     * - {@link BitFieldIncrBy}
     * - {@link BitFieldOverflow}
     *
     * @returns An array of results from the executed subcommands:
     *
     * - {@link BitFieldGet} returns the value in {@link BitOffset} or {@link BitOffsetMultiplier}.
     * - {@link BitFieldSet} returns the old value in {@link BitOffset} or {@link BitOffsetMultiplier}.
     * - {@link BitFieldIncrBy} returns the new value in {@link BitOffset} or {@link BitOffsetMultiplier}.
     * - {@link BitFieldOverflow} determines the behavior of the {@link BitFieldSet} and {@link BitFieldIncrBy}
     *   subcommands when an overflow or underflow occurs. {@link BitFieldOverflow} does not return a value and
     *   does not contribute a value to the array response.
     *
     * @example
     * ```typescript
     * await client.set("key", "A");  // "A" has binary value 01000001
     * const result = await client.bitfield("key", [new BitFieldSet(new UnsignedEncoding(2), new BitOffset(1), 3), new BitFieldGet(new UnsignedEncoding(2), new BitOffset(1))]);
     * console.log(result); // Output: [2, 3] - The old value at offset 1 with an unsigned encoding of 2 was 2. The new value at offset 1 with an unsigned encoding of 2 is 3.
     * ```
     */
    bitfield(key: GlideString, subcommands: BitFieldSubCommands[]): Promise<(number | null)[]>;
    /**
     * Reads the array of bits representing the string that is held at `key` based on the specified `subcommands`.
     *
     * @see {@link https://valkey.io/commands/bitfield_ro/|valkey.io} for more details.
     * @remarks Since Valkey version 6.0.0.
     *
     * @param key - The key of the string.
     * @param subcommands - The {@link BitFieldGet} subcommands to be performed.
     * @returns An array of results from the {@link BitFieldGet} subcommands.
     *
     * @example
     * ```typescript
     * await client.set("key", "A");  // "A" has binary value 01000001
     * const result = await client.bitfieldReadOnly("key", [new BitFieldGet(new UnsignedEncoding(2), new BitOffset(1))]);
     * console.log(result); // Output: [2] - The value at offset 1 with an unsigned encoding of 2 is 2.
     * ```
     */
    bitfieldReadOnly(key: GlideString, subcommands: BitFieldGet[]): Promise<number[]>;
    /** Retrieve the value associated with `field` in the hash stored at `key`.
     *
     * @see {@link https://valkey.io/commands/hget/|valkey.io} for details.
     *
     * @param key - The key of the hash.
     * @param field - The field in the hash stored at `key` to retrieve from the database.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns the value associated with `field`, or null when `field` is not present in the hash or `key` does not exist.
     *
     * @example
     * ```typescript
     * // Example usage of the hget method on an-existing field
     * await client.hset("my_hash", {"field": "value"});
     * const result = await client.hget("my_hash", "field");
     * console.log(result); // Output: "value"
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of the hget method on a non-existing field
     * const result = await client.hget("my_hash", "nonexistent_field");
     * console.log(result); // Output: null
     * ```
     */
    hget(key: GlideString, field: GlideString, options?: DecoderOption): Promise<GlideString | null>;
    /** Sets the specified fields to their respective values in the hash stored at `key`.
     *
     * @see {@link https://valkey.io/commands/hset/|valkey.io} for details.
     *
     * @param key - The key of the hash.
     * @param fieldsAndValues - A list of field names and their values.
     * @returns The number of fields that were added.
     *
     * @example
     * ```typescript
     * // Example usage of the hset method using HashDataType as input type
     * const result = await client.hset("my_hash", [{"field": "field1", "value": "value1"}, {"field": "field2", "value": "value2"}]);
     * console.log(result); // Output: 2 - Indicates that 2 fields were successfully set in the hash "my_hash".
     *
     * // Example usage of the hset method using Record<string, GlideString> as input
     * const result = await client.hset("my_hash", {"field1": "value", "field2": "value2"});
     * console.log(result); // Output: 2 - Indicates that 2 fields were successfully set in the hash "my_hash".
     * ```
     */
    hset(key: GlideString, fieldsAndValues: HashDataType | Record<string, GlideString>): Promise<number>;
    /**
     * Returns all field names in the hash stored at `key`.
     *
     * @see {@link https://valkey.io/commands/hkeys/|valkey.io} for details.
     *
     * @param key - The key of the hash.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns A list of field names for the hash, or an empty list when the key does not exist.
     *
     * @example
     * ```typescript
     * // Example usage of the hkeys method:
     * await client.hset("my_hash", {"field1": "value1", "field2": "value2", "field3": "value3"});
     * const result = await client.hkeys("my_hash");
     * console.log(result); // Output: ["field1", "field2", "field3"]  - Returns all the field names stored in the hash "my_hash".
     * ```
     */
    hkeys(key: GlideString, options?: DecoderOption): Promise<GlideString[]>;
    /** Sets `field` in the hash stored at `key` to `value`, only if `field` does not yet exist.
     * If `key` does not exist, a new key holding a hash is created.
     * If `field` already exists, this operation has no effect.
     *
     * @see {@link https://valkey.io/commands/hsetnx/|valkey.io} for more details.
     *
     * @param key - The key of the hash.
     * @param field - The field to set the value for.
     * @param value - The value to set.
     * @returns `true` if the field was set, `false` if the field already existed and was not set.
     *
     * @example
     * ```typescript
     * // Example usage of the hsetnx method
     * const result = await client.hsetnx("my_hash", "field", "value");
     * console.log(result); // Output: true - Indicates that the field "field" was set successfully in the hash "my_hash".
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of the hsetnx method on a field that already exists
     * const result = await client.hsetnx("my_hash", "field", "new_value");
     * console.log(result); // Output: false - Indicates that the field "field" already existed in the hash "my_hash" and was not set again.
     * ```
     */
    hsetnx(key: GlideString, field: GlideString, value: GlideString): Promise<boolean>;
    /** Removes the specified fields from the hash stored at `key`.
     * Specified fields that do not exist within this hash are ignored.
     *
     * @see {@link https://valkey.io/commands/hdel/|valkey.io} for details.
     *
     * @param key - The key of the hash.
     * @param fields - The fields to remove from the hash stored at `key`.
     * @returns the number of fields that were removed from the hash, not including specified but non existing fields.
     * If `key` does not exist, it is treated as an empty hash and it returns 0.
     *
     * @example
     * ```typescript
     * // Example usage of the hdel method
     * const result = await client.hdel("my_hash", ["field1", "field2"]);
     * console.log(result); // Output: 2 - Indicates that two fields were successfully removed from the hash.
     * ```
     */
    hdel(key: GlideString, fields: GlideString[]): Promise<number>;
    /** Returns the values associated with the specified fields in the hash stored at `key`.
     *
     * @see {@link https://valkey.io/commands/hmget/|valkey.io} for details.
     *
     * @param key - The key of the hash.
     * @param fields - The fields in the hash stored at `key` to retrieve from the database.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns a list of values associated with the given fields, in the same order as they are requested.
     * For every field that does not exist in the hash, a null value is returned.
     * If `key` does not exist, it is treated as an empty hash and it returns a list of null values.
     *
     * @example
     * ```typescript
     * // Example usage of the hmget method
     * const result = await client.hmget("my_hash", ["field1", "field2"]);
     * console.log(result); // Output: ["value1", "value2"] - A list of values associated with the specified fields.
     * ```
     */
    hmget(key: GlideString, fields: GlideString[], options?: DecoderOption): Promise<(GlideString | null)[]>;
    /** Returns if `field` is an existing field in the hash stored at `key`.
     *
     * @see {@link https://valkey.io/commands/hexists/|valkey.io} for details.
     *
     * @param key - The key of the hash.
     * @param field - The field to check in the hash stored at `key`.
     * @returns `true` the hash contains `field`. If the hash does not contain `field`, or if `key` does not exist, it returns `false`.
     *
     * @example
     * ```typescript
     * // Example usage of the hexists method with existing field
     * const result = await client.hexists("my_hash", "field1");
     * console.log(result); // Output: true
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of the hexists method with non-existing field
     * const result = await client.hexists("my_hash", "nonexistent_field");
     * console.log(result); // Output: false
     * ```
     */
    hexists(key: GlideString, field: GlideString): Promise<boolean>;
    /**
     * Returns all fields and values of the hash stored at `key`.
     *
     * @see {@link https://valkey.io/commands/hgetall/|valkey.io} for details.
     *
     * @param key - The key of the hash.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns A list of fields and their values stored in the hash.
     * If `key` does not exist, it returns an empty list.
     *
     * @example
     * ```typescript
     * // Example usage of the hgetall method
     * const result = await client.hgetall("my_hash");
     * console.log(result); // Output:
     * // [
     * //     { field: "field1", value: "value1"},
     * //     { field: "field2", value: "value2"}
     * // ]
     * ```
     */
    hgetall(key: GlideString, options?: DecoderOption): Promise<HashDataType>;
    /** Increments the number stored at `field` in the hash stored at `key` by increment.
     * By using a negative increment value, the value stored at `field` in the hash stored at `key` is decremented.
     * If `field` or `key` does not exist, it is set to 0 before performing the operation.
     *
     * @see {@link https://valkey.io/commands/hincrby/|valkey.io} for details.
     *
     * @param key - The key of the hash.
     * @param amount - The amount to increment.
     * @param field - The field in the hash stored at `key` to increment its value.
     * @returns the value of `field` in the hash stored at `key` after the increment.
     *
     * @example
     * ```typescript
     * // Example usage of the hincrby method to increment the value in a hash by a specified amount
     * const result = await client.hincrby("my_hash", "field1", 5);
     * console.log(result); // Output: 5
     * ```
     */
    hincrBy(key: GlideString, field: GlideString, amount: number): Promise<number>;
    /** Increment the string representing a floating point number stored at `field` in the hash stored at `key` by increment.
     * By using a negative increment value, the value stored at `field` in the hash stored at `key` is decremented.
     * If `field` or `key` does not exist, it is set to 0 before performing the operation.
     *
     * @see {@link https://valkey.io/commands/hincrbyfloat/|valkey.io} for details.
     *
     * @param key - The key of the hash.
     * @param amount - The amount to increment.
     * @param field - The field in the hash stored at `key` to increment its value.
     * @returns the value of `field` in the hash stored at `key` after the increment.
     *
     * @example
     * ```typescript
     * // Example usage of the hincrbyfloat method to increment the value of a floating point in a hash by a specified amount
     * const result = await client.hincrbyfloat("my_hash", "field1", 2.5);
     * console.log(result); // Output: 2.5
     * ```
     */
    hincrByFloat(key: GlideString, field: GlideString, amount: number): Promise<number>;
    /** Returns the number of fields contained in the hash stored at `key`.
     *
     * @see {@link https://valkey.io/commands/hlen/|valkey.io} for more details.
     *
     * @param key - The key of the hash.
     * @returns The number of fields in the hash, or 0 when the key does not exist.
     *
     * @example
     * ```typescript
     * // Example usage of the hlen method with an existing key
     * const result = await client.hlen("my_hash");
     * console.log(result); // Output: 3
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of the hlen method with a non-existing key
     * const result = await client.hlen("non_existing_key");
     * console.log(result); // Output: 0
     * ```
     */
    hlen(key: GlideString): Promise<number>;
    /** Returns all values in the hash stored at key.
     *
     * @see {@link https://valkey.io/commands/hvals/|valkey.io} for more details.
     *
     * @param key - The key of the hash.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns a list of values in the hash, or an empty list when the key does not exist.
     *
     * @example
     * ```typescript
     * // Example usage of the hvals method
     * const result = await client.hvals("my_hash");
     * console.log(result); // Output: ["value1", "value2", "value3"] - Returns all the values stored in the hash "my_hash".
     * ```
     */
    hvals(key: GlideString, options?: DecoderOption): Promise<GlideString[]>;
    /**
     * Returns the string length of the value associated with `field` in the hash stored at `key`.
     *
     * @see {@link https://valkey.io/commands/hstrlen/|valkey.io} for details.
     *
     * @param key - The key of the hash.
     * @param field - The field in the hash.
     * @returns The string length or `0` if `field` or `key` does not exist.
     *
     * @example
     * ```typescript
     * await client.hset("my_hash", {"field": "value"});
     * const result = await client.hstrlen("my_hash", "field");
     * console.log(result); // Output: 5
     * ```
     */
    hstrlen(key: GlideString, field: GlideString): Promise<number>;
    /**
     * Returns a random field name from the hash value stored at `key`.
     *
     * @see {@link https://valkey.io/commands/hrandfield/|valkey.io} for more details.
     * @remarks Since Valkey version 6.2.0.
     *
     * @param key - The key of the hash.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns A random field name from the hash stored at `key`, or `null` when
     *     the key does not exist.
     *
     * @example
     * ```typescript
     * console.log(await client.hrandfield("myHash")); // Output: 'field'
     * ```
     */
    hrandfield(key: GlideString, options?: DecoderOption): Promise<GlideString | null>;
    /**
     * Iterates incrementally over a hash.
     *
     * @see {@link https://valkey.io/commands/hscan/|valkey.io} for more details.
     *
     * @param key - The key of the set.
     * @param cursor - The cursor that points to the next iteration of results. A value of `"0"` indicates the start of the search.
     * @param options - (Optional) See {@link HScanOptions} and {@link DecoderOption}.
     * @returns An array of the `cursor` and the subset of the hash held by `key`.
     * The first element is always the `cursor` for the next iteration of results. `"0"` will be the `cursor`
     * returned on the last iteration of the hash. The second element is always an array of the subset of the
     * hash held in `key`. The array in the second element is a flattened series of string pairs,
     * where the value is at even indices and the value is at odd indices.
     * If `options.noValues` is set to `true`, the second element will only contain the fields without the values.
     *
     * @example
     * ```typescript
     * // Assume "key" contains a hash with multiple members
     * let newCursor = "0";
     * let result = [];
     * do {
     *      result = await client.hscan(key1, newCursor, {
     *          match: "*",
     *          count: 3,
     *      });
     *      newCursor = result[0];
     *      console.log("Cursor: ", newCursor);
     *      console.log("Members: ", result[1]);
     * } while (newCursor !== "0");
     * // The output of the code above is something similar to:
     * // Cursor:  31
     * // Members:  ['field 79', 'value 79', 'field 20', 'value 20', 'field 115', 'value 115']
     * // Cursor:  39
     * // Members:  ['field 63', 'value 63', 'field 293', 'value 293', 'field 162', 'value 162']
     * // Cursor:  0
     * // Members:  ['field 55', 'value 55', 'field 24', 'value 24', 'field 90', 'value 90', 'field 113', 'value 113']
     * ```
     * @example
     * ```typescript
     * // Hscan with noValues
     * let newCursor = "0";
     * let result = [];
     * do {
     *      result = await client.hscan(key1, newCursor, {
     *          match: "*",
     *          count: 3,
     *          noValues: true,
     *      });
     *      newCursor = result[0];
     *      console.log("Cursor: ", newCursor);
     *      console.log("Members: ", result[1]);
     * } while (newCursor !== "0");
     * // The output of the code above is something similar to:
     * // Cursor:  31
     * // Members:  ['field 79', 'field 20', 'field 115']
     * // Cursor:  39
     * // Members:  ['field 63', 'field 293', 'field 162']
     * // Cursor:  0
     * // Members:  ['field 55', 'field 24', 'field 90', 'field 113']
     * ```
     */
    hscan(key: GlideString, cursor: string, options?: HScanOptions & DecoderOption): Promise<[string, GlideString[]]>;
    /**
     * Retrieves up to `count` random field names from the hash value stored at `key`.
     *
     * @see {@link https://valkey.io/commands/hrandfield/|valkey.io} for more details.
     * @remarks Since Valkey version 6.2.0.
     *
     * @param key - The key of the hash.
     * @param count - The number of field names to return.
     * @param options - (Optional) See {@link DecoderOption}.
     *
     *     If `count` is positive, returns unique elements. If negative, allows for duplicates.
     * @returns An `array` of random field names from the hash stored at `key`,
     *     or an `empty array` when the key does not exist.
     *
     * @example
     * ```typescript
     * console.log(await client.hrandfieldCount("myHash", 2)); // Output: ['field1', 'field2']
     * ```
     */
    hrandfieldCount(key: GlideString, count: number, options?: DecoderOption): Promise<GlideString[]>;
    /**
     * Retrieves up to `count` random field names along with their values from the hash
     * value stored at `key`.
     *
     * @see {@link https://valkey.io/commands/hrandfield/|valkey.io} for more details.
     * @remarks Since Valkey version 6.2.0.
     *
     * @param key - The key of the hash.
     * @param count - The number of field names to return.
     * @param options - (Optional) See {@link DecoderOption}.
     *
     *     If `count` is positive, returns unique elements. If negative, allows for duplicates.
     * @returns A 2D `array` of `[fieldName, value]` `arrays`, where `fieldName` is a random
     *     field name from the hash and `value` is the associated value of the field name.
     *     If the hash does not exist or is empty, the response will be an empty `array`.
     *
     * @example
     * ```typescript
     * const result = await client.hrandfieldCountWithValues("myHash", 2);
     * console.log(result); // Output: [['field1', 'value1'], ['field2', 'value2']]
     * ```
     */
    hrandfieldWithValues(key: GlideString, count: number, options?: DecoderOption): Promise<[GlideString, GlideString][]>;
    /** Inserts all the specified values at the head of the list stored at `key`.
     * `elements` are inserted one after the other to the head of the list, from the leftmost element to the rightmost element.
     * If `key` does not exist, it is created as empty list before performing the push operations.
     *
     * @see {@link https://valkey.io/commands/lpush/|valkey.io} for details.
     *
     * @param key - The key of the list.
     * @param elements - The elements to insert at the head of the list stored at `key`.
     * @returns the length of the list after the push operations.
     *
     * @example
     * ```typescript
     * // Example usage of the lpush method with an existing list
     * const result = await client.lpush("my_list", ["value2", "value3"]);
     * console.log(result); // Output: 3 - Indicated that the new length of the list is 3 after the push operation.
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of the lpush method with a non-existing list
     * const result = await client.lpush("nonexistent_list", ["new_value"]);
     * console.log(result); // Output: 1 - Indicates that a new list was created with one element
     * ```
     */
    lpush(key: GlideString, elements: GlideString[]): Promise<number>;
    /**
     * Inserts specified values at the head of the `list`, only if `key` already
     * exists and holds a list.
     *
     * @see {@link https://valkey.io/commands/lpushx/|valkey.io} for details.
     *
     * @param key - The key of the list.
     * @param elements - The elements to insert at the head of the list stored at `key`.
     * @returns The length of the list after the push operation.
     * @example
     * ```typescript
     * const listLength = await client.lpushx("my_list", ["value1", "value2"]);
     * console.log(result); // Output: 2 - Indicates that the list has two elements.
     * ```
     */
    lpushx(key: GlideString, elements: GlideString[]): Promise<number>;
    /** Removes and returns the first elements of the list stored at `key`.
     * The command pops a single element from the beginning of the list.
     *
     * @see {@link https://valkey.io/commands/lpop/|valkey.io} for details.
     *
     * @param key - The key of the list.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns The value of the first element.
     * If `key` does not exist null will be returned.
     *
     * @example
     * ```typescript
     * // Example usage of the lpop method with an existing list
     * const result = await client.lpop("my_list");
     * console.log(result); // Output: 'value1'
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of the lpop method with a non-existing list
     * const result = await client.lpop("non_exiting_key");
     * console.log(result); // Output: null
     * ```
     */
    lpop(key: GlideString, options?: DecoderOption): Promise<GlideString | null>;
    /** Removes and returns up to `count` elements of the list stored at `key`, depending on the list's length.
     *
     * @see {@link https://valkey.io/commands/lpop/|valkey.io} for details.
     *
     * @param key - The key of the list.
     * @param count - The count of the elements to pop from the list.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns A list of the popped elements will be returned depending on the list's length.
     * If `key` does not exist null will be returned.
     *
     * @example
     * ```typescript
     * // Example usage of the lpopCount method with an existing list
     * const result = await client.lpopCount("my_list", 2);
     * console.log(result); // Output: ["value1", "value2"]
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of the lpopCount method with a non-existing list
     * const result = await client.lpopCount("non_exiting_key", 3);
     * console.log(result); // Output: null
     * ```
     */
    lpopCount(key: GlideString, count: number, options?: DecoderOption): Promise<GlideString[] | null>;
    /** Returns the specified elements of the list stored at `key`.
     * The offsets `start` and `end` are zero-based indexes, with 0 being the first element of the list, 1 being the next element and so on.
     * These offsets can also be negative numbers indicating offsets starting at the end of the list,
     * with -1 being the last element of the list, -2 being the penultimate, and so on.
     *
     * @see {@link https://valkey.io/commands/lrange/|valkey.io} for details.
     *
     * @param key - The key of the list.
     * @param start - The starting point of the range.
     * @param end - The end of the range.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns list of elements in the specified range.
     * If `start` exceeds the end of the list, or if `start` is greater than `end`, an empty list will be returned.
     * If `end` exceeds the actual end of the list, the range will stop at the actual end of the list.
     * If `key` does not exist an empty list will be returned.
     *
     * @example
     * ```typescript
     * // Example usage of the lrange method with an existing list and positive indices
     * const result = await client.lrange("my_list", 0, 2);
     * console.log(result); // Output: ["value1", "value2", "value3"]
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of the lrange method with an existing list and negative indices
     * const result = await client.lrange("my_list", -2, -1);
     * console.log(result); // Output: ["value2", "value3"]
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of the lrange method with a non-existing list
     * const result = await client.lrange("non_exiting_key", 0, 2);
     * console.log(result); // Output: []
     * ```
     */
    lrange(key: GlideString, start: number, end: number, options?: DecoderOption): Promise<GlideString[]>;
    /** Returns the length of the list stored at `key`.
     *
     * @see {@link https://valkey.io/commands/llen/|valkey.io} for details.
     *
     * @param key - The key of the list.
     * @returns the length of the list at `key`.
     * If `key` does not exist, it is interpreted as an empty list and 0 is returned.
     *
     * @example
     * ```typescript
     * // Example usage of the llen method
     * const result = await client.llen("my_list");
     * console.log(result); // Output: 3 - Indicates that there are 3 elements in the list.
     * ```
     */
    llen(key: GlideString): Promise<number>;
    /**
     * Atomically pops and removes the left/right-most element to the list stored at `source`
     * depending on `whereTo`, and pushes the element at the first/last element of the list
     * stored at `destination` depending on `whereFrom`, see {@link ListDirection}.
     *
     * @see {@link https://valkey.io/commands/lmove/|valkey.io} for details.
     * @remarks Since Valkey version 6.2.0.
     *
     * @param source - The key to the source list.
     * @param destination - The key to the destination list.
     * @param whereFrom - The {@link ListDirection} to remove the element from.
     * @param whereTo - The {@link ListDirection} to add the element to.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns The popped element, or `null` if `source` does not exist.
     *
     * @example
     * ```typescript
     * await client.lpush("testKey1", ["two", "one"]);
     * await client.lpush("testKey2", ["four", "three"]);
     *
     * const result1 = await client.lmove("testKey1", "testKey2", ListDirection.LEFT, ListDirection.LEFT);
     * console.log(result1); // Output: "one".
     *
     * const updated_array_key1 = await client.lrange("testKey1", 0, -1);
     * console.log(updated_array); // Output: "two".
     *
     * const updated_array_key2 = await client.lrange("testKey2", 0, -1);
     * console.log(updated_array_key2); // Output: ["one", "three", "four"].
     * ```
     */
    lmove(source: GlideString, destination: GlideString, whereFrom: ListDirection, whereTo: ListDirection, options?: DecoderOption): Promise<GlideString | null>;
    /**
     * Blocks the connection until it pops atomically and removes the left/right-most element to the
     * list stored at `source` depending on `whereFrom`, and pushes the element at the first/last element
     * of the list stored at `destination` depending on `whereTo`.
     * `BLMOVE` is the blocking variant of {@link lmove}.
     *
     * @see {@link https://valkey.io/commands/blmove/|valkey.io} for details.
     * @remarks When in cluster mode, both `source` and `destination` must map to the same hash slot.
     * @remarks `BLMOVE` is a client blocking command, see {@link https://github.com/valkey-io/valkey-glide/wiki/General-Concepts#blocking-commands|Valkey Glide Wiki} for more details and best practices.
     * @remarks Since Valkey version 6.2.0.
     *
     * @param source - The key to the source list.
     * @param destination - The key to the destination list.
     * @param whereFrom - The {@link ListDirection} to remove the element from.
     * @param whereTo - The {@link ListDirection} to add the element to.
     * @param timeout - The number of seconds to wait for a blocking operation to complete. A value of `0` will block indefinitely.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns The popped element, or `null` if `source` does not exist or if the operation timed-out.
     *
     * @example
     * ```typescript
     * await client.lpush("testKey1", ["two", "one"]);
     * await client.lpush("testKey2", ["four", "three"]);
     * const result = await client.blmove("testKey1", "testKey2", ListDirection.LEFT, ListDirection.LEFT, 0.1);
     * console.log(result); // Output: "one"
     *
     * const result2 = await client.lrange("testKey1", 0, -1);
     * console.log(result2);   // Output: "two"
     *
     * const updated_array2 = await client.lrange("testKey2", 0, -1);
     * console.log(updated_array2); // Output: ["one", "three", "four"]
     * ```
     */
    blmove(source: GlideString, destination: GlideString, whereFrom: ListDirection, whereTo: ListDirection, timeout: number, options?: DecoderOption): Promise<GlideString | null>;
    /**
     * Sets the list element at `index` to `element`.
     * The index is zero-based, so `0` means the first element, `1` the second element and so on.
     * Negative indices can be used to designate elements starting at the tail of
     * the list. Here, `-1` means the last element, `-2` means the penultimate and so forth.
     *
     * @see {@link https://valkey.io/commands/lset/|valkey.io} for details.
     *
     * @param key - The key of the list.
     * @param index - The index of the element in the list to be set.
     * @param element - The new element to set at the specified index.
     * @returns Always "OK".
     *
     * @example
     * ```typescript
     * // Example usage of the lset method
     * const response = await client.lset("test_key", 1, "two");
     * console.log(response); // Output: 'OK' - Indicates that the second index of the list has been set to "two".
     * ```
     */
    lset(key: GlideString, index: number, element: GlideString): Promise<"OK">;
    /** Trim an existing list so that it will contain only the specified range of elements specified.
     * The offsets `start` and `end` are zero-based indexes, with 0 being the first element of the list, 1 being the next element and so on.
     * These offsets can also be negative numbers indicating offsets starting at the end of the list,
     * with -1 being the last element of the list, -2 being the penultimate, and so on.
     *
     * @see {@link https://valkey.io/commands/ltrim/|valkey.io} for details.
     *
     * @param key - The key of the list.
     * @param start - The starting point of the range.
     * @param end - The end of the range.
     * @returns always "OK".
     * If `start` exceeds the end of the list, or if `start` is greater than `end`, the result will be an empty list (which causes key to be removed).
     * If `end` exceeds the actual end of the list, it will be treated like the last element of the list.
     * If `key` does not exist the command will be ignored.
     *
     * @example
     * ```typescript
     * // Example usage of the ltrim method
     * const result = await client.ltrim("my_list", 0, 1);
     * console.log(result); // Output: 'OK' - Indicates that the list has been trimmed to contain elements from 0 to 1.
     * ```
     */
    ltrim(key: GlideString, start: number, end: number): Promise<"OK">;
    /** Removes the first `count` occurrences of elements equal to `element` from the list stored at `key`.
     * If `count` is positive : Removes elements equal to `element` moving from head to tail.
     * If `count` is negative : Removes elements equal to `element` moving from tail to head.
     * If `count` is 0 or `count` is greater than the occurrences of elements equal to `element`: Removes all elements equal to `element`.
     *
     * @param key - The key of the list.
     * @param count - The count of the occurrences of elements equal to `element` to remove.
     * @param element - The element to remove from the list.
     * @returns the number of the removed elements.
     * If `key` does not exist, 0 is returned.
     *
     * @example
     * ```typescript
     * // Example usage of the lrem method
     * const result = await client.lrem("my_list", 2, "value");
     * console.log(result); // Output: 2 - Removes the first 2 occurrences of "value" in the list.
     * ```
     */
    lrem(key: GlideString, count: number, element: GlideString): Promise<number>;
    /** Inserts all the specified values at the tail of the list stored at `key`.
     * `elements` are inserted one after the other to the tail of the list, from the leftmost element to the rightmost element.
     * If `key` does not exist, it is created as empty list before performing the push operations.
     *
     * @see {@link https://valkey.io/commands/rpush/|valkey.io} for details.
     *
     * @param key - The key of the list.
     * @param elements - The elements to insert at the tail of the list stored at `key`.
     * @returns the length of the list after the push operations.
     *
     * @example
     * ```typescript
     * // Example usage of the rpush method with an existing list
     * const result = await client.rpush("my_list", ["value2", "value3"]);
     * console.log(result); // Output: 3 - Indicates that the new length of the list is 3 after the push operation.
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of the rpush method with a non-existing list
     * const result = await client.rpush("nonexistent_list", ["new_value"]);
     * console.log(result); // Output: 1
     * ```
     */
    rpush(key: GlideString, elements: GlideString[]): Promise<number>;
    /**
     * Inserts specified values at the tail of the `list`, only if `key` already
     * exists and holds a list.
     *
     * @see {@link https://valkey.io/commands/rpushx/|valkey.io} for details.
     *
     * @param key - The key of the list.
     * @param elements - The elements to insert at the tail of the list stored at `key`.
     * @returns The length of the list after the push operation.
     * @example
     * ```typescript
     * const result = await client.rpushx("my_list", ["value1", "value2"]);
     * console.log(result);  // Output: 2 - Indicates that the list has two elements.
     * ```
     * */
    rpushx(key: GlideString, elements: GlideString[]): Promise<number>;
    /** Removes and returns the last elements of the list stored at `key`.
     * The command pops a single element from the end of the list.
     *
     * @see {@link https://valkey.io/commands/rpop/|valkey.io} for details.
     *
     * @param key - The key of the list.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns The value of the last element.
     * If `key` does not exist null will be returned.
     *
     * @example
     * ```typescript
     * // Example usage of the rpop method with an existing list
     * const result = await client.rpop("my_list");
     * console.log(result); // Output: 'value1'
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of the rpop method with a non-existing list
     * const result = await client.rpop("non_exiting_key");
     * console.log(result); // Output: null
     * ```
     */
    rpop(key: GlideString, options?: DecoderOption): Promise<GlideString | null>;
    /** Removes and returns up to `count` elements from the list stored at `key`, depending on the list's length.
     *
     * @see {@link https://valkey.io/commands/rpop/|valkey.io} for details.
     *
     * @param key - The key of the list.
     * @param count - The count of the elements to pop from the list.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns A list of popped elements will be returned depending on the list's length.
     * If `key` does not exist null will be returned.
     *
     * @example
     * ```typescript
     * // Example usage of the rpopCount method with an existing list
     * const result = await client.rpopCount("my_list", 2);
     * console.log(result); // Output: ["value1", "value2"]
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of the rpopCount method with a non-existing list
     * const result = await client.rpopCount("non_exiting_key", 7);
     * console.log(result); // Output: null
     * ```
     */
    rpopCount(key: GlideString, count: number, options?: DecoderOption): Promise<GlideString[] | null>;
    /** Adds the specified members to the set stored at `key`. Specified members that are already a member of this set are ignored.
     * If `key` does not exist, a new set is created before adding `members`.
     *
     * @see {@link https://valkey.io/commands/sadd/|valkey.io} for details.
     *
     * @param key - The key to store the members to its set.
     * @param members - A list of members to add to the set stored at `key`.
     * @returns The number of members that were added to the set, not including all the members already present in the set.
     *
     * @example
     * ```typescript
     * // Example usage of the sadd method with an existing set
     * const result = await client.sadd("my_set", ["member1", "member2"]);
     * console.log(result); // Output: 2
     * ```
     */
    sadd(key: GlideString, members: GlideString[]): Promise<number>;
    /** Removes the specified members from the set stored at `key`. Specified members that are not a member of this set are ignored.
     *
     * @see {@link https://valkey.io/commands/srem/|valkey.io} for details.
     *
     * @param key - The key to remove the members from its set.
     * @param members - A list of members to remove from the set stored at `key`.
     * @returns The number of members that were removed from the set, not including non existing members.
     * If `key` does not exist, it is treated as an empty set and this command returns 0.
     *
     * @example
     * ```typescript
     * // Example usage of the srem method
     * const result = await client.srem("my_set", ["member1", "member2"]);
     * console.log(result); // Output: 2
     * ```
     */
    srem(key: GlideString, members: GlideString[]): Promise<number>;
    /**
     * Iterates incrementally over a set.
     *
     * @see {@link https://valkey.io/commands/sscan} for details.
     *
     * @param key - The key of the set.
     * @param cursor - The cursor that points to the next iteration of results. A value of `"0"` indicates the start of the search.
     * @param options - (Optional) See {@link BaseScanOptions} and {@link DecoderOption}.
     * @returns An array of the cursor and the subset of the set held by `key`. The first element is always the `cursor` and for the next iteration of results.
     * The `cursor` will be `"0"` on the last iteration of the set. The second element is always an array of the subset of the set held in `key`.
     *
     * @example
     * ```typescript
     * // Assume key contains a set with 200 members
     * let newCursor = "0";
     * let result = [];
     *
     * do {
     *      result = await client.sscan(key1, newCursor, {
     *      match: "*",
     *      count: 5,
     * });
     *      newCursor = result[0];
     *      console.log("Cursor: ", newCursor);
     *      console.log("Members: ", result[1]);
     * } while (newCursor !== "0");
     *
     * // The output of the code above is something similar to:
     * // Cursor:  8, Match: "f*"
     * // Members:  ['field', 'fur', 'fun', 'fame']
     * // Cursor:  20, Count: 3
     * // Members:  ['1', '2', '3', '4', '5', '6']
     * // Cursor:  0
     * // Members:  ['1', '2', '3', '4', '5', '6']
     * ```
     */
    sscan(key: GlideString, cursor: GlideString, options?: BaseScanOptions & DecoderOption): Promise<[GlideString, GlideString[]]>;
    /** Returns all the members of the set value stored at `key`.
     *
     * @see {@link https://valkey.io/commands/smembers/|valkey.io} for details.
     *
     * @param key - The key to return its members.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns A `Set` containing all members of the set.
     * If `key` does not exist, it is treated as an empty set and this command returns an empty `Set`.
     *
     * @example
     * ```typescript
     * // Example usage of the smembers method
     * const result = await client.smembers("my_set");
     * console.log(result); // Output: Set {'member1', 'member2', 'member3'}
     * ```
     */
    smembers(key: GlideString, options?: DecoderOption): Promise<Set<GlideString>>;
    /** Moves `member` from the set at `source` to the set at `destination`, removing it from the source set.
     * Creates a new destination set if needed. The operation is atomic.
     *
     * @see {@link https://valkey.io/commands/smove/|valkey.io} for more details.
     * @remarks When in cluster mode, `source` and `destination` must map to the same hash slot.
     *
     * @param source - The key of the set to remove the element from.
     * @param destination - The key of the set to add the element to.
     * @param member - The set element to move.
     * @returns `true` on success, or `false` if the `source` set does not exist or the element is not a member of the source set.
     *
     * @example
     * ```typescript
     * const result = await client.smove("set1", "set2", "member1");
     * console.log(result); // Output: true - "member1" was moved from "set1" to "set2".
     * ```
     */
    smove(source: GlideString, destination: GlideString, member: GlideString): Promise<boolean>;
    /** Returns the set cardinality (number of elements) of the set stored at `key`.
     *
     * @see {@link https://valkey.io/commands/scard/|valkey.io} for details.
     *
     * @param key - The key to return the number of its members.
     * @returns The cardinality (number of elements) of the set, or 0 if key does not exist.
     *
     * @example
     * ```typescript
     * // Example usage of the scard method
     * const result = await client.scard("my_set");
     * console.log(result); // Output: 3
     * ```
     */
    scard(key: GlideString): Promise<number>;
    /** Gets the intersection of all the given sets.
     *
     * @see {@link https://valkey.io/docs/latest/commands/sinter/|valkey.io} for more details.
     * @remarks When in cluster mode, all `keys` must map to the same hash slot.
     *
     * @param keys - The `keys` of the sets to get the intersection.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns - A set of members which are present in all given sets.
     * If one or more sets do not exist, an empty set will be returned.
     *
     * @example
     * ```typescript
     * // Example usage of sinter method when member exists
     * const result = await client.sinter(["my_set1", "my_set2"]);
     * console.log(result); // Output: Set {'member2'} - Indicates that sets have one common member
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of sinter method with non-existing key
     * const result = await client.sinter(["my_set", "non_existing_key"]);
     * console.log(result); // Output: Set {} - An empty set is returned since the key does not exist.
     * ```
     */
    sinter(keys: GlideString[], options?: DecoderOption): Promise<Set<GlideString>>;
    /**
     * Gets the cardinality of the intersection of all the given sets.
     *
     * @see {@link https://valkey.io/commands/sintercard/|valkey.io} for more details.
     * @remarks When in cluster mode, all `keys` must map to the same hash slot.
     * @remarks Since Valkey version 7.0.0.
     *
     * @param keys - The keys of the sets.
     * @param options - (Optional) Additional parameters:
     * - (Optional) `limit`: the limit for the intersection cardinality value. If not specified, or set to `0`, no limit is used.
     * @returns The cardinality of the intersection result. If one or more sets do not exist, `0` is returned.
     *
     * @example
     * ```typescript
     * await client.sadd("set1", ["a", "b", "c"]);
     * await client.sadd("set2", ["b", "c", "d"]);
     * const result1 = await client.sintercard(["set1", "set2"]);
     * console.log(result1); // Output: 2 - The intersection of "set1" and "set2" contains 2 elements: "b" and "c".
     *
     * const result2 = await client.sintercard(["set1", "set2"], { limit: 1 });
     * console.log(result2); // Output: 1 - The computation stops early as the intersection cardinality reaches the limit of 1.
     * ```
     */
    sintercard(keys: GlideString[], options?: {
        limit?: number;
    }): Promise<number>;
    /**
     * Stores the members of the intersection of all given sets specified by `keys` into a new set at `destination`.
     *
     * @see {@link https://valkey.io/commands/sinterstore/|valkey.io} for more details.
     * @remarks When in cluster mode, `destination` and all `keys` must map to the same hash slot.
     *
     * @param destination - The key of the destination set.
     * @param keys - The keys from which to retrieve the set members.
     * @returns The number of elements in the resulting set.
     *
     * @example
     * ```typescript
     * const result = await client.sinterstore("my_set", ["set1", "set2"]);
     * console.log(result); // Output: 2 - Two elements were stored at "my_set", and those elements are the intersection of "set1" and "set2".
     * ```
     */
    sinterstore(destination: GlideString, keys: GlideString[]): Promise<number>;
    /**
     * Computes the difference between the first set and all the successive sets in `keys`.
     *
     * @see {@link https://valkey.io/commands/sdiff/|valkey.io} for more details.
     * @remarks When in cluster mode, all `keys` must map to the same hash slot.
     *
     * @param keys - The keys of the sets to diff.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns A `Set` of elements representing the difference between the sets.
     * If a key in `keys` does not exist, it is treated as an empty set.
     *
     * @example
     * ```typescript
     * await client.sadd("set1", ["member1", "member2"]);
     * await client.sadd("set2", ["member1"]);
     * const result = await client.sdiff(["set1", "set2"]);
     * console.log(result); // Output: Set {"member1"} - "member2" is in "set1" but not "set2"
     * ```
     */
    sdiff(keys: GlideString[], options?: DecoderOption): Promise<Set<GlideString>>;
    /**
     * Stores the difference between the first set and all the successive sets in `keys` into a new set at `destination`.
     *
     * @see {@link https://valkey.io/commands/sdiffstore/|valkey.io} for more details.
     * @remarks When in cluster mode, `destination` and all `keys` must map to the same hash slot.
     *
     * @param destination - The key of the destination set.
     * @param keys - The keys of the sets to diff.
     * @returns The number of elements in the resulting set.
     *
     * @example
     * ```typescript
     * await client.sadd("set1", ["member1", "member2"]);
     * await client.sadd("set2", ["member1"]);
     * const result = await client.sdiffstore("set3", ["set1", "set2"]);
     * console.log(result); // Output: 1 - One member was stored in "set3", and that member is the diff between "set1" and "set2".
     * ```
     */
    sdiffstore(destination: GlideString, keys: GlideString[]): Promise<number>;
    /**
     * Gets the union of all the given sets.
     *
     * @see {@link https://valkey.io/commands/sunion/|valkey.io} for more details.
     * @remarks When in cluster mode, all `keys` must map to the same hash slot.
     *
     * @param keys - The keys of the sets.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns A `Set` of members which are present in at least one of the given sets.
     * If none of the sets exist, an empty `Set` will be returned.
     *
     * @example
     * ```typescript
     * await client.sadd("my_set1", ["member1", "member2"]);
     * await client.sadd("my_set2", ["member2", "member3"]);
     * const result1 = await client.sunion(["my_set1", "my_set2"]);
     * console.log(result1); // Output: Set {'member1', 'member2', 'member3'} - Sets "my_set1" and "my_set2" have three unique members.
     *
     * const result2 = await client.sunion(["my_set1", "non_existing_set"]);
     * console.log(result2); // Output: Set {'member1', 'member2'}
     * ```
     */
    sunion(keys: GlideString[], options?: DecoderOption): Promise<Set<GlideString>>;
    /**
     * Stores the members of the union of all given sets specified by `keys` into a new set
     * at `destination`.
     *
     * @see {@link https://valkey.io/commands/sunionstore/|valkey.io} for details.
     * @remarks When in cluster mode, `destination` and all `keys` must map to the same hash slot.
     *
     * @param destination - The key of the destination set.
     * @param keys - The keys from which to retrieve the set members.
     * @returns The number of elements in the resulting set.
     *
     * @example
     * ```typescript
     * const length = await client.sunionstore("mySet", ["set1", "set2"]);
     * console.log(length); // Output: 2 - Two elements were stored in "mySet", and those two members are the union of "set1" and "set2".
     * ```
     */
    sunionstore(destination: GlideString, keys: GlideString[]): Promise<number>;
    /** Returns if `member` is a member of the set stored at `key`.
     *
     * @see {@link https://valkey.io/commands/sismember/|valkey.io} for more details.
     *
     * @param key - The key of the set.
     * @param member - The member to check for existence in the set.
     * @returns `true` if the member exists in the set, `false` otherwise.
     * If `key` doesn't exist, it is treated as an empty set and the command returns `false`.
     *
     * @example
     * ```typescript
     * // Example usage of the sismember method when member exists
     * const result = await client.sismember("my_set", "member1");
     * console.log(result); // Output: true - Indicates that "member1" exists in the set "my_set".
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of the sismember method when member does not exist
     * const result = await client.sismember("my_set", "non_existing_member");
     * console.log(result); // Output: false - Indicates that "non_existing_member" does not exist in the set "my_set".
     * ```
     */
    sismember(key: GlideString, member: GlideString): Promise<boolean>;
    /**
     * Checks whether each member is contained in the members of the set stored at `key`.
     *
     * @see {@link https://valkey.io/commands/smismember/|valkey.io} for more details.
     * @remarks Since Valkey version 6.2.0.
     *
     * @param key - The key of the set to check.
     * @param members - A list of members to check for existence in the set.
     * @returns An `array` of `boolean` values, each indicating if the respective member exists in the set.
     *
     * @example
     * ```typescript
     * await client.sadd("set1", ["a", "b", "c"]);
     * const result = await client.smismember("set1", ["b", "c", "d"]);
     * console.log(result); // Output: [true, true, false] - "b" and "c" are members of "set1", but "d" is not.
     * ```
     */
    smismember(key: GlideString, members: GlideString[]): Promise<boolean[]>;
    /** Removes and returns one random member from the set value store at `key`.
     * To pop multiple members, see {@link spopCount}.
     *
     * @see {@link https://valkey.io/commands/spop/|valkey.io} for details.
     *
     * @param key - The key of the set.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns the value of the popped member.
     * If `key` does not exist, null will be returned.
     *
     * @example
     * ```typescript
     * // Example usage of spop method to remove and return a random member from a set
     * const result = await client.spop("my_set");
     * console.log(result); // Output: 'member1' - Removes and returns a random member from the set "my_set".
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of spop method with non-existing key
     * const result = await client.spop("non_existing_key");
     * console.log(result); // Output: null
     * ```
     */
    spop(key: GlideString, options?: DecoderOption): Promise<GlideString | null>;
    /** Removes and returns up to `count` random members from the set value store at `key`, depending on the set's length.
     *
     * @see {@link https://valkey.io/commands/spop/|valkey.io} for details.
     *
     * @param key - The key of the set.
     * @param count - The count of the elements to pop from the set.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns A `Set` containing the popped elements, depending on the set's length.
     * If `key` does not exist, an empty `Set` will be returned.
     *
     * @example
     * ```typescript
     * // Example usage of spopCount method to remove and return multiple random members from a set
     * const result = await client.spopCount("my_set", 2);
     * console.log(result); // Output: Set {'member2', 'member3'} - Removes and returns 2 random members from the set "my_set".
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of spopCount method with non-existing key
     * const result = await client.spopCount("non_existing_key");
     * console.log(result); // Output: Set {} - An empty set is returned since the key does not exist.
     * ```
     */
    spopCount(key: GlideString, count: number, options?: DecoderOption): Promise<Set<GlideString>>;
    /**
     * Returns a random element from the set value stored at `key`.
     *
     * @see {@link https://valkey.io/commands/srandmember/|valkey.io} for more details.
     *
     * @param key - The key from which to retrieve the set member.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns A random element from the set, or null if `key` does not exist.
     *
     * @example
     * ```typescript
     * // Example usage of srandmember method to return a random member from a set
     * const result = await client.srandmember("my_set");
     * console.log(result); // Output: 'member1' - A random member of "my_set".
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of srandmember method with non-existing key
     * const result = await client.srandmember("non_existing_set");
     * console.log(result); // Output: null
     * ```
     */
    srandmember(key: GlideString, options?: DecoderOption): Promise<GlideString | null>;
    /**
     * Returns one or more random elements from the set value stored at `key`.
     *
     * @see {@link https://valkey.io/commands/srandmember/|valkey.io} for more details.
     *
     * @param key - The key of the sorted set.
     * @param count - The number of members to return.
     *                If `count` is positive, returns unique members.
     *                If `count` is negative, allows for duplicates members.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns a list of members from the set. If the set does not exist or is empty, an empty list will be returned.
     *
     * @example
     * ```typescript
     * // Example usage of srandmemberCount method to return multiple random members from a set
     * const result = await client.srandmemberCount("my_set", -3);
     * console.log(result); // Output: ['member1', 'member1', 'member2'] - Random members of "my_set".
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of srandmemberCount method with non-existing key
     * const result = await client.srandmemberCount("non_existing_set", 3);
     * console.log(result); // Output: [] - An empty list since the key does not exist.
     * ```
     */
    srandmemberCount(key: GlideString, count: number, options?: DecoderOption): Promise<GlideString[]>;
    /**
     * Returns the number of keys in `keys` that exist in the database.
     *
     * @remarks In cluster mode, if keys in `keys` map to different hash slots,
     * the command will be split across these slots and executed separately for each.
     * This means the command is atomic only at the slot level. If one or more slot-specific
     * requests fail, the entire call will return the first encountered error, even
     * though some requests may have succeeded while others did not.
     * If this behavior impacts your application logic, consider splitting the
     * request into sub-requests per slot to ensure atomicity.
     *
     * @see {@link https://valkey.io/commands/exists/|valkey.io} for details.
     *
     * @param keys - The keys list to check.
     * @returns The number of keys that exist. If the same existing key is mentioned in `keys` multiple times,
     * it will be counted multiple times.
     *
     * @example
     * ```typescript
     * // Example usage of the exists method
     * const result = await client.exists(["key1", "key2", "key3"]);
     * console.log(result); // Output: 3 - Indicates that all three keys exist in the database.
     * ```
     */
    exists(keys: GlideString[]): Promise<number>;
    /**
     * Removes the specified keys. A key is ignored if it does not exist.
     * This command, similar to {@link del}, removes specified keys and ignores non-existent ones.
     * However, this command does not block the server, while {@link https://valkey.io/commands/del|`DEL`} does.
     *
     * @remarks In cluster mode, if keys in `keys` map to different hash slots,
     * the command will be split across these slots and executed separately for each.
     * This means the command is atomic only at the slot level. If one or more slot-specific
     * requests fail, the entire call will return the first encountered error, even
     * though some requests may have succeeded while others did not.
     * If this behavior impacts your application logic, consider splitting the
     * request into sub-requests per slot to ensure atomicity.
     *
     * @see {@link https://valkey.io/commands/unlink/|valkey.io} for details.
     *
     * @param keys - The keys we wanted to unlink.
     * @returns The number of keys that were unlinked.
     *
     * @example
     * ```typescript
     * // Example usage of the unlink method
     * const result = await client.unlink(["key1", "key2", "key3"]);
     * console.log(result); // Output: 3 - Indicates that all three keys were unlinked from the database.
     * ```
     */
    unlink(keys: GlideString[]): Promise<number>;
    /**
     * Sets a timeout on `key` in seconds. After the timeout has expired, the key will automatically be deleted.
     * If `key` already has an existing expire set, the time to live is updated to the new value.
     * If `seconds` is non-positive number, the key will be deleted rather than expired.
     * The timeout will only be cleared by commands that delete or overwrite the contents of `key`.
     *
     * @see {@link https://valkey.io/commands/expire/|valkey.io} for details.
     *
     * @param key - The key to set timeout on it.
     * @param seconds - The timeout in seconds.
     * @param options - (Optional) Additional parameters:
     * - (Optional) `expireOption`: the expire option - see {@link ExpireOptions}.
     * @returns `true` if the timeout was set. `false` if the timeout was not set. e.g. key doesn't exist,
     * or operation skipped due to the provided arguments.
     *
     * @example
     * ```typescript
     * // Example usage of the expire method
     * const result = await client.expire("my_key", 60);
     * console.log(result); // Output: true - Indicates that a timeout of 60 seconds has been set for "my_key".
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of the expire method with exisiting expiry
     * const result = await client.expire("my_key", 60, { expireOption: ExpireOptions.HasNoExpiry });
     * console.log(result); // Output: false - Indicates that "my_key" has an existing expiry.
     * ```
     */
    expire(key: GlideString, seconds: number, options?: {
        expireOption?: ExpireOptions;
    }): Promise<boolean>;
    /**
     * Sets a timeout on `key`. It takes an absolute Unix timestamp (seconds since January 1, 1970) instead of specifying the number of seconds.
     * A timestamp in the past will delete the key immediately. After the timeout has expired, the key will automatically be deleted.
     * If `key` already has an existing expire set, the time to live is updated to the new value.
     * The timeout will only be cleared by commands that delete or overwrite the contents of `key`.
     *
     * @see {@link https://valkey.io/commands/expireat/|valkey.io} for details.
     *
     * @param key - The key to set timeout on it.
     * @param unixSeconds - The timeout in an absolute Unix timestamp.
     * @param options - (Optional) Additional parameters:
     * - (Optional) `expireOption`: the expire option - see {@link ExpireOptions}.
     * @returns `true` if the timeout was set. `false` if the timeout was not set. e.g. key doesn't exist,
     * or operation skipped due to the provided arguments.
     *
     * @example
     * ```typescript
     * // Example usage of the expireAt method on a key with no previous expiry
     * const result = await client.expireAt("my_key", 1672531200, { expireOption: ExpireOptions.HasNoExpiry });
     * console.log(result); // Output: true - Indicates that the expiration time for "my_key" was successfully set.
     * ```
     */
    expireAt(key: GlideString, unixSeconds: number, options?: {
        expireOption?: ExpireOptions;
    }): Promise<boolean>;
    /**
     * Returns the absolute Unix timestamp (since January 1, 1970) at which the given `key` will expire, in seconds.
     * To get the expiration with millisecond precision, use {@link pexpiretime}.
     *
     * @see {@link https://valkey.io/commands/expiretime/|valkey.io} for details.
     * @remarks Since Valkey version 7.0.0.
     *
     * @param key - The `key` to determine the expiration value of.
     * @returns The expiration Unix timestamp in seconds, `-2` if `key` does not exist or `-1` if `key` exists but has no associated expire.
     *
     * @example
     * ```typescript
     * const result1 = await client.expiretime("myKey");
     * console.log(result1); // Output: -2 - myKey doesn't exist.
     *
     * const result2 = await client.set(myKey, "value");
     * const result3 = await client.expireTime(myKey);
     * console.log(result2); // Output: -1 - myKey has no associated expiration.
     *
     * client.expire(myKey, 60);
     * const result3 = await client.expireTime(myKey);
     * console.log(result3); // Output: 123456 - the Unix timestamp (in seconds) when "myKey" will expire.
     * ```
     */
    expiretime(key: GlideString): Promise<number>;
    /**
     * Sets a timeout on `key` in milliseconds. After the timeout has expired, the key will automatically be deleted.
     * If `key` already has an existing expire set, the time to live is updated to the new value.
     * If `milliseconds` is non-positive number, the key will be deleted rather than expired.
     * The timeout will only be cleared by commands that delete or overwrite the contents of `key`.
     *
     * @see {@link https://valkey.io/commands/pexpire/|valkey.io} for details.
     *
     * @param key - The key to set timeout on it.
     * @param milliseconds - The timeout in milliseconds.
     * @param options - (Optional) Additional parameters:
     * - (Optional) `expireOption`: the expire option - see {@link ExpireOptions}.
     * @returns `true` if the timeout was set. `false` if the timeout was not set. e.g. key doesn't exist,
     * or operation skipped due to the provided arguments.
     *
     * @example
     * ```typescript
     * // Example usage of the pexpire method on a key with no previous expiry
     * const result = await client.pexpire("my_key", 60000, { expireOption: ExpireOptions.HasNoExpiry });
     * console.log(result); // Output: true - Indicates that a timeout of 60,000 milliseconds has been set for "my_key".
     * ```
     */
    pexpire(key: GlideString, milliseconds: number, options?: {
        expireOption?: ExpireOptions;
    }): Promise<boolean>;
    /**
     * Sets a timeout on `key`. It takes an absolute Unix timestamp (milliseconds since January 1, 1970) instead of specifying the number of milliseconds.
     * A timestamp in the past will delete the key immediately. After the timeout has expired, the key will automatically be deleted.
     * If `key` already has an existing expire set, the time to live is updated to the new value.
     * The timeout will only be cleared by commands that delete or overwrite the contents of `key`.
     *
     * @see {@link https://valkey.io/commands/pexpireat/|valkey.io} for details.
     *
     * @param key - The key to set timeout on it.
     * @param unixMilliseconds - The timeout in an absolute Unix timestamp.
     * @param options - (Optional) Additional parameters:
     * - (Optional) `expireOption`: the expire option - see {@link ExpireOptions}.
     * @returns `true` if the timeout was set. `false` if the timeout was not set. e.g. key doesn't exist,
     * or operation skipped due to the provided arguments.
     *
     * @example
     * ```typescript
     * // Example usage of the pexpireAt method on a key with no previous expiry
     * const result = await client.pexpireAt("my_key", 1672531200000, { expireOption: ExpireOptions.HasNoExpiry });
     * console.log(result); // Output: true - Indicates that the expiration time for "my_key" was successfully set.
     * ```
     */
    pexpireAt(key: GlideString, unixMilliseconds: number, options?: {
        expireOption?: ExpireOptions;
    }): Promise<number>;
    /**
     * Returns the absolute Unix timestamp (since January 1, 1970) at which the given `key` will expire, in milliseconds.
     *
     * @see {@link https://valkey.io/commands/pexpiretime/|valkey.io} for details.
     * @remarks Since Valkey version 7.0.0.
     *
     * @param key - The `key` to determine the expiration value of.
     * @returns The expiration Unix timestamp in seconds, `-2` if `key` does not exist or `-1` if `key` exists but has no associated expire.
     *
     * @example
     * ```typescript
     * const result1 = client.pexpiretime("myKey");
     * console.log(result1); // Output: -2 - myKey doesn't exist.
     *
     * const result2 = client.set(myKey, "value");
     * const result3 = client.pexpireTime(myKey);
     * console.log(result2); // Output: -1 - myKey has no associated expiration.
     *
     * client.expire(myKey, 60);
     * const result3 = client.pexpireTime(myKey);
     * console.log(result3); // Output: 123456789 - the Unix timestamp (in milliseconds) when "myKey" will expire.
     * ```
     */
    pexpiretime(key: GlideString): Promise<number>;
    /**
     * Returns the remaining time to live of `key` that has a timeout.
     *
     * @see {@link https://valkey.io/commands/ttl/|valkey.io} for details.
     *
     * @param key - The key to return its timeout.
     * @returns TTL in seconds, `-2` if `key` does not exist or `-1` if `key` exists but has no associated expire.
     *
     * @example
     * ```typescript
     * // Example usage of the ttl method with existing key
     * const result = await client.ttl("my_key");
     * console.log(result); // Output: 3600 - Indicates that "my_key" has a remaining time to live of 3600 seconds.
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of the ttl method with existing key that has no associated expire.
     * const result = await client.ttl("key");
     * console.log(result); // Output: -1 - Indicates that the key has no associated expire.
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of the ttl method with a non-existing key
     * const result = await client.ttl("nonexistent_key");
     * console.log(result); // Output: -2 - Indicates that the key doesn't exist.
     * ```
     */
    ttl(key: GlideString): Promise<number>;
    /**
     * Invokes a Lua script with its keys and arguments.
     * This method simplifies the process of invoking scripts on a Valkey server by using an object that represents a Lua script.
     * The script loading, argument preparation, and execution will all be handled internally. If the script has not already been loaded,
     * it will be loaded automatically using the `SCRIPT LOAD` command. After that, it will be invoked using the `EVALSHA` command.
     *
     * @see {@link https://valkey.io/commands/script-load/|SCRIPT LOAD} and {@link https://valkey.io/commands/evalsha/|EVALSHA} on valkey.io for details.
     * @remarks When in cluster mode, all `keys` must map to the same hash slot.
     *
     * @param script - The Lua script to execute.
     * @param options - (Optional) Additional parameters:
     * - (Optional) `keys` : the keys that are used in the script.
     * - (Optional) `args`: the arguments for the script.
     * - (Optional) `decoder`: see {@link DecoderOption}.
     * @returns A value that depends on the script that was executed.
     *
     * @example
     * ```typescript
     * const luaScript = new Script("return { KEYS[1], ARGV[1] }");
     * const scriptOptions = {
     *      keys: ["foo"],
     *      args: ["bar"],
     * };
     * const result = await invokeScript(luaScript, scriptOptions);
     * console.log(result); // Output: ['foo', 'bar']
     * ```
     */
    invokeScript(script: Script, options?: {
        keys?: GlideString[];
        args?: GlideString[];
    } & DecoderOption): Promise<GlideReturnType>;
    /**
     * Returns the original source code of a script in the script cache.
     *
     * @see {@link https://valkey.io/commands/script-show|valkey.io} for more details.
     * @remarks Since Valkey version 8.0.0.
     *
     * @param sha1 - The SHA1 digest of the script.
     * @param options - (Optional) See {@link DecoderOption}.
     * @return The original source code of the script, if present in the cache.
     * If the script is not found in the cache, an error is thrown.
     *
     * @example
     * ```typescript
     * const scriptHash = script.getHash();
     * const scriptSource = await client.scriptShow(scriptHash);
     * console.log(scriptSource); // Output: "return { KEYS[1], ARGV[1] }"
     * ```
     */
    scriptShow(sha1: GlideString, options?: DecoderOption): Promise<GlideString>;
    /**
     * Returns stream entries matching a given range of entry IDs.
     *
     * @see {@link https://valkey.io/commands/xrange/|valkey.io} for more details.
     *
     * @param key - The key of the stream.
     * @param start - The starting stream entry ID bound for the range.
     *     - Use `value` to specify a stream entry ID.
     *     - Use `isInclusive: false` to specify an exclusive bounded stream entry ID. This is only available starting with Valkey version 6.2.0.
     *     - Use `InfBoundary.NegativeInfinity` to start with the minimum available ID.
     * @param end - The ending stream entry ID bound for the range.
     *     - Use `value` to specify a stream entry ID.
     *     - Use `isInclusive: false` to specify an exclusive bounded stream entry ID. This is only available starting with Valkey version 6.2.0.
     *     - Use `InfBoundary.PositiveInfinity` to end with the maximum available ID.
     * @param options - (Optional) Additional parameters:
     * - (Optional) `count`: the maximum count of stream entries to return.
     *     If `count` is not provided, all stream entries in the range will be returned.
     * - (Optional) `decoder`: see {@link DecoderOption}.
     * @returns A map of stream entry ids, to an array of entries, or `null` if `count` is non-positive.
     *
     * @example
     * ```typescript
     * await client.xadd("mystream", [["field1", "value1"]], {id: "0-1"});
     * await client.xadd("mystream", [["field2", "value2"], ["field2", "value3"]], {id: "0-2"});
     * console.log(await client.xrange("mystream", InfBoundary.NegativeInfinity, InfBoundary.PositiveInfinity));
     * // Output:
     * // {
     * //     "0-1": [["field1", "value1"]],
     * //     "0-2": [["field2", "value2"], ["field2", "value3"]],
     * // } // Indicates the stream entry IDs and their associated field-value pairs for all stream entries in "mystream".
     * ```
     */
    xrange(key: GlideString, start: Boundary<string>, end: Boundary<string>, options?: {
        count?: number;
    } & DecoderOption): Promise<StreamEntryDataType | null>;
    /**
     * Returns stream entries matching a given range of entry IDs in reverse order. Equivalent to {@link xrange} but returns the
     * entries in reverse order.
     *
     * @see {@link https://valkey.io/commands/xrevrange/|valkey.io} for more details.
     *
     * @param key - The key of the stream.
     * @param end - The ending stream entry ID bound for the range.
     *     - Use `value` to specify a stream entry ID.
     *     - Use `isInclusive: false` to specify an exclusive bounded stream entry ID. This is only available starting with Valkey version 6.2.0.
     *     - Use `InfBoundary.PositiveInfinity` to end with the maximum available ID.
     * @param start - The ending stream ID bound for the range.
     *     - Use `value` to specify a stream entry ID.
     *     - Use `isInclusive: false` to specify an exclusive bounded stream entry ID. This is only available starting with Valkey version 6.2.0.
     *     - Use `InfBoundary.NegativeInfinity` to start with the minimum available ID.
     * @param options - (Optional) Additional parameters:
     * - (Optional) `count`: the maximum count of stream entries to return.
     *     If `count` is not provided, all stream entries in the range will be returned.
     * - (Optional) `decoder`: see {@link DecoderOption}.
     * @returns A map of stream entry ids, to an array of entries, or `null` if `count` is non-positive.
     *
     * @example
     * ```typescript
     * await client.xadd("mystream", [["field1", "value1"]], {id: "0-1"});
     * await client.xadd("mystream", [["field2", "value2"], ["field2", "value3"]], {id: "0-2"});
     * console.log(await client.xrevrange("mystream", InfBoundary.PositiveInfinity, InfBoundary.NegativeInfinity));
     * // Output:
     * // {
     * //     "0-2": [["field2", "value2"], ["field2", "value3"]],
     * //     "0-1": [["field1", "value1"]],
     * // } // Indicates the stream entry IDs and their associated field-value pairs for all stream entries in "mystream".
     * ```
     */
    xrevrange(key: GlideString, end: Boundary<string>, start: Boundary<string>, options?: {
        count?: number;
    } & DecoderOption): Promise<StreamEntryDataType | null>;
    /**
     * Adds members with their scores to the sorted set stored at `key`.
     * If a member is already a part of the sorted set, its score is updated.
     *
     * @see {@link https://valkey.io/commands/zadd/|valkey.io} for more details.
     *
     * @param key - The key of the sorted set.
     * @param membersAndScores - A list of members and their corresponding scores or a mapping of members to their corresponding scores.
     * @param options - (Optional) The `ZADD` options - see {@link ZAddOptions}.
     * @returns The number of elements added to the sorted set.
     * If {@link ZAddOptions.changed} is set to `true`, returns the number of elements updated in the sorted set.
     *
     * @example
     * ```typescript
     * // Example usage of the zadd method to add elements to a sorted set
     * const data = [{ element: "member1", score: 10.5 }, { element: "member2", score: 8.2 }]
     * const result = await client.zadd("my_sorted_set", data);
     * console.log(result); // Output: 2 - Indicates that two elements have been added to the sorted set "my_sorted_set."
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of the zadd method to update scores in an existing sorted set
     * const options = { conditionalChange: ConditionalChange.ONLY_IF_EXISTS, changed: true };
     * const result = await client.zadd("existing_sorted_set", { "member1": 10.5, "member2": 8.2 }, options);
     * console.log(result); // Output: 2 - Updates the scores of two existing members in the sorted set "existing_sorted_set."
     * ```
     */
    zadd(key: GlideString, membersAndScores: ElementAndScore[] | Record<string, Score>, options?: ZAddOptions): Promise<number>;
    /**
     * Increments the score of member in the sorted set stored at `key` by `increment`.
     * If `member` does not exist in the sorted set, it is added with `increment` as its score (as if its previous score was 0.0).
     * If `key` does not exist, a new sorted set with the specified member as its sole member is created.
     *
     * @see {@link https://valkey.io/commands/zadd/|valkey.io} for more details.
     *
     * @param key - The key of the sorted set.
     * @param member - A member in the sorted set to increment score to.
     * @param increment - The score to increment the member.
     * @param options - (Optional) The `ZADD` options - see {@link ZAddOptions}.
     * @returns The score of the member.
     * If there was a conflict with the options, the operation aborts and `null` is returned.
     *
     * @example
     * ```typescript
     * // Example usage of the zaddIncr method to add a member with a score to a sorted set
     * const result = await client.zaddIncr("my_sorted_set", member, 5.0);
     * console.log(result); // Output: 5.0
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of the zaddIncr method to add or update a member with a score in an existing sorted set
     * const result = await client.zaddIncr("existing_sorted_set", member, "3.0", { updateOptions: UpdateByScore.LESS_THAN });
     * console.log(result); // Output: null - Indicates that the member in the sorted set haven't been updated.
     * ```
     */
    zaddIncr(key: GlideString, member: GlideString, increment: number, options?: ZAddOptions): Promise<number | null>;
    /**
     * Removes the specified members from the sorted set stored at `key`.
     * Specified members that are not a member of this set are ignored.
     *
     * @see {@link https://valkey.io/commands/zrem/|valkey.io} for more details.
     *
     * @param key - The key of the sorted set.
     * @param members - A list of members to remove from the sorted set.
     * @returns The number of members that were removed from the sorted set, not including non-existing members.
     * If `key` does not exist, it is treated as an empty sorted set, and this command returns 0.
     *
     * @example
     * ```typescript
     * // Example usage of the zrem function to remove members from a sorted set
     * const result = await client.zrem("my_sorted_set", ["member1", "member2"]);
     * console.log(result); // Output: 2 - Indicates that two members have been removed from the sorted set "my_sorted_set."
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of the zrem function when the sorted set does not exist
     * const result = await client.zrem("non_existing_sorted_set", ["member1", "member2"]);
     * console.log(result); // Output: 0 - Indicates that no members were removed as the sorted set "non_existing_sorted_set" does not exist.
     * ```
     */
    zrem(key: GlideString, members: GlideString[]): Promise<number>;
    /**
     * Returns the cardinality (number of elements) of the sorted set stored at `key`.
     *
     * @see {@link https://valkey.io/commands/zcard/|valkey.io} for more details.
     *
     * @param key - The key of the sorted set.
     * @returns The number of elements in the sorted set.
     * If `key` does not exist, it is treated as an empty sorted set, and this command returns `0`.
     *
     * @example
     * ```typescript
     * // Example usage of the zcard method to get the cardinality of a sorted set
     * const result = await client.zcard("my_sorted_set");
     * console.log(result); // Output: 3 - Indicates that there are 3 elements in the sorted set "my_sorted_set".
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of the zcard method with a non-existing key
     * const result = await client.zcard("non_existing_key");
     * console.log(result); // Output: 0
     * ```
     */
    zcard(key: GlideString): Promise<number>;
    /**
     * Returns the cardinality of the intersection of the sorted sets specified by `keys`.
     *
     * @see {@link https://valkey.io/commands/zintercard/|valkey.io} for more details.
     * @remarks When in cluster mode, all `keys` must map to the same hash slot.
     * @remarks Since Valkey version 7.0.0.
     *
     * @param keys - The keys of the sorted sets to intersect.
     * @param options - (Optional) Additional parameters:
     * - (Optional) `limit`: the limit for the intersection cardinality value. If not specified, or set to `0`, no limit is used.
     * @returns The cardinality of the intersection of the given sorted sets.
     *
     * @example
     * ```typescript
     * const cardinality = await client.zintercard(["key1", "key2"], { limit: 10 });
     * console.log(cardinality); // Output: 3 - The intersection of the sorted sets at "key1" and "key2" has a cardinality of 3.
     * ```
     */
    zintercard(keys: GlideString[], options?: {
        limit?: number;
    }): Promise<number>;
    /**
     * Returns the difference between the first sorted set and all the successive sorted sets.
     * To get the elements with their scores, see {@link zdiffWithScores}.
     *
     * @see {@link https://valkey.io/commands/zdiff/|valkey.io} for more details.
     * @remarks When in cluster mode, all `keys` must map to the same hash slot.
     * @remarks Since Valkey version 6.2.0.
     *
     * @param keys - The keys of the sorted sets.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns An `array` of elements representing the difference between the sorted sets.
     * If the first key does not exist, it is treated as an empty sorted set, and the command returns an empty `array`.
     *
     * @example
     * ```typescript
     * await client.zadd("zset1", {"member1": 1.0, "member2": 2.0, "member3": 3.0});
     * await client.zadd("zset2", {"member2": 2.0});
     * await client.zadd("zset3", {"member3": 3.0});
     * const result = await client.zdiff(["zset1", "zset2", "zset3"]);
     * console.log(result); // Output: ["member1"] - "member1" is in "zset1" but not "zset2" or "zset3".
     * ```
     */
    zdiff(keys: GlideString[], options?: DecoderOption): Promise<GlideString[]>;
    /**
     * Returns the difference between the first sorted set and all the successive sorted sets, with the associated
     * scores.
     *
     * @see {@link https://valkey.io/commands/zdiff/|valkey.io} for more details.
     * @remarks When in cluster mode, all `keys` must map to the same hash slot.
     * @remarks Since Valkey version 6.2.0.
     *
     * @param keys - The keys of the sorted sets.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns A list of elements and their scores representing the difference between the sorted sets.
     * If the first key does not exist, it is treated as an empty sorted set, and the command returns an empty `array`.
     *
     * @example
     * ```typescript
     * await client.zadd("zset1", {"member1": 1.0, "member2": 2.0, "member3": 3.0});
     * await client.zadd("zset2", {"member2": 2.0});
     * await client.zadd("zset3", {"member3": 3.0});
     * const result = await client.zdiffWithScores(["zset1", "zset2", "zset3"]);
     * console.log(result); // Output: "member1" is in "zset1" but not "zset2" or "zset3"
     * // [{ element: "member1", score: 1.0 }]
     * ```
     */
    zdiffWithScores(keys: GlideString[], options?: DecoderOption): Promise<SortedSetDataType>;
    /**
     * Calculates the difference between the first sorted set and all the successive sorted sets in `keys` and stores
     * the difference as a sorted set to `destination`, overwriting it if it already exists. Non-existent keys are
     * treated as empty sets.
     *
     * @see {@link https://valkey.io/commands/zdiffstore/|valkey.io} for more details.
     * @remarks When in cluster mode, all keys in `keys` and `destination` must map to the same hash slot.
     * @remarks Since Valkey version 6.2.0.
     *
     * @param destination - The key for the resulting sorted set.
     * @param keys - The keys of the sorted sets to compare.
     * @returns The number of members in the resulting sorted set stored at `destination`.
     *
     * @example
     * ```typescript
     * await client.zadd("zset1", {"member1": 1.0, "member2": 2.0});
     * await client.zadd("zset2", {"member1": 1.0});
     * const result1 = await client.zdiffstore("zset3", ["zset1", "zset2"]);
     * console.log(result1); // Output: 1 - One member exists in "key1" but not "key2", and this member was stored in "zset3".
     *
     * const result2 = await client.zrange("zset3", {start: 0, end: -1});
     * console.log(result2); // Output: ["member2"] - "member2" is now stored in "my_sorted_set".
     * ```
     */
    zdiffstore(destination: GlideString, keys: GlideString[]): Promise<number>;
    /**
     * Returns the score of `member` in the sorted set stored at `key`.
     *
     * @see {@link https://valkey.io/commands/zscore/|valkey.io} for more details.
     *
     * @param key - The key of the sorted set.
     * @param member - The member whose score is to be retrieved.
     * @returns The score of the member.
     * If `member` does not exist in the sorted set, null is returned.
     * If `key` does not exist, null is returned.
     *
     * @example
     * ```typescript
     * // Example usage of the zscore method∂∂ to get the score of a member in a sorted set
     * const result = await client.zscore("my_sorted_set", "member");
     * console.log(result); // Output: 10.5 - Indicates that the score of "member" in the sorted set "my_sorted_set" is 10.5.
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of the zscore method when the member does not exist in the sorted set
     * const result = await client.zscore("my_sorted_set", "non_existing_member");
     * console.log(result); // Output: null
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of the zscore method with non existimng key
     * const result = await client.zscore("non_existing_set", "member");
     * console.log(result); // Output: null
     * ```
     */
    zscore(key: GlideString, member: GlideString): Promise<number | null>;
    /**
     * Computes the union of sorted sets given by the specified `keys` and stores the result in `destination`.
     * If `destination` already exists, it is overwritten. Otherwise, a new sorted set will be created.
     * To get the result directly, see {@link zunionWithScores}.
     *
     * @see {@link https://valkey.io/commands/zunionstore/|valkey.io} for details.
     * @remarks When in cluster mode, `destination` and all keys in `keys` both must map to the same hash slot.
     *
     * @param destination - The key of the destination sorted set.
     * @param keys - The keys of the sorted sets with possible formats:
     *  - `GlideString[]` - for keys only.
     *  - `KeyWeight[]` - for weighted keys with their score multipliers.
     * @param options - (Optional) Additional parameters:
     * - (Optional) `aggregationType`: the aggregation strategy to apply when combining the scores of elements. See {@link AggregationType}.
     *   If `aggregationType` is not specified, defaults to `AggregationType.SUM`.
     * @returns The number of elements in the resulting sorted set stored at `destination`.
     *
     * @example
     * ```typescript
     * await client.zadd("key1", {"member1": 10.5, "member2": 8.2})
     * await client.zadd("key2", {"member1": 9.5})
     *
     * // use `zunionstore` with default aggregation and weights
     * console.log(await client.zunionstore("my_sorted_set", ["key1", "key2"]))
     * // Output: 2 - Indicates that the sorted set "my_sorted_set" contains two elements.
     * console.log(await client.zrangeWithScores("my_sorted_set", {start: 0, stop: -1}))
     * // Output: {'member1': 20, 'member2': 8.2} - "member1" is now stored in "my_sorted_set" with score of 20 and "member2" with score of 8.2.
     * ```
     *
     * @example
     * ```typescript
     * // use `zunionstore` with default weights
     * console.log(await client.zunionstore("my_sorted_set", ["key1", "key2"], { aggregationType: AggregationType.MAX }))
     * // Output: 2 - Indicates that the sorted set "my_sorted_set" contains two elements, and each score is the maximum score between the sets.
     * console.log(await client.zrangeWithScores("my_sorted_set", {start: 0, stop: -1}))
     * // Output: {'member1': 10.5, 'member2': 8.2} - "member1" is now stored in "my_sorted_set" with score of 10.5 and "member2" with score of 8.2.
     * ```
     *
     * @example
     * ```typescript
     * // use `zunionstore` with default aggregation
     * console.log(await client.zunionstore("my_sorted_set", [["key1", 2], ["key2", 1]])) // Output: 2
     * console.log(await client.zrangeWithScores("my_sorted_set", {start: 0, stop: -1})) // Output: { member2: 16.4, member1: 30.5 }
     * ```
     */
    zunionstore(destination: GlideString, keys: GlideString[] | KeyWeight[], options?: {
        aggregationType?: AggregationType;
    }): Promise<number>;
    /**
     * Returns the scores associated with the specified `members` in the sorted set stored at `key`.
     *
     * @see {@link https://valkey.io/commands/zmscore/|valkey.io} for more details.
     * @remarks Since Valkey version 6.2.0.
     *
     * @param key - The key of the sorted set.
     * @param members - A list of members in the sorted set.
     * @returns An `array` of scores corresponding to `members`.
     * If a member does not exist in the sorted set, the corresponding value in the list will be `null`.
     *
     * @example
     * ```typescript
     * const result = await client.zmscore("zset1", ["member1", "non_existent_member", "member2"]);
     * console.log(result); // Output: [1.0, null, 2.0] - "member1" has a score of 1.0, "non_existent_member" does not exist in the sorted set, and "member2" has a score of 2.0.
     * ```
     */
    zmscore(key: GlideString, members: GlideString[]): Promise<(number | null)[]>;
    /**
     * Returns the number of members in the sorted set stored at `key` with scores between `minScore` and `maxScore`.
     *
     * @see {@link https://valkey.io/commands/zcount/|valkey.io} for more details.
     *
     * @param key - The key of the sorted set.
     * @param minScore - The minimum score to count from. Can be positive/negative infinity, or specific score and inclusivity.
     * @param maxScore - The maximum score to count up to. Can be positive/negative infinity, or specific score and inclusivity.
     * @returns The number of members in the specified score range.
     * If `key` does not exist, it is treated as an empty sorted set, and the command returns `0`.
     * If `minScore` is greater than `maxScore`, `0` is returned.
     *
     * @example
     * ```typescript
     * // Example usage of the zcount method to count members in a sorted set within a score range
     * const result = await client.zcount("my_sorted_set", { value: 5.0, isInclusive: true }, InfBoundary.PositiveInfinity);
     * console.log(result); // Output: 2 - Indicates that there are 2 members with scores between 5.0 (inclusive) and +inf in the sorted set "my_sorted_set".
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of the zcount method to count members in a sorted set within a score range
     * const result = await client.zcount("my_sorted_set", { value: 5.0, isInclusive: true }, { value: 10.0, isInclusive: false });
     * console.log(result); // Output: 1 - Indicates that there is one member with score between 5.0 (inclusive) and 10.0 (exclusive) in the sorted set "my_sorted_set".
     * ```
     */
    zcount(key: GlideString, minScore: Boundary<number>, maxScore: Boundary<number>): Promise<number>;
    /**
     * Returns the specified range of elements in the sorted set stored at `key`.
     * `ZRANGE` can perform different types of range queries: by index (rank), by the score, or by lexicographical order.
     *
     * To get the elements with their scores, see {@link zrangeWithScores}.
     *
     * @see {@link https://valkey.io/commands/zrange/|valkey.io} for more details.
     *
     * @param key - The key of the sorted set.
     * @param rangeQuery - The range query object representing the type of range query to perform.
     * - For range queries by index (rank), use {@link RangeByIndex}.
     * - For range queries by lexicographical order, use {@link RangeByLex}.
     * - For range queries by score, use {@link RangeByScore}.
     * @param options - (Optional) Additional parameters:
     * - (Optional) `reverse`: if `true`, reverses the sorted set, with index `0` as the element with the highest score.
     * - (Optional) `decoder`: see {@link DecoderOption}.
     * @returns A list of elements within the specified range.
     * If `key` does not exist, it is treated as an empty sorted set, and the command returns an empty array.
     *
     * @example
     * ```typescript
     * // Example usage of zrange method to retrieve all members of a sorted set in ascending order
     * const result = await client.zrange("my_sorted_set", { start: 0, end: -1 });
     * console.log(result1); // Output: all members in ascending order
     * // ['member1', 'member2', 'member3']
     * ```
     * @example
     * ```typescript
     * // Example usage of zrange method to retrieve members within a score range in descending order
     * const result = await client.zrange("my_sorted_set", {
     *              start: { value: 3, isInclusive: false },
     *              end: InfBoundary.NegativeInfinity,
     *              type: "byScore",
     *           }, { reverse: true });
     * console.log(result); // Output: members with scores within the range of negative infinity to 3, in descending order
     * // ['member2', 'member1']
     * ```
     */
    zrange(key: GlideString, rangeQuery: RangeByScore | RangeByLex | RangeByIndex, options?: {
        reverse?: boolean;
    } & DecoderOption): Promise<GlideString[]>;
    /**
     * Returns the specified range of elements with their scores in the sorted set stored at `key`.
     * Similar to {@link ZRange} but with a `WITHSCORE` flag.
     *
     * @see {@link https://valkey.io/commands/zrange/|valkey.io} for more details.
     *
     * @param key - The key of the sorted set.
     * @param rangeQuery - The range query object representing the type of range query to perform.
     * - For range queries by index (rank), use {@link RangeByIndex}.
     * - For range queries by score, use {@link RangeByScore}.
     * @param options - (Optional) Additional parameters:
     * - (Optional) `reverse`: if `true`, reverses the sorted set, with index `0` as the element with the highest score.
     * - (Optional) `decoder`: see {@link DecoderOption}.
     * @returns A list of elements and their scores within the specified range.
     * If `key` does not exist, it is treated as an empty sorted set, and the command returns an empty list.
     *
     * @example
     * ```typescript
     * // Example usage of zrangeWithScores method to retrieve members within a score range with their scores
     * const result = await client.zrangeWithScores("my_sorted_set", {
     *              start: { value: 10, isInclusive: false },
     *              end: { value: 20, isInclusive: false },
     *              type: "byScore",
     *           });
     * console.log(result); // Output: members with scores between 10 and 20 with their scores
     * // [{ element: 'member1', score: 10.5 }, { element: 'member2', score: 15.2 }]
     * ```
     * @example
     * ```typescript
     * // Example usage of zrangeWithScores method to retrieve members within a score range with their scores
     * const result = await client.zrangeWithScores("my_sorted_set", {
     *              start: { value: 3, isInclusive: false },
     *              end: InfBoundary.NegativeInfinity,
     *              type: "byScore",
     *           }, { reverse: true });
     * console.log(result); // Output: members with scores within the range of negative infinity to 3, with their scores
     * // [{ element: 'member7', score: 1.5 }, { element: 'member4', score: -2.0 }]
     * ```
     */
    zrangeWithScores(key: GlideString, rangeQuery: RangeByScore | RangeByIndex, options?: {
        reverse?: boolean;
    } & DecoderOption): Promise<SortedSetDataType>;
    /**
     * Stores a specified range of elements from the sorted set at `source`, into a new
     * sorted set at `destination`. If `destination` doesn't exist, a new sorted
     * set is created; if it exists, it's overwritten.
     *
     * @see {@link https://valkey.io/commands/zrangestore/|valkey.io} for more details.
     * @remarks When in cluster mode, `destination` and `source` must map to the same hash slot.
     * @remarks Since Valkey version 6.2.0.
     *
     * @param destination - The key for the destination sorted set.
     * @param source - The key of the source sorted set.
     * @param rangeQuery - The range query object representing the type of range query to perform.
     * - For range queries by index (rank), use {@link RangeByIndex}.
     * - For range queries by lexicographical order, use {@link RangeByLex}.
     * - For range queries by score, use {@link RangeByScore}.
     * @param reverse - If `true`, reverses the sorted set, with index `0` as the element with the highest score.
     * @returns The number of elements in the resulting sorted set.
     *
     * @example
     * ```typescript
     * // Example usage of zrangeStore to retrieve and store all members of a sorted set in ascending order.
     * const result = await client.zrangeStore("destination_key", "my_sorted_set", { start: 0, end: -1 });
     * console.log(result); // Output: 7 - "destination_key" contains a sorted set with the 7 members from "my_sorted_set".
     * ```
     * @example
     * ```typescript
     * // Example usage of zrangeStore method to retrieve members within a score range in ascending order and store in "destination_key"
     * const result = await client.zrangeStore("destination_key", "my_sorted_set", {
     *              start: InfBoundary.NegativeInfinity,
     *              end: { value: 3, isInclusive: false },
     *              type: "byScore",
     *           });
     * console.log(result); // Output: 5 - Stores 5 members with scores within the range of negative infinity to 3, in ascending order, in "destination_key".
     * ```
     */
    zrangeStore(destination: GlideString, source: GlideString, rangeQuery: RangeByScore | RangeByLex | RangeByIndex, reverse?: boolean): Promise<number>;
    /**
     * Computes the intersection of sorted sets given by the specified `keys` and stores the result in `destination`.
     * If `destination` already exists, it is overwritten. Otherwise, a new sorted set will be created.
     * To get the result directly, see {@link zinterWithScores}.
     *
     * @see {@link https://valkey.io/commands/zinterstore/|valkey.io} for more details.
     * @remarks When in cluster mode, `destination` and all keys in `keys` must map to the same hash slot.
     *
     * @param destination - The key of the destination sorted set.
     * @param keys - The keys of the sorted sets with possible formats:
     *  - `GlideString[]` - for keys only.
     *  - `KeyWeight[]` - for weighted keys with score multipliers.
     * @param options - (Optional) Additional parameters:
     * - (Optional) `aggregationType`: the aggregation strategy to apply when combining the scores of elements. See {@link AggregationType}.
     *   If `aggregationType` is not specified, defaults to `AggregationType.SUM`.
     * @returns The number of elements in the resulting sorted set stored at `destination`.
     *
     * @example
     * ```typescript
     * await client.zadd("key1", {"member1": 10.5, "member2": 8.2})
     * await client.zadd("key2", {"member1": 9.5})
     *
     * // use `zinterstore` with default aggregation and weights
     * console.log(await client.zinterstore("my_sorted_set", ["key1", "key2"]))
     * // Output: 1 - Indicates that the sorted set "my_sorted_set" contains one element.
     * console.log(await client.zrangeWithScores("my_sorted_set", {start: 0, end: -1}))
     * // Output: {'member1': 20} - "member1" is now stored in "my_sorted_set" with score of 20.
     *
     * // use `zinterstore` with default weights
     * console.log(await client.zinterstore("my_sorted_set", ["key1", "key2"] , { aggregationType: AggregationType.MAX }))
     * // Output: 1 - Indicates that the sorted set "my_sorted_set" contains one element, and it's score is the maximum score between the sets.
     * console.log(await client.zrangeWithScores("my_sorted_set", {start: 0, end: -1}))
     * // Output: {'member1': 10.5} - "member1" is now stored in "my_sorted_set" with score of 10.5.
     * ```
     */
    zinterstore(destination: GlideString, keys: GlideString[] | KeyWeight[], options?: {
        aggregationType?: AggregationType;
    }): Promise<number>;
    /**
     * Computes the intersection of sorted sets given by the specified `keys` and returns a list of intersecting elements.
     * To get the scores as well, see {@link zinterWithScores}.
     * To store the result in a key as a sorted set, see {@link zinterStore}.
     *
     * @remarks When in cluster mode, all keys in `keys` must map to the same hash slot.
     *
     * @remarks Since Valkey version 6.2.0.
     *
     * @see {@link https://valkey.io/commands/zinter/|valkey.io} for details.
     *
     * @param keys - The keys of the sorted sets.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns The resulting array of intersecting elements.
     *
     * @example
     * ```typescript
     * await client.zadd("key1", {"member1": 10.5, "member2": 8.2});
     * await client.zadd("key2", {"member1": 9.5});
     * const result = await client.zinter(["key1", "key2"]);
     * console.log(result); // Output: ['member1']
     * ```
     */
    zinter(keys: GlideString[], options?: DecoderOption): Promise<GlideString[]>;
    /**
     * Computes the intersection of sorted sets given by the specified `keys` and returns a list of intersecting elements with scores.
     * To get the elements only, see {@link zinter}.
     * To store the result in a key as a sorted set, see {@link zinterStore}.
     *
     * @remarks When in cluster mode, all keys in `keys` must map to the same hash slot.
     *
     * @see {@link https://valkey.io/commands/zinter/|valkey.io} for details.
     *
     * @remarks Since Valkey version 6.2.0.
     *
     * @param keys - The keys of the sorted sets with possible formats:
     *  - `GlideString[]` - for keys only.
     *  - `KeyWeight[]` - for weighted keys with score multipliers.
     * @param options - (Optional) Additional parameters:
     * - (Optional) `aggregationType`: the aggregation strategy to apply when combining the scores of elements.
     *     If `aggregationType` is not specified, defaults to `AggregationType.SUM`. See {@link AggregationType}.
     * - (Optional) `decoder`: see {@link DecoderOption}.
     * @returns A list of elements and their scores representing the intersection of the sorted sets.
     * If a key does not exist, it is treated as an empty sorted set, and the command returns an empty result.
     *
     * @example
     * ```typescript
     * await client.zadd("key1", {"member1": 10.5, "member2": 8.2});
     * await client.zadd("key2", {"member1": 9.5});
     * const result1 = await client.zinterWithScores(["key1", "key2"]);
     * console.log(result1); // Output: "member1" with score of 20 is the result
     * // [{ element: 'member1', score: 20 }]
     * const result2 = await client.zinterWithScores(["key1", "key2"], AggregationType.MAX)
     * console.log(result2); // Output: "member1" with score of 10.5 is the result
     * // [{ element: 'member1', score: 10.5 }]
     * ```
     */
    zinterWithScores(keys: GlideString[] | KeyWeight[], options?: {
        aggregationType?: AggregationType;
    } & DecoderOption): Promise<SortedSetDataType>;
    /**
     * Computes the union of sorted sets given by the specified `keys` and returns a list of union elements.
     *
     * To get the scores as well, see {@link zunionWithScores}.
     * To store the result in a key as a sorted set, see {@link zunionStore}.
     *
     * @see {@link https://valkey.io/commands/zunion/|valkey.io} for details.
     * @remarks When in cluster mode, all keys in `keys` must map to the same hash slot.
     * @remarks Since Valkey version 6.2.0.
     *
     * @param keys - The keys of the sorted sets.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns The resulting array of union elements.
     *
     * @example
     * ```typescript
     * await client.zadd("key1", {"member1": 10.5, "member2": 8.2});
     * await client.zadd("key2", {"member1": 9.5});
     * const result = await client.zunion(["key1", "key2"]);
     * console.log(result); // Output: ['member1', 'member2']
     * ```
     */
    zunion(keys: GlideString[], options?: DecoderOption): Promise<GlideString[]>;
    /**
     * Computes the intersection of sorted sets given by the specified `keys` and returns a list of union elements with scores.
     * To get the elements only, see {@link zunion}.
     *
     * @remarks When in cluster mode, all keys in `keys` must map to the same hash slot.
     *
     * @see {@link https://valkey.io/commands/zunion/|valkey.io} for details.
     *
     * @remarks Since Valkey version 6.2.0.
     *
     * @param keys - The keys of the sorted sets with possible formats:
     *  - string[] - for keys only.
     *  - KeyWeight[] - for weighted keys with score multipliers.
     * @param options - (Optional) Additional parameters:
     * - (Optional) `aggregationType`: the aggregation strategy to apply when combining the scores of elements.
     *     If `aggregationType` is not specified, defaults to `AggregationType.SUM`. See {@link AggregationType}.
     * - (Optional) `decoder`: see {@link DecoderOption}.
     * @returns A list of elements and their scores representing the intersection of the sorted sets.
     *
     * @example
     * ```typescript
     * await client.zadd("key1", {"member1": 10.5, "member2": 8.2});
     * await client.zadd("key2", {"member1": 9.5});
     * const result1 = await client.zunionWithScores(["key1", "key2"]);
     * console.log(result1); // Output:
     * // [{ element: 'member1', score: 20 }, { element: 'member2', score: 8.2 }]
     * const result2 = await client.zunionWithScores(["key1", "key2"], "MAX");
     * console.log(result2); // Output:
     * // [{ element: 'member1', score: 10.5}, { element: 'member2', score: 8.2 }]
     * ```
     */
    zunionWithScores(keys: GlideString[] | KeyWeight[], options?: {
        aggregationType?: AggregationType;
    } & DecoderOption): Promise<SortedSetDataType>;
    /**
     * Returns a random member from the sorted set stored at `key`.
     *
     * @see {@link https://valkey.io/commands/zrandmember/|valkey.io} for more details.
     *
     * @param keys - The key of the sorted set.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns A string representing a random member from the sorted set.
     *     If the sorted set does not exist or is empty, the response will be `null`.
     *
     * @example
     * ```typescript
     * const payload1 = await client.zrandmember("mySortedSet");
     * console.log(payload1); // Output: "Glide" (a random member from the set)
     * ```
     *
     * @example
     * ```typescript
     * const payload2 = await client.zrandmember("nonExistingSortedSet");
     * console.log(payload2); // Output: null since the sorted set does not exist.
     * ```
     */
    zrandmember(key: GlideString, options?: DecoderOption): Promise<GlideString | null>;
    /**
     * Returns random members from the sorted set stored at `key`.
     *
     * @see {@link https://valkey.io/commands/zrandmember/|valkey.io} for more details.
     *
     * @param keys - The key of the sorted set.
     * @param count - The number of members to return.
     *     If `count` is positive, returns unique members.
     *     If negative, allows for duplicates.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns An `array` of members from the sorted set.
     *     If the sorted set does not exist or is empty, the response will be an empty `array`.
     *
     * @example
     * ```typescript
     * const payload1 = await client.zrandmemberWithCount("mySortedSet", -3);
     * console.log(payload1); // Output: ["Glide", "GLIDE", "node"]
     * ```
     *
     * @example
     * ```typescript
     * const payload2 = await client.zrandmemberWithCount("nonExistingKey", 3);
     * console.log(payload1); // Output: [] since the sorted set does not exist.
     * ```
     */
    zrandmemberWithCount(key: GlideString, count: number, options?: DecoderOption): Promise<GlideString[]>;
    /**
     * Returns random members with scores from the sorted set stored at `key`.
     *
     * @see {@link https://valkey.io/commands/zrandmember/|valkey.io} for more details.
     *
     * @param keys - The key of the sorted set.
     * @param count - The number of members to return.
     *     If `count` is positive, returns unique members.
     *     If negative, allows for duplicates.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns A list of {@link KeyWeight} tuples, which store member names and their respective scores.
     *     If the sorted set does not exist or is empty, the response will be an empty `array`.
     *
     * @example
     * ```typescript
     * const payload1 = await client.zrandmemberWithCountWithScore("mySortedSet", -3);
     * console.log(payload1); // Output: [["Glide", 1.0], ["GLIDE", 1.0], ["node", 2.0]]
     * ```
     *
     * @example
     * ```typescript
     * const payload2 = await client.zrandmemberWithCountWithScore("nonExistingKey", 3);
     * console.log(payload1); // Output: [] since the sorted set does not exist.
     * ```
     */
    zrandmemberWithCountWithScores(key: GlideString, count: number, options?: DecoderOption): Promise<KeyWeight[]>;
    /**
     * Returns the length of the string value stored at `key`.
     *
     * @see {@link https://valkey.io/commands/strlen/|valkey.io} for more details.
     *
     * @param key - The key to check its length.
     * @returns The length of the string value stored at key
     * If `key` does not exist, it is treated as an empty string, and the command returns `0`.
     *
     * @example
     * ```typescript
     * // Example usage of strlen method with an existing key
     * await client.set("key", "GLIDE");
     * const len1 = await client.strlen("key");
     * console.log(len1); // Output: 5
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of strlen method with a non-existing key
     * const len2 = await client.strlen("non_existing_key");
     * console.log(len2); // Output: 0
     * ```
     */
    strlen(key: GlideString): Promise<number>;
    /**
     * Returns the string representation of the type of the value stored at `key`.
     *
     * @see {@link https://valkey.io/commands/type/|valkey.io} for more details.
     *
     * @param key - The `key` to check its data type.
     * @returns If the `key` exists, the type of the stored value is returned. Otherwise, a "none" string is returned.
     *
     * @example
     * ```typescript
     * // Example usage of type method with a string value
     * await client.set("key", "value");
     * const type = await client.type("key");
     * console.log(type); // Output: 'string'
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of type method with a list
     * await client.lpush("key", ["value"]);
     * const type = await client.type("key");
     * console.log(type); // Output: 'list'
     * ```
     */
    type(key: GlideString): Promise<string>;
    /**
     * Removes and returns the members with the lowest scores from the sorted set stored at `key`.
     * If `count` is provided, up to `count` members with the lowest scores are removed and returned.
     * Otherwise, only one member with the lowest score is removed and returned.
     *
     * @see {@link https://valkey.io/commands/zpopmin/|valkey.io} for more details.
     *
     * @param key - The key of the sorted set.
     * @param options - (Optional) Additional parameters:
     * - (Optional) `count`: the maximum number of popped elements. If not specified, pops one member.
     * - (Optional) `decoder`: see {@link DecoderOption}.
     * @returns A list of the removed members and their scores, ordered from the one with the lowest score to the one with the highest.
     * If `key` doesn't exist, it will be treated as an empty sorted set and the command returns an empty map.
     * If `count` is higher than the sorted set's cardinality, returns all members and their scores.
     *
     * @example
     * ```typescript
     * // Example usage of zpopmin method to remove and return the member with the lowest score from a sorted set
     * const result = await client.zpopmin("my_sorted_set");
     * console.log(result); // Output:
     * // 'member1' with a score of 5.0 has been removed from the sorted set
     * // [{ element: 'member1', score: 5.0 }]
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of zpopmin method to remove and return multiple members with the lowest scores from a sorted set
     * const result = await client.zpopmin("my_sorted_set", 2);
     * console.log(result); // Output:
     * // 'member3' with a score of 7.5 and 'member2' with a score of 8.0 have been removed from the sorted set
     * // [
     * //     { element: 'member3', score: 7.5 },
     * //     { element: 'member2', score: 8.0 }
     * // ]
     * ```
     */
    zpopmin(key: GlideString, options?: {
        count?: number;
    } & DecoderOption): Promise<SortedSetDataType>;
    /**
     * Blocks the connection until it removes and returns a member with the lowest score from the
     * first non-empty sorted set, with the given `key` being checked in the order they
     * are provided.
     * `BZPOPMIN` is the blocking variant of {@link zpopmin}.
     *
     * @see {@link https://valkey.io/commands/bzpopmin/|valkey.io} for more details.
     * @remarks When in cluster mode, `keys` must map to the same hash slot.
     *
     * @param keys - The keys of the sorted sets.
     * @param timeout - The number of seconds to wait for a blocking operation to complete. A value of
     *     `0` will block indefinitely. Since 6.0.0: timeout is interpreted as a double instead of an integer.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns An `array` containing the key where the member was popped out, the member, itself, and the member score.
     *     If no member could be popped and the `timeout` expired, returns `null`.
     *
     * @example
     * ```typescript
     * const data = await client.bzpopmin(["zset1", "zset2"], 0.5);
     * console.log(data); // Output: ["zset1", "a", 2];
     * ```
     */
    bzpopmin(keys: GlideString[], timeout: number, options?: DecoderOption): Promise<[GlideString, GlideString, number] | null>;
    /**
     * Removes and returns the members with the highest scores from the sorted set stored at `key`.
     * If `count` is provided, up to `count` members with the highest scores are removed and returned.
     * Otherwise, only one member with the highest score is removed and returned.
     *
     * @see {@link https://valkey.io/commands/zpopmax/|valkey.io} for more details.
     *
     * @param key - The key of the sorted set.
     * @param options - (Optional) Additional parameters:
     * - (Optional) `count`: the maximum number of popped elements. If not specified, pops one member.
     * - (Optional) `decoder`: see {@link DecoderOption}.
     * @returns A list of the removed members and their scores, ordered from the one with the highest score to the one with the lowest.
     * If `key` doesn't exist, it will be treated as an empty sorted set and the command returns an empty map.
     * If `count` is higher than the sorted set's cardinality, returns all members and their scores, ordered from highest to lowest.
     *
     * @example
     * ```typescript
     * // Example usage of zpopmax method to remove and return the member with the highest score from a sorted set
     * const result = await client.zpopmax("my_sorted_set");
     * console.log(result); // Output:
     * // 'member1' with a score of 10.0 has been removed from the sorted set
     * // [{ element: 'member1', score: 10.0 }]
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of zpopmax method to remove and return multiple members with the highest scores from a sorted set
     * const result = await client.zpopmax("my_sorted_set", 2);
     * console.log(result); // Output:
     * // 'member3' with a score of 7.5 and 'member2' with a score of 8.0 have been removed from the sorted set
     * // [
     * //     { element: 'member3', score: 7.5 },
     * //     { element: 'member2', score: 8.0 }
     * // ]
     * ```
     */
    zpopmax(key: GlideString, options?: {
        count?: number;
    } & DecoderOption): Promise<SortedSetDataType>;
    /**
     * Blocks the connection until it removes and returns a member with the highest score from the
     * first non-empty sorted set, with the given `key` being checked in the order they
     * are provided.
     * `BZPOPMAX` is the blocking variant of {@link zpopmax}.
     *
     * @see {@link https://valkey.io/commands/zpopmax/|valkey.io} for more details.
     * @remarks When in cluster mode, `keys` must map to the same hash slot.
     *
     * @param keys - The keys of the sorted sets.
     * @param timeout - The number of seconds to wait for a blocking operation to complete. A value of
     *     `0` will block indefinitely. Since 6.0.0: timeout is interpreted as a double instead of an integer.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns An `array` containing the key where the member was popped out, the member, itself, and the member score.
     *     If no member could be popped and the `timeout` expired, returns `null`.
     *
     * @example
     * ```typescript
     * const data = await client.bzpopmax(["zset1", "zset2"], 0.5);
     * console.log(data); // Output: ["zset1", "c", 2];
     * ```
     */
    bzpopmax(keys: GlideString[], timeout: number, options?: DecoderOption): Promise<[GlideString, GlideString, number] | null>;
    /**
     * Returns the remaining time to live of `key` that has a timeout, in milliseconds.
     *
     * @see {@link https://valkey.io/commands/pttl/|valkey.io} for more details.
     *
     * @param key - The key to return its timeout.
     * @returns TTL in milliseconds, `-2` if `key` does not exist, `-1` if `key` exists but has no associated expire.
     *
     * @example
     * ```typescript
     * // Example usage of pttl method with an existing key
     * const result = await client.pttl("my_key");
     * console.log(result); // Output: 5000 - Indicates that the key "my_key" has a remaining time to live of 5000 milliseconds.
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of pttl method with a non-existing key
     * const result = await client.pttl("non_existing_key");
     * console.log(result); // Output: -2 - Indicates that the key "non_existing_key" does not exist.
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of pttl method with an exisiting key that has no associated expire.
     * const result = await client.pttl("key");
     * console.log(result); // Output: -1 - Indicates that the key "key" has no associated expire.
     * ```
     */
    pttl(key: GlideString): Promise<number>;
    /**
     * Removes all elements in the sorted set stored at `key` with rank between `start` and `end`.
     * Both `start` and `end` are zero-based indexes with 0 being the element with the lowest score.
     * These indexes can be negative numbers, where they indicate offsets starting at the element with the highest score.
     *
     * @see {@link https://valkey.io/commands/zremrangebyrank/|valkey.io} for more details.
     *
     * @param key - The key of the sorted set.
     * @param start - The starting point of the range.
     * @param end - The end of the range.
     * @returns The number of members removed.
     * If `start` exceeds the end of the sorted set, or if `start` is greater than `end`, 0 returned.
     * If `end` exceeds the actual end of the sorted set, the range will stop at the actual end of the sorted set.
     * If `key` does not exist 0 will be returned.
     *
     * @example
     * ```typescript
     * // Example usage of zremRangeByRank method
     * const result = await client.zremRangeByRank("my_sorted_set", 0, 2);
     * console.log(result); // Output: 3 - Indicates that three elements have been removed from the sorted set "my_sorted_set" between ranks 0 and 2.
     * ```
     */
    zremRangeByRank(key: GlideString, start: number, end: number): Promise<number>;
    /**
     * Removes all elements in the sorted set stored at `key` with lexicographical order between `minLex` and `maxLex`.
     *
     * @see {@link https://valkey.io/commands/zremrangebylex/|valkey.io} for more details.
     *
     * @param key - The key of the sorted set.
     * @param minLex - The minimum lex to count from. Can be negative infinity, or a specific lex and inclusivity.
     * @param maxLex - The maximum lex to count up to. Can be positive infinity, or a specific lex and inclusivity.
     * @returns The number of members removed.
     * If `key` does not exist, it is treated as an empty sorted set, and the command returns 0.
     * If `minLex` is greater than `maxLex`, 0 is returned.
     *
     * @example
     * ```typescript
     * // Example usage of zremRangeByLex method to remove members from a sorted set based on lexicographical order range
     * const result = await client.zremRangeByLex("my_sorted_set", { value: "a", isInclusive: false }, { value: "e" });
     * console.log(result); // Output: 4 - Indicates that 4 members, with lexicographical values ranging from "a" (exclusive) to "e" (inclusive), have been removed from "my_sorted_set".
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of zremRangeByLex method when the sorted set does not exist
     * const result = await client.zremRangeByLex("non_existing_sorted_set", InfBoundary.NegativeInfinity, { value: "e" });
     * console.log(result); // Output: 0 - Indicates that no elements were removed.
     * ```
     */
    zremRangeByLex(key: GlideString, minLex: Boundary<GlideString>, maxLex: Boundary<GlideString>): Promise<number>;
    /**
     * Removes all elements in the sorted set stored at `key` with a score between `minScore` and `maxScore`.
     *
     * @see {@link https://valkey.io/commands/zremrangebyscore/|valkey.io} for more details.
     *
     * @param key - The key of the sorted set.
     * @param minScore - The minimum score to remove from. Can be negative infinity, or specific score and inclusivity.
     * @param maxScore - The maximum score to remove to. Can be positive infinity, or specific score and inclusivity.
     * @returns The number of members removed.
     * If `key` does not exist, it is treated as an empty sorted set, and the command returns 0.
     * If `minScore` is greater than `maxScore`, 0 is returned.
     *
     * @example
     * ```typescript
     * // Example usage of zremRangeByScore method to remove members from a sorted set based on score range
     * const result = await client.zremRangeByScore("my_sorted_set", { value: 5.0, isInclusive: true }, InfBoundary.PositiveInfinity);
     * console.log(result); // Output: 2 - Indicates that 2 members with scores between 5.0 (inclusive) and +inf have been removed from the sorted set "my_sorted_set".
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of zremRangeByScore method when the sorted set does not exist
     * const result = await client.zremRangeByScore("non_existing_sorted_set", { value: 5.0, isInclusive: true }, { value: 10.0, isInclusive: false });
     * console.log(result); // Output: 0 - Indicates that no members were removed as the sorted set "non_existing_sorted_set" does not exist.
     * ```
     */
    zremRangeByScore(key: GlideString, minScore: Boundary<number>, maxScore: Boundary<number>): Promise<number>;
    /**
     * Returns the number of members in the sorted set stored at 'key' with scores between 'minLex' and 'maxLex'.
     *
     * @see {@link https://valkey.io/commands/zlexcount/|valkey.io} for more details.
     *
     * @param key - The key of the sorted set.
     * @param minLex - The minimum lex to count from. Can be negative infinity, or a specific lex and inclusivity.
     * @param maxLex - The maximum lex to count up to. Can be positive infinity, or a specific lex and inclusivity.
     * @returns The number of members in the specified lex range.
     * If 'key' does not exist, it is treated as an empty sorted set, and the command returns '0'.
     * If maxLex is less than minLex, '0' is returned.
     *
     * @example
     * ```typescript
     * const result = await client.zlexcount("my_sorted_set", {value: "c"}, InfBoundary.PositiveInfinity);
     * console.log(result); // Output: 2 - Indicates that there are 2 members with lex scores between "c" (inclusive) and positive infinity in the sorted set "my_sorted_set".
     * ```
     *
     * @example
     * ```typescript
     * const result = await client.zlexcount("my_sorted_set", {value: "c"}, {value: "k", isInclusive: false});
     * console.log(result); // Output: 1 - Indicates that there is one member with a lex score between "c" (inclusive) and "k" (exclusive) in the sorted set "my_sorted_set".
     * ```
     */
    zlexcount(key: GlideString, minLex: Boundary<GlideString>, maxLex: Boundary<GlideString>): Promise<number>;
    /**
     * Returns the rank of `member` in the sorted set stored at `key`, with scores ordered from low to high.
     * To get the rank of `member` with its score, see {@link zrankWithScore}.
     *
     * @see {@link https://valkey.io/commands/zrank/|valkey.io} for more details.
     *
     * @param key - The key of the sorted set.
     * @param member - The member whose rank is to be retrieved.
     * @returns The rank of `member` in the sorted set.
     * If `key` doesn't exist, or if `member` is not present in the set, null will be returned.
     *
     * @example
     * ```typescript
     * // Example usage of zrank method to retrieve the rank of a member in a sorted set
     * const result = await client.zrank("my_sorted_set", "member2");
     * console.log(result); // Output: 1 - Indicates that "member2" has the second-lowest score in the sorted set "my_sorted_set".
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of zrank method with a non-existing member
     * const result = await client.zrank("my_sorted_set", "non_existing_member");
     * console.log(result); // Output: null - Indicates that "non_existing_member" is not present in the sorted set "my_sorted_set".
     * ```
     */
    zrank(key: GlideString, member: GlideString): Promise<number | null>;
    /**
     * Returns the rank of `member` in the sorted set stored at `key` with its score, where scores are ordered from the lowest to highest.
     *
     * @see {@link https://valkey.io/commands/zrank/|valkey.io} for more details.
     * @remarks Since Valkey version 7.2.0.
     *
     * @param key - The key of the sorted set.
     * @param member - The member whose rank is to be retrieved.
     * @returns A list containing the rank and score of `member` in the sorted set.
     * If `key` doesn't exist, or if `member` is not present in the set, null will be returned.
     *
     * @example
     * ```typescript
     * // Example usage of zrank_withscore method to retrieve the rank and score of a member in a sorted set
     * const result = await client.zrank_withscore("my_sorted_set", "member2");
     * console.log(result); // Output: [1, 6.0] - Indicates that "member2" with score 6.0 has the second-lowest score in the sorted set "my_sorted_set".
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of zrank_withscore method with a non-existing member
     * const result = await client.zrank_withscore("my_sorted_set", "non_existing_member");
     * console.log(result); // Output: null - Indicates that "non_existing_member" is not present in the sorted set "my_sorted_set".
     * ```
     */
    zrankWithScore(key: GlideString, member: GlideString): Promise<[number, number] | null>;
    /**
     * Returns the rank of `member` in the sorted set stored at `key`, where
     * scores are ordered from the highest to lowest, starting from `0`.
     * To get the rank of `member` with its score, see {@link zrevrankWithScore}.
     *
     * @see {@link https://valkey.io/commands/zrevrank/|valkey.io} for more details.
     *
     * @param key - The key of the sorted set.
     * @param member - The member whose rank is to be retrieved.
     * @returns The rank of `member` in the sorted set, where ranks are ordered from high to low based on scores.
     *     If `key` doesn't exist, or if `member` is not present in the set, `null` will be returned.
     *
     * @example
     * ```typescript
     * const result = await client.zrevrank("my_sorted_set", "member2");
     * console.log(result); // Output: 1 - Indicates that "member2" has the second-highest score in the sorted set "my_sorted_set".
     * ```
     */
    zrevrank(key: GlideString, member: GlideString): Promise<number | null>;
    /**
     * Returns the rank of `member` in the sorted set stored at `key` with its
     * score, where scores are ordered from the highest to lowest, starting from `0`.
     *
     * @see {@link https://valkey.io/commands/zrevrank/|valkey.io} for more details.
     * @remarks Since Valkey version 7.2.0.
     *
     * @param key - The key of the sorted set.
     * @param member - The member whose rank is to be retrieved.
     * @returns A list containing the rank and score of `member` in the sorted set, where ranks
     *     are ordered from high to low based on scores.
     *     If `key` doesn't exist, or if `member` is not present in the set, `null` will be returned.
     *
     * @example
     * ```typescript
     * const result = await client.zrevankWithScore("my_sorted_set", "member2");
     * console.log(result); // Output: [1, 6.0] - Indicates that "member2" with score 6.0 has the second-highest score in the sorted set "my_sorted_set".
     * ```
     */
    zrevrankWithScore(key: GlideString, member: GlideString): Promise<[number, number] | null>;
    /**
     * Adds an entry to the specified stream stored at `key`. If the `key` doesn't exist, the stream is created.
     *
     * @see {@link https://valkey.io/commands/xadd/|valkey.io} for more details.
     *
     * @param key - The key of the stream.
     * @param values - field-value pairs to be added to the entry.
     * @param options - options detailing how to add to the stream.
     * @param options - (Optional) See {@link StreamAddOptions} and {@link DecoderOption}.
     * @returns The id of the added entry, or `null` if `options.makeStream` is set to `false` and no stream with the matching `key` exists.
     */
    xadd(key: GlideString, values: [GlideString, GlideString][], options?: StreamAddOptions & DecoderOption): Promise<GlideString | null>;
    /**
     * Removes the specified entries by id from a stream, and returns the number of entries deleted.
     *
     * @see {@link https://valkey.io/commands/xdel/|valkey.io} for more details.
     *
     * @param key - The key of the stream.
     * @param ids - An array of entry ids.
     * @returns The number of entries removed from the stream. This number may be less than the number of entries in
     *      `ids`, if the specified `ids` don't exist in the stream.
     *
     * @example
     * ```typescript
     * console.log(await client.xdel("key", ["1538561698944-0", "1538561698944-1"]));
     * // Output is 2 since the stream marked 2 entries as deleted.
     * ```
     */
    xdel(key: GlideString, ids: string[]): Promise<number>;
    /**
     * Trims the stream stored at `key` by evicting older entries.
     *
     * @see {@link https://valkey.io/commands/xtrim/|valkey.io} for more details.
     *
     * @param key - the key of the stream
     * @param options - options detailing how to trim the stream.
     * @returns The number of entries deleted from the stream. If `key` doesn't exist, 0 is returned.
     */
    xtrim(key: GlideString, options: StreamTrimOptions): Promise<number>;
    /**
     * Reads entries from the given streams.
     *
     * @see {@link https://valkey.io/commands/xread/|valkey.io} for more details.
     *
     * @param keys_and_ids - An object of stream keys and entry IDs to read from.
     * @param options - (Optional) Parameters detailing how to read the stream - see {@link StreamReadOptions} and {@link DecoderOption}.
     * @returns A list of stream keys with a `Record` of stream IDs mapped to an `Array` of entries or `null` if key does not exist.
     *
     * @example
     * ```typescript
     * const streamResults = await client.xread({"my_stream": "0-0", "writers": "0-0"});
     * console.log(result); // Output:
     * // [
     * //     {
     * //         key: "my_stream",
     * //         value: {
     * //             "1526984818136-0": [["duration", "1532"], ["event-id", "5"], ["user-id", "7782813"]],
     * //             "1526999352406-0": [["duration", "812"], ["event-id", "9"], ["user-id", "388234"]],
     * //         }
     * //     },
     * //     {
     * //         key: "writers",
     * //         value: {
     * //             "1526985676425-0": [["name", "Virginia"], ["surname", "Woolf"]],
     * //             "1526985685298-0": [["name", "Jane"], ["surname", "Austen"]],
     * //         }
     * //     }
     * // ]
     * ```
     */
    xread(keys_and_ids: Record<string, string> | GlideRecord<string>, options?: StreamReadOptions & DecoderOption): Promise<GlideRecord<StreamEntryDataType> | null>;
    /**
     * Reads entries from the given streams owned by a consumer group.
     *
     * @see {@link https://valkey.io/commands/xreadgroup/|valkey.io} for details.
     *
     * @param group - The consumer group name.
     * @param consumer - The group consumer.
     * @param keys_and_ids - An object of stream keys and entry IDs to read from.
     *     Use the special entry ID of `">"` to receive only new messages.
     * @param options - (Optional) Parameters detailing how to read the stream - see {@link StreamReadGroupOptions} and {@link DecoderOption}.
     * @returns A list of stream keys with a `Record` of stream IDs mapped to an `Array` of entries.
     *     Returns `null` if there is no stream that can be served.
     *
     * @example
     * ```typescript
     * const streamResults = await client.xreadgroup("my_group", "my_consumer", {"my_stream": "0-0", "writers_stream": "0-0", "readers_stream", ">"});
     * console.log(result); // Output:
     * // [
     * //     {
     * //         key: "my_stream",
     * //         value: {
     * //             "1526984818136-0": [["duration", "1532"], ["event-id", "5"], ["user-id", "7782813"]],
     * //             "1526999352406-0": [["duration", "812"], ["event-id", "9"], ["user-id", "388234"]],
     * //         }
     * //     },
     * //     {
     * //         key: "writers_stream",
     * //         value: {
     * //             "1526985676425-0": [["name", "Virginia"], ["surname", "Woolf"]],
     * //             "1526985685298-0": null,                                          // entry was deleted
     * //         }
     * //     },
     * //     {
     * //         key: "readers_stream",                                                // stream is empty
     * //         value: {}
     * //     }
     * // ]
     * ```
     */
    xreadgroup(group: GlideString, consumer: GlideString, keys_and_ids: Record<string, string> | GlideRecord<string>, options?: StreamReadGroupOptions & DecoderOption): Promise<GlideRecord<Record<string, [GlideString, GlideString][] | null>> | null>;
    /**
     * Returns the number of entries in the stream stored at `key`.
     *
     * @see {@link https://valkey.io/commands/xlen/|valkey.io} for more details.
     *
     * @param key - The key of the stream.
     * @returns The number of entries in the stream. If `key` does not exist, returns `0`.
     *
     * @example
     * ```typescript
     * const numEntries = await client.xlen("my_stream");
     * console.log(numEntries); // Output: 2 - "my_stream" contains 2 entries.
     * ```
     */
    xlen(key: GlideString): Promise<number>;
    /**
     * Returns stream message summary information for pending messages matching a given range of IDs.
     *
     * @see {@link https://valkey.io/commands/xpending/|valkey.io} for more details.
     *
     * @param key - The key of the stream.
     * @param group - The consumer group name.
     * @returns An `array` that includes the summary of the pending messages. See example for more details.
     * @example
     * ```typescript
     * console.log(await client.xpending("my_stream", "my_group")); // Output:
     * // [
     * //     42,                            // The total number of pending messages
     * //     "1722643465939-0",             // The smallest ID among the pending messages
     * //     "1722643484626-0",             // The greatest ID among the pending messages
     * //     [                              // A 2D-`array` of every consumer in the group
     * //         [ "consumer1", "10" ],     // with at least one pending message, and the
     * //         [ "consumer2", "32" ],     // number of pending messages it has
     * //     ]
     * // ]
     * ```
     */
    xpending(key: GlideString, group: GlideString): Promise<[number, GlideString, GlideString, [GlideString, number][]]>;
    /**
     * Returns an extended form of stream message information for pending messages matching a given range of IDs.
     *
     * @see {@link https://valkey.io/commands/xpending/|valkey.io} for more details.
     *
     * @param key - The key of the stream.
     * @param group - The consumer group name.
     * @param options - Additional options to filter entries, see {@link StreamPendingOptions}.
     * @returns A 2D-`array` of 4-tuples containing extended message information. See example for more details.
     *
     * @example
     * ```typescript
     * console.log(await client.xpending("my_stream", "my_group"), {
     *     start: { value: "0-1", isInclusive: true },
     *     end: InfBoundary.PositiveInfinity,
     *     count: 2,
     *     consumer: "consumer1"
     * }); // Output:
     * // [
     * //     [
     * //         "1722643465939-0",  // The ID of the message
     * //         "consumer1",        // The name of the consumer that fetched the message and has still to acknowledge it
     * //         174431,             // The number of milliseconds that elapsed since the last time this message was delivered to this consumer
     * //         1                   // The number of times this message was delivered
     * //     ],
     * //     [
     * //         "1722643484626-0",
     * //         "consumer1",
     * //         202231,
     * //         1
     * //     ]
     * // ]
     * ```
     */
    xpendingWithOptions(key: GlideString, group: GlideString, options: StreamPendingOptions): Promise<[GlideString, GlideString, number, number][]>;
    /**
     * Returns the list of all consumers and their attributes for the given consumer group of the
     * stream stored at `key`.
     *
     * @see {@link https://valkey.io/commands/xinfo-consumers/|valkey.io} for more details.
     *
     * @param key - The key of the stream.
     * @param group - The consumer group name.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns An `Array` of `Records`, where each mapping contains the attributes
     *     of a consumer for the given consumer group of the stream at `key`.
     *
     * @example
     * ```typescript
     * const result = await client.xinfoConsumers("my_stream", "my_group");
     * console.log(result); // Output:
     * // [
     * //     {
     * //         "name": "Alice",
     * //         "pending": 1,
     * //         "idle": 9104628,
     * //         "inactive": 18104698   // Added in 7.2.0
     * //     },
     * //     ...
     * // ]
     * ```
     */
    xinfoConsumers(key: GlideString, group: GlideString, options?: DecoderOption): Promise<Record<string, GlideString | number>[]>;
    /**
     * Returns the list of all consumer groups and their attributes for the stream stored at `key`.
     *
     * @see {@link https://valkey.io/commands/xinfo-groups/|valkey.io} for details.
     *
     * @param key - The key of the stream.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns An array of maps, where each mapping represents the
     *     attributes of a consumer group for the stream at `key`.
     * @example
     * ```typescript
     * const result = await client.xinfoGroups("my_stream");
     * console.log(result); // Output:
     * // [
     * //     {
     * //         "name": "mygroup",
     * //         "consumers": 2,
     * //         "pending": 2,
     * //         "last-delivered-id": "1638126030001-0",
     * //         "entries-read": 2,                       // Added in version 7.0.0
     * //         "lag": 0                                 // Added in version 7.0.0
     * //     },
     * //     {
     * //         "name": "some-other-group",
     * //         "consumers": 1,
     * //         "pending": 0,
     * //         "last-delivered-id": "0-0",
     * //         "entries-read": null,                    // Added in version 7.0.0
     * //         "lag": 1                                 // Added in version 7.0.0
     * //     }
     * // ]
     * ```
     */
    xinfoGroups(key: GlideString, options?: DecoderOption): Promise<Record<string, GlideString | number | null>[]>;
    /**
     * Changes the ownership of a pending message.
     *
     * @see {@link https://valkey.io/commands/xclaim/|valkey.io} for more details.
     *
     * @param key - The key of the stream.
     * @param group - The consumer group name.
     * @param consumer - The group consumer.
     * @param minIdleTime - The minimum idle time for the message to be claimed.
     * @param ids - An array of entry ids.
     * @param options - (Optional) See {@link StreamClaimOptions} and {@link DecoderOption}.
     * @returns A `Record` of message entries that are claimed by the consumer.
     *
     * @example
     * ```typescript
     * const result = await client.xclaim("myStream", "myGroup", "myConsumer", 42,
     *     ["1-0", "2-0", "3-0"], { idle: 500, retryCount: 3, isForce: true });
     * console.log(result); // Output:
     * // {
     * //     "2-0": [["duration", "1532"], ["event-id", "5"], ["user-id", "7782813"]]
     * // }
     * ```
     */
    xclaim(key: GlideString, group: GlideString, consumer: GlideString, minIdleTime: number, ids: string[], options?: StreamClaimOptions & DecoderOption): Promise<StreamEntryDataType>;
    /**
     * Transfers ownership of pending stream entries that match the specified criteria.
     *
     * @see {@link https://valkey.io/commands/xautoclaim/|valkey.io} for more details.
     * @remarks Since Valkey version 6.2.0.
     *
     * @param key - The key of the stream.
     * @param group - The consumer group name.
     * @param consumer - The group consumer.
     * @param minIdleTime - The minimum idle time for the message to be claimed.
     * @param start - Filters the claimed entries to those that have an ID equal or greater than the
     *     specified value.
     * @param options - (Optional) Additional parameters:
     * - (Optional) `count`: the number of claimed entries.
     * - (Optional) `decoder`: see {@link DecoderOption}.
     * @returns A `tuple` containing the following elements:
     *   - A stream ID to be used as the start argument for the next call to `XAUTOCLAIM`. This ID is
     *     equivalent to the next ID in the stream after the entries that were scanned, or "0-0" if
     *     the entire stream was scanned.
     *   - A `Record` of the claimed entries.
     *   - If you are using Valkey 7.0.0 or above, the response list will also include a list containing
     *     the message IDs that were in the Pending Entries List but no longer exist in the stream.
     *     These IDs are deleted from the Pending Entries List.
     *
     * @example
     * ```typescript
     * const result = await client.xautoclaim("myStream", "myGroup", "myConsumer", 42, "0-0", { count: 25 });
     * console.log(result); // Output:
     * // [
     * //     "1609338788321-0",                // value to be used as `start` argument
     * //                                       // for the next `xautoclaim` call
     * //     {
     * //         "1609338752495-0": [          // claimed entries
     * //             ["field 1", "value 1"],
     * //             ["field 2", "value 2"]
     * //         ]
     * //     },
     * //     [
     * //         "1594324506465-0",            // array of IDs of deleted messages,
     * //         "1594568784150-0"             // included in the response only on valkey 7.0.0 and above
     * //     ]
     * // ]
     * ```
     */
    xautoclaim(key: GlideString, group: GlideString, consumer: GlideString, minIdleTime: number, start: string, options?: {
        count?: number;
    } & DecoderOption): Promise<[GlideString, StreamEntryDataType, GlideString[]?]>;
    /**
     * Transfers ownership of pending stream entries that match the specified criteria.
     *
     * @see {@link https://valkey.io/commands/xautoclaim/|valkey.io} for more details.
     * @remarks Since Valkey version 6.2.0.
     *
     * @param key - The key of the stream.
     * @param group - The consumer group name.
     * @param consumer - The group consumer.
     * @param minIdleTime - The minimum idle time for the message to be claimed.
     * @param start - Filters the claimed entries to those that have an ID equal or greater than the
     *     specified value.
     * @param options - (Optional) Additional parameters:
     * - (Optional) `count`: limits the number of claimed entries to the specified value.
     * @returns An `array` containing the following elements:
     *   - A stream ID to be used as the start argument for the next call to `XAUTOCLAIM`. This ID is
     *     equivalent to the next ID in the stream after the entries that were scanned, or "0-0" if
     *     the entire stream was scanned.
     *   - A list of the IDs for the claimed entries.
     *   - If you are using Valkey 7.0.0 or above, the response list will also include a list containing
     *     the message IDs that were in the Pending Entries List but no longer exist in the stream.
     *     These IDs are deleted from the Pending Entries List.
     *
     * @example
     * ```typescript
     * const result = await client.xautoclaim("myStream", "myGroup", "myConsumer", 42, "0-0", { count: 25 });
     * console.log(result); // Output:
     * // [
     * //     "1609338788321-0",                // value to be used as `start` argument
     * //                                       // for the next `xautoclaim` call
     * //     [
     * //         "1609338752495-0",            // claimed entries
     * //         "1609338752495-1",
     * //     ],
     * //     [
     * //         "1594324506465-0",            // array of IDs of deleted messages,
     * //         "1594568784150-0"             // included in the response only on valkey 7.0.0 and above
     * //     ]
     * // ]
     * ```
     */
    xautoclaimJustId(key: GlideString, group: GlideString, consumer: GlideString, minIdleTime: number, start: string, options?: {
        count?: number;
    }): Promise<[string, string[], string[]?]>;
    /**
     * Changes the ownership of a pending message. This function returns an `array` with
     * only the message/entry IDs, and is equivalent to using `JUSTID` in the Valkey API.
     *
     * @see {@link https://valkey.io/commands/xclaim/|valkey.io} for more details.
     *
     * @param key - The key of the stream.
     * @param group - The consumer group name.
     * @param consumer - The group consumer.
     * @param minIdleTime - The minimum idle time for the message to be claimed.
     * @param ids - An array of entry ids.
     * @param options - (Optional) Stream claim options {@link StreamClaimOptions}.
     * @returns An `array` of message ids claimed by the consumer.
     *
     * @example
     * ```typescript
     * const result = await client.xclaimJustId("my_stream", "my_group", "my_consumer", 42,
     *     ["1-0", "2-0", "3-0"], { idle: 500, retryCount: 3, isForce: true });
     * console.log(result); // Output: [ "2-0", "3-0" ]
     * ```
     */
    xclaimJustId(key: GlideString, group: GlideString, consumer: GlideString, minIdleTime: number, ids: string[], options?: StreamClaimOptions): Promise<string[]>;
    /**
     * Creates a new consumer group uniquely identified by `groupname` for the stream stored at `key`.
     *
     * @see {@link https://valkey.io/commands/xgroup-create/|valkey.io} for more details.
     *
     * @param key - The key of the stream.
     * @param groupName - The newly created consumer group name.
     * @param id - Stream entry ID that specifies the last delivered entry in the stream from the new
     *     group’s perspective. The special ID `"$"` can be used to specify the last entry in the stream.
     * @returns `"OK"`.
     *
     * @example
     * ```typescript
     * // Create the consumer group "mygroup", using zero as the starting ID:
     * console.log(await client.xgroupCreate("mystream", "mygroup", "0-0")); // Output is "OK"
     * ```
     */
    xgroupCreate(key: GlideString, groupName: GlideString, id: string, options?: StreamGroupOptions): Promise<"OK">;
    /**
     * Destroys the consumer group `groupname` for the stream stored at `key`.
     *
     * @see {@link https://valkey.io/commands/xgroup-destroy/|valkey.io} for more details.
     *
     * @param key - The key of the stream.
     * @param groupname - The newly created consumer group name.
     * @returns `true` if the consumer group is destroyed. Otherwise, `false`.
     *
     * @example
     * ```typescript
     * // Destroys the consumer group "mygroup"
     * console.log(await client.xgroupDestroy("mystream", "mygroup")); // Output is true
     * ```
     */
    xgroupDestroy(key: GlideString, groupName: GlideString): Promise<boolean>;
    /**
     * Returns information about the stream stored at `key`.
     *
     * @see {@link https://valkey.io/commands/xinfo-stream/|valkey.io} for more details.
     *
     * @param key - The key of the stream.
     * @param options - (Optional) Additional parameters:
     * - (Optional) `fullOptions`: If `true`, returns verbose information with a limit of the first 10 PEL entries.
     * If `number` is specified, returns verbose information limiting the returned PEL entries.
     * If `0` is specified, returns verbose information with no limit.
     * - (Optional) `decoder`: see {@link DecoderOption}.
     * @returns A {@link ReturnTypeXinfoStream} of detailed stream information for the given `key`. See
     *     the example for a sample response.
     *
     * @example
     * ```typescript
     * const infoResult = await client.xinfoStream("my_stream");
     * console.log(infoResult);
     * // Output: {
     * //   length: 2,
     * //   'radix-tree-keys': 1,
     * //   'radix-tree-nodes': 2,
     * //   'last-generated-id': '1719877599564-1',
     * //   'max-deleted-entry-id': '0-0',
     * //   'entries-added': 2,
     * //   'recorded-first-entry-id': '1719877599564-0',
     * //   'first-entry': [ '1719877599564-0', ['some_field", "some_value', ...] ],
     * //   'last-entry': [ '1719877599564-0', ['some_field", "some_value', ...] ],
     * //   groups: 1,
     * // }
     * ```
     *
     * @example
     * ```typescript
     * const infoResult = await client.xinfoStream("my_stream", true); // default limit of 10 entries
     * const infoResult = await client.xinfoStream("my_stream", 15); // limit of 15 entries
     * console.log(infoResult);
     * // Output: {
     * //   'length': 2,
     * //   'radix-tree-keys': 1,
     * //   'radix-tree-nodes': 2,
     * //   'last-generated-id': '1719877599564-1',
     * //   'max-deleted-entry-id': '0-0',
     * //   'entries-added': 2,
     * //   'recorded-first-entry-id': '1719877599564-0',
     * //   'entries': [ [ '1719877599564-0', ['some_field", "some_value', ...] ] ],
     * //   'groups': [ {
     * //     'name': 'group',
     * //     'last-delivered-id': '1719877599564-0',
     * //     'entries-read': 1,
     * //     'lag': 1,
     * //     'pel-count': 1,
     * //     'pending': [ [ '1719877599564-0', 'consumer', 1722624726802, 1 ] ],
     * //     'consumers': [ {
     * //         'name': 'consumer',
     * //         'seen-time': 1722624726802,
     * //         'active-time': 1722624726802,
     * //         'pel-count': 1,
     * //         'pending': [ [ '1719877599564-0', 'consumer', 1722624726802, 1 ] ],
     * //         }
     * //       ]
     * //     }
     * //   ]
     * // }
     * ```
     */
    xinfoStream(key: GlideString, options?: {
        fullOptions?: boolean | number;
    } & DecoderOption): Promise<ReturnTypeXinfoStream>;
    /**
     * Creates a consumer named `consumerName` in the consumer group `groupName` for the stream stored at `key`.
     *
     * @see {@link https://valkey.io/commands/xgroup-createconsumer/|valkey.io} for more details.
     *
     * @param key - The key of the stream.
     * @param groupName - The consumer group name.
     * @param consumerName - The newly created consumer.
     * @returns `true` if the consumer is created. Otherwise, returns `false`.
     *
     * @example
     * ```typescript
     * // The consumer "myconsumer" was created in consumer group "mygroup" for the stream "mystream".
     * console.log(await client.xgroupCreateConsumer("mystream", "mygroup", "myconsumer")); // Output is true
     * ```
     */
    xgroupCreateConsumer(key: GlideString, groupName: GlideString, consumerName: GlideString): Promise<boolean>;
    /**
     * Deletes a consumer named `consumerName` in the consumer group `groupName` for the stream stored at `key`.
     *
     * @see {@link https://valkey.io/commands/xgroup-delconsumer/|valkey.io} for more details.
     *
     * @param key - The key of the stream.
     * @param groupName - The consumer group name.
     * @param consumerName - The consumer to delete.
     * @returns The number of pending messages the `consumer` had before it was deleted.
     *
     * * @example
     * ```typescript
     * // Consumer "myconsumer" was deleted, and had 5 pending messages unclaimed.
     * console.log(await client.xgroupDelConsumer("mystream", "mygroup", "myconsumer")); // Output is 5
     * ```
     */
    xgroupDelConsumer(key: GlideString, groupName: GlideString, consumerName: GlideString): Promise<number>;
    private readonly MAP_READ_FROM_STRATEGY;
    /**
     * Returns the number of messages that were successfully acknowledged by the consumer group member of a stream.
     * This command should be called on a pending message so that such message does not get processed again.
     *
     * @see {@link https://valkey.io/commands/xack/|valkey.io} for details.
     *
     * @param key - The key of the stream.
     * @param group - The consumer group name.
     * @param ids - An array of entry ids.
     * @returns The number of messages that were successfully acknowledged.
     *
     * @example
     * ```typescript
     * const entryId = await client.xadd("mystream", ["myfield", "mydata"]);
     * // read messages from streamId
     * const readResult = await client.xreadgroup(["myfield", "mydata"], "mygroup", "my0consumer");
     * // acknowledge messages on stream
     * console.log(await client.xack("mystream", "mygroup", [entryId])); // Output: 1
     * ```
     */
    xack(key: GlideString, group: GlideString, ids: string[]): Promise<number>;
    /**
     * Sets the last delivered ID for a consumer group.
     *
     * @see {@link https://valkey.io/commands/xgroup-setid|valkey.io} for more details.
     *
     * @param key - The key of the stream.
     * @param groupName - The consumer group name.
     * @param id - The stream entry ID that should be set as the last delivered ID for the consumer group.
     * @param options - (Optional) Additional parameters:
     * - (Optional) `entriesRead`: the number of stream entries already read by the group.
     *     This option can only be specified if you are using Valkey version 7.0.0 or above.
     * @returns `"OK"`.
     *
     * * @example
     * ```typescript
     * console.log(await client.xgroupSetId("mystream", "mygroup", "0", { entriesRead: 1 })); // Output is "OK"
     * ```
     */
    xgroupSetId(key: GlideString, groupName: GlideString, id: string, options?: {
        entriesRead?: number;
    }): Promise<"OK">;
    /** Returns the element at index `index` in the list stored at `key`.
     * The index is zero-based, so 0 means the first element, 1 the second element and so on.
     * Negative indices can be used to designate elements starting at the tail of the list.
     * Here, -1 means the last element, -2 means the penultimate and so forth.
     *
     * @see {@link https://valkey.io/commands/lindex/|valkey.io} for more details.
     *
     * @param key - The `key` of the list.
     * @param index - The `index` of the element in the list to retrieve.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns - The element at `index` in the list stored at `key`.
     * If `index` is out of range or if `key` does not exist, null is returned.
     *
     * @example
     * ```typescript
     * // Example usage of lindex method to retrieve elements from a list by index
     * const result = await client.lindex("my_list", 0);
     * console.log(result); // Output: 'value1' - Returns the first element in the list stored at 'my_list'.
     * ```
     *
     * @example
     * ```typescript
     * // Example usage of lindex method to retrieve elements from a list by negative index
     * const result = await client.lindex("my_list", -1);
     * console.log(result); // Output: 'value3' - Returns the last element in the list stored at 'my_list'.
     * ```
     */
    lindex(key: GlideString, index: number, options?: DecoderOption): Promise<GlideString | null>;
    /**
     * Inserts `element` in the list at `key` either before or after the `pivot`.
     *
     * @see {@link https://valkey.io/commands/linsert/|valkey.io} for more details.
     *
     * @param key - The key of the list.
     * @param position - The relative position to insert into - either `InsertPosition.Before` or
     *     `InsertPosition.After` the `pivot`.
     * @param pivot - An element of the list.
     * @param element - The new element to insert.
     * @returns The list length after a successful insert operation.
     * If the `key` doesn't exist returns `-1`.
     * If the `pivot` wasn't found, returns `0`.
     *
     * @example
     * ```typescript
     * const length = await client.linsert("my_list", InsertPosition.Before, "World", "There");
     * console.log(length); // Output: 2 - The list has a length of 2 after performing the insert.
     * ```
     */
    linsert(key: GlideString, position: InsertPosition, pivot: GlideString, element: GlideString): Promise<number>;
    /**
     * Removes the existing timeout on `key`, turning the key from volatile (a key with an expire set) to
     * persistent (a key that will never expire as no timeout is associated).
     *
     * @see {@link https://valkey.io/commands/persist/|valkey.io} for more details.
     *
     * @param key - The key to remove the existing timeout on.
     * @returns `false` if `key` does not exist or does not have an associated timeout, `true` if the timeout has been removed.
     *
     * @example
     * ```typescript
     * // Example usage of persist method to remove the timeout associated with a key
     * const result = await client.persist("my_key");
     * console.log(result); // Output: true - Indicates that the timeout associated with the key "my_key" was successfully removed.
     * ```
     */
    persist(key: GlideString): Promise<boolean>;
    /**
     * Renames `key` to `newkey`.
     * If `newkey` already exists it is overwritten.
     *
     * @see {@link https://valkey.io/commands/rename/|valkey.io} for more details.
     * @remarks When in cluster mode, `key` and `newKey` must map to the same hash slot.
     *
     * @param key - The key to rename.
     * @param newKey - The new name of the key.
     * @returns - If the `key` was successfully renamed, return "OK". If `key` does not exist, an error is thrown.
     *
     * @example
     * ```typescript
     * // Example usage of rename method to rename a key
     * await client.set("old_key", "value");
     * const result = await client.rename("old_key", "new_key");
     * console.log(result); // Output: OK - Indicates successful renaming of the key "old_key" to "new_key".
     * ```
     */
    rename(key: GlideString, newKey: GlideString): Promise<"OK">;
    /**
     * Renames `key` to `newkey` if `newkey` does not yet exist.
     *
     * @see {@link https://valkey.io/commands/renamenx/|valkey.io} for more details.
     * @remarks When in cluster mode, `key` and `newKey` must map to the same hash slot.
     *
     * @param key - The key to rename.
     * @param newKey - The new name of the key.
     * @returns - If the `key` was successfully renamed, returns `true`. Otherwise, returns `false`.
     * If `key` does not exist, an error is thrown.
     *
     * @example
     * ```typescript
     * // Example usage of renamenx method to rename a key
     * await client.set("old_key", "value");
     * const result = await client.renamenx("old_key", "new_key");
     * console.log(result); // Output: true - Indicates successful renaming of the key "old_key" to "new_key".
     * ```
     */
    renamenx(key: GlideString, newKey: GlideString): Promise<boolean>;
    /** Blocking list pop primitive.
     * Pop an element from the tail of the first list that is non-empty,
     * with the given `keys` being checked in the order that they are given.
     * Blocks the connection when there are no elements to pop from any of the given lists.
     *
     * @see {@link https://valkey.io/commands/brpop/|valkey.io} for more details.
     * @remarks When in cluster mode, all `keys` must map to the same hash slot.
     * @remarks `BRPOP` is a blocking command, see [Blocking Commands](https://github.com/valkey-io/valkey-glide/wiki/General-Concepts#blocking-commands) for more details and best practices.
     *
     * @param keys - The `keys` of the lists to pop from.
     * @param timeout - The `timeout` in seconds.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns - An `array` containing the `key` from which the element was popped and the value of the popped element,
     * formatted as [key, value]. If no element could be popped and the timeout expired, returns `null`.
     *
     * @example
     * ```typescript
     * // Example usage of brpop method to block and wait for elements from multiple lists
     * const result = await client.brpop(["list1", "list2"], 5);
     * console.log(result); // Output: ["list1", "element"] - Indicates an element "element" was popped from "list1".
     * ```
     */
    brpop(keys: GlideString[], timeout: number, options?: DecoderOption): Promise<[GlideString, GlideString] | null>;
    /** Blocking list pop primitive.
     * Pop an element from the head of the first list that is non-empty,
     * with the given `keys` being checked in the order that they are given.
     * Blocks the connection when there are no elements to pop from any of the given lists.
     *
     * @see {@link https://valkey.io/commands/blpop/|valkey.io} for more details.
     * @remarks When in cluster mode, all `keys` must map to the same hash slot.
     * @remarks `BLPOP` is a blocking command, see [Blocking Commands](https://github.com/valkey-io/valkey-glide/wiki/General-Concepts#blocking-commands) for more details and best practices.
     *
     * @param keys - The `keys` of the lists to pop from.
     * @param timeout - The `timeout` in seconds.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns - An `array` containing the `key` from which the element was popped and the value of the popped element,
     * formatted as [key, value]. If no element could be popped and the timeout expired, returns `null`.
     *
     * @example
     * ```typescript
     * const result = await client.blpop(["list1", "list2"], 5);
     * console.log(result); // Output: ['list1', 'element']
     * ```
     */
    blpop(keys: GlideString[], timeout: number, options?: DecoderOption): Promise<[GlideString, GlideString] | null>;
    /** Adds all elements to the HyperLogLog data structure stored at the specified `key`.
     * Creates a new structure if the `key` does not exist.
     * When no elements are provided, and `key` exists and is a HyperLogLog, then no operation is performed.
     *
     * @see {@link https://valkey.io/commands/pfadd/|valkey.io} for more details.
     *
     * @param key - The key of the HyperLogLog data structure to add elements into.
     * @param elements - An array of members to add to the HyperLogLog stored at `key`.
     * @returns - If the HyperLogLog is newly created, or if the HyperLogLog approximated cardinality is
     *     altered, then returns `1`. Otherwise, returns `0`.
     * @example
     * ```typescript
     * const result = await client.pfadd("hll_1", ["a", "b", "c"]);
     * console.log(result); // Output: 1 - Indicates that a data structure was created or modified
     * const result = await client.pfadd("hll_2", []);
     * console.log(result); // Output: 1 - Indicates that a new empty data structure was created
     * ```
     */
    pfadd(key: GlideString, elements: GlideString[]): Promise<number>;
    /** Estimates the cardinality of the data stored in a HyperLogLog structure for a single key or
     * calculates the combined cardinality of multiple keys by merging their HyperLogLogs temporarily.
     *
     * @see {@link https://valkey.io/commands/pfcount/|valkey.io} for more details.
     * @remarks When in cluster mode, all `keys` must map to the same hash slot.
     *
     * @param keys - The keys of the HyperLogLog data structures to be analyzed.
     * @returns - The approximated cardinality of given HyperLogLog data structures.
     *     The cardinality of a key that does not exist is `0`.
     * @example
     * ```typescript
     * const result = await client.pfcount(["hll_1", "hll_2"]);
     * console.log(result); // Output: 4 - The approximated cardinality of the union of "hll_1" and "hll_2"
     * ```
     */
    pfcount(keys: GlideString[]): Promise<number>;
    /**
     * Merges multiple HyperLogLog values into a unique value. If the destination variable exists, it is
     * treated as one of the source HyperLogLog data sets, otherwise a new HyperLogLog is created.
     *
     * @see {@link https://valkey.io/commands/pfmerge/|valkey.io} for more details.
     * @remarks When in Cluster mode, all keys in `sourceKeys` and `destination` must map to the same hash slot.
     *
     * @param destination - The key of the destination HyperLogLog where the merged data sets will be stored.
     * @param sourceKeys - The keys of the HyperLogLog structures to be merged.
     * @returns A simple "OK" response.
     *
     * @example
     * ```typescript
     * await client.pfadd("hll1", ["a", "b"]);
     * await client.pfadd("hll2", ["b", "c"]);
     * const result = await client.pfmerge("new_hll", ["hll1", "hll2"]);
     * console.log(result); // Output: OK  - The value of "hll1" merged with "hll2" was stored in "new_hll".
     * const count = await client.pfcount(["new_hll"]);
     * console.log(count); // Output: 3  - The approximated cardinality of "new_hll" is 3.
     * ```
     */
    pfmerge(destination: GlideString, sourceKeys: GlideString[]): Promise<"OK">;
    /**
     * Returns the internal encoding for the Valkey object stored at `key`.
     *
     * @see {@link https://valkey.io/commands/object-encoding/|valkey.io} for more details.
     *
     * @param key - The `key` of the object to get the internal encoding of.
     * @returns - If `key` exists, returns the internal encoding of the object stored at `key` as a string.
     *     Otherwise, returns `null`.
     *
     * @example
     * ```typescript
     * const result = await client.objectEncoding("my_hash");
     * console.log(result); // Output: "listpack"
     * ```
     */
    objectEncoding(key: GlideString): Promise<string | null>;
    /**
     * Returns the logarithmic access frequency counter of a Valkey object stored at `key`.
     *
     * @see {@link https://valkey.io/commands/object-freq/|valkey.io} for more details.
     *
     * @param key - The `key` of the object to get the logarithmic access frequency counter of.
     * @returns - If `key` exists, returns the logarithmic access frequency counter of the object
     *            stored at `key` as a `number`. Otherwise, returns `null`.
     *
     * @example
     * ```typescript
     * const result = await client.objectFreq("my_hash");
     * console.log(result); // Output: 2 - The logarithmic access frequency counter of "my_hash".
     * ```
     */
    objectFreq(key: GlideString): Promise<number | null>;
    /**
     * Returns the time in seconds since the last access to the value stored at `key`.
     *
     * @see {@link https://valkey.io/commands/object-idletime/|valkey.io} for more details.
     *
     * @param key - The key of the object to get the idle time of.
     * @returns If `key` exists, returns the idle time in seconds. Otherwise, returns `null`.
     *
     * @example
     * ```typescript
     * const result = await client.objectIdletime("my_hash");
     * console.log(result); // Output: 13 - "my_hash" was last accessed 13 seconds ago.
     * ```
     */
    objectIdletime(key: GlideString): Promise<number | null>;
    /**
     * Returns the reference count of the object stored at `key`.
     *
     * @see {@link https://valkey.io/commands/object-refcount/|valkey.io} for more details.
     *
     * @param key - The `key` of the object to get the reference count of.
     * @returns If `key` exists, returns the reference count of the object stored at `key` as a `number`.
     * Otherwise, returns `null`.
     *
     * @example
     * ```typescript
     * const result = await client.objectRefcount("my_hash");
     * console.log(result); // Output: 2 - "my_hash" has a reference count of 2.
     * ```
     */
    objectRefcount(key: GlideString): Promise<number | null>;
    /**
     * Invokes a previously loaded function.
     *
     * @see {@link https://valkey.io/commands/fcall/|valkey.io} for more details.
     * @remarks When in cluster mode, all `keys` must map to the same hash slot.
     * @remarks Since Valkey version 7.0.0.
     *
     * @param func - The function name.
     * @param keys - A list of `keys` accessed by the function. To ensure the correct execution of functions,
     *     all names of keys that a function accesses must be explicitly provided as `keys`.
     * @param args - A list of `function` arguments and it should not represent names of keys.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns The invoked function's return value.
     *
     * @example
     * ```typescript
     * const response = await client.fcall("Deep_Thought", [], []);
     * console.log(response); // Output: Returns the function's return value.
     * ```
     */
    fcall(func: GlideString, keys: GlideString[], args: GlideString[], options?: DecoderOption): Promise<GlideReturnType>;
    /**
     * Invokes a previously loaded read-only function.
     *
     * @see {@link https://valkey.io/commands/fcall/|valkey.io} for more details.
     * @remarks When in cluster mode, all `keys` must map to the same hash slot.
     * @remarks Since Valkey version 7.0.0.
     *
     * @param func - The function name.
     * @param keys - A list of `keys` accessed by the function. To ensure the correct execution of functions,
     *     all names of keys that a function accesses must be explicitly provided as `keys`.
     * @param args - A list of `function` arguments and it should not represent names of keys.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns The invoked function's return value.
     *
     * @example
     * ```typescript
     * const response = await client.fcallReadOnly("Deep_Thought", ["key1"], ["Answer", "to", "the",
     *            "Ultimate", "Question", "of", "Life,", "the", "Universe,", "and", "Everything"]);
     * console.log(response); // Output: 42 # The return value on the function that was executed.
     * ```
     */
    fcallReadonly(func: GlideString, keys: GlideString[], args: GlideString[], options?: DecoderOption): Promise<GlideReturnType>;
    /**
     * Returns the index of the first occurrence of `element` inside the list specified by `key`. If no
     * match is found, `null` is returned. If the `count` option is specified, then the function returns
     * an `array` of indices of matching elements within the list.
     *
     * @see {@link https://valkey.io/commands/lpos/|valkey.io} for more details.
     * @remarks Since Valkey version 6.0.6.
     *
     * @param key - The name of the list.
     * @param element - The value to search for within the list.
     * @param options - (Optional) The LPOS options - see {@link LPosOptions}.
     * @returns The index of `element`, or `null` if `element` is not in the list. If the `count` option
     * is specified, then the function returns an `array` of indices of matching elements within the list.
     *
     * @example
     * ```typescript
     * await client.rpush("myList", ["a", "b", "c", "d", "e", "e"]);
     * console.log(await client.lpos("myList", "e", { rank: 2 })); // Output: 5 - the second occurrence of "e" is at index 5.
     * console.log(await client.lpos("myList", "e", { count: 3 })); // Output: [ 4, 5 ] - indices for the occurrences of "e" in list "myList".
     * ```
     */
    lpos(key: GlideString, element: GlideString, options?: LPosOptions): Promise<number | number[] | null>;
    /**
     * Counts the number of set bits (population counting) in the string stored at `key`. The `options` argument can
     * optionally be provided to count the number of bits in a specific string interval.
     *
     * @see {@link https://valkey.io/commands/bitcount/|valkey.io} for more details.
     *
     * @param key - The key for the string to count the set bits of.
     * @param options - The offset options - see {@link BitOffsetOptions}.
     * @returns If `options` is provided, returns the number of set bits in the string interval specified by `options`.
     *     If `options` is not provided, returns the number of set bits in the string stored at `key`.
     *     Otherwise, if `key` is missing, returns `0` as it is treated as an empty string.
     *
     * @example
     * ```typescript
     * console.log(await client.bitcount("my_key1")); // Output: 2 - The string stored at "my_key1" contains 2 set bits.
     * console.log(await client.bitcount("my_key2", { start: 1 })); // Output: 8 - From the second to to the last bytes of the string stored at "my_key2" are contain 8 set bits.
     * console.log(await client.bitcount("my_key2", { start: 1, end: 3 })); // Output: 2 - The second to fourth bytes of the string stored at "my_key2" contain 2 set bits.
     * console.log(await client.bitcount("my_key3", { start: 1, end: 1, indexType: BitmapIndexType.BIT })); // Output: 1 - Indicates that the second bit of the string stored at "my_key3" is set.
     * console.log(await client.bitcount("my_key3", { start: -1, end: -1, indexType: BitmapIndexType.BIT })); // Output: 1 - Indicates that the last bit of the string stored at "my_key3" is set.
     * ```
     */
    bitcount(key: GlideString, options?: BitOffsetOptions): Promise<number>;
    /**
     * Adds geospatial members with their positions to the specified sorted set stored at `key`.
     * If a member is already a part of the sorted set, its position is updated.
     *
     * @see {@link https://valkey.io/commands/geoadd/|valkey.io} for more details.
     *
     * @param key - The key of the sorted set.
     * @param membersToGeospatialData - A mapping of member names to their corresponding positions - see
     *     {@link GeospatialData}. The command will report an error when the user attempts to index
     *     coordinates outside the specified ranges.
     * @param options - The GeoAdd options - see {@link GeoAddOptions}.
     * @returns The number of elements added to the sorted set. If `changed` is set to
     *    `true` in the options, returns the number of elements updated in the sorted set.
     *
     * @example
     * ```typescript
     * const options = {updateMode: ConditionalChange.ONLY_IF_EXISTS, changed: true};
     * const membersToCoordinates = new Map<string, GeospatialData>([
     *      ["Palermo", { longitude: 13.361389, latitude: 38.115556 }],
     * ]);
     * const num = await client.geoadd("mySortedSet", membersToCoordinates, options);
     * console.log(num); // Output: 1 - Indicates that the position of an existing member in the sorted set "mySortedSet" has been updated.
     * ```
     */
    geoadd(key: GlideString, membersToGeospatialData: Map<GlideString, GeospatialData>, options?: GeoAddOptions): Promise<number>;
    /**
     * Returns the members of a sorted set populated with geospatial information using {@link geoadd},
     * which are within the borders of the area specified by a given shape.
     *
     * @see {@link https://valkey.io/commands/geosearch/|valkey.io} for more details.
     * @remarks Since Valkey version 6.2.0.
     *
     * @param key - The key of the sorted set.
     * @param searchFrom - The query's center point options, could be one of:
     * - {@link MemberOrigin} to use the position of the given existing member in the sorted set.
     * - {@link CoordOrigin} to use the given longitude and latitude coordinates.
     * @param searchBy - The query's shape options, could be one of:
     * - {@link GeoCircleShape} to search inside circular area according to given radius.
     * - {@link GeoBoxShape} to search inside an axis-aligned rectangle, determined by height and width.
     * @param options - (Optional) Parameters to request additional information and configure sorting/limiting the results,
     *     see {@link GeoSearchResultOptions} and {@link DecoderOption}.
     * @returns By default, returns an `Array` of members (locations) names.
     *     If any of `withCoord`, `withDist` or `withHash` are set to `true` in {@link GeoSearchResultOptions}, a 2D `Array` returned,
     *     where each sub-array represents a single item in the following order:
     * - The member (location) name.
     * - The distance from the center as a floating point `number`, in the same unit specified for `searchBy`, if `withDist` is set to `true`.
     * - The geohash of the location as a integer `number`, if `withHash` is set to `true`.
     * - The coordinates as a two item `array` of floating point `number`s, if `withCoord` is set to `true`.
     *
     * @example
     * ```typescript
     * const data = new Map<GlideString, GeospatialData>([["Palermo", { longitude: 13.361389, latitude: 38.115556 }], ["Catania", { longitude: 15.087269, latitude: 37.502669 }]]);
     * await client.geoadd("mySortedSet", data);
     * // search for locations within 200 km circle around stored member named 'Palermo'
     * const result1 = await client.geosearch("mySortedSet", { member: "Palermo" }, { radius: 200, unit: GeoUnit.KILOMETERS });
     * console.log(result1); // Output: ['Palermo', 'Catania']
     *
     * // search for locations in 200x300 mi rectangle centered at coordinate (15, 37), requesting additional info,
     * // limiting results by 2 best matches, ordered by ascending distance from the search area center
     * const result2 = await client.geosearch(
     *     "mySortedSet",
     *     { position: { longitude: 15, latitude: 37 } },
     *     { width: 200, height: 300, unit: GeoUnit.MILES },
     *     {
     *         sortOrder: SortOrder.ASC,
     *         count: 2,
     *         withCoord: true,
     *         withDist: true,
     *         withHash: true,
     *     },
     * );
     * console.log(result2); // Output:
     * // [
     * //     [
     * //         'Catania',                                       // location name
     * //         [
     * //             56.4413,                                     // distance
     * //             3479447370796909,                            // geohash of the location
     * //             [15.087267458438873, 37.50266842333162],     // coordinates of the location
     * //         ],
     * //     ],
     * //     [
     * //         'Palermo',
     * //         [
     * //             190.4424,
     * //             3479099956230698,
     * //             [13.361389338970184, 38.1155563954963],
     * //         ],
     * //     ],
     * // ]
     * ```
     */
    geosearch(key: GlideString, searchFrom: SearchOrigin, searchBy: GeoSearchShape, options?: GeoSearchResultOptions & DecoderOption): Promise<[GlideString, [number?, number?, [number, number]?]?][]>;
    /**
     * Searches for members in a sorted set stored at `source` representing geospatial data
     * within a circular or rectangular area and stores the result in `destination`.
     *
     * If `destination` already exists, it is overwritten. Otherwise, a new sorted set will be created.
     *
     * To get the result directly, see {@link geosearch}.
     *
     * @see {@link https://valkey.io/commands/geosearchstore/|valkey.io} for more details.
     * @remarks When in cluster mode, `destination` and `source` must map to the same hash slot.
     * @remarks Since Valkey version 6.2.0.
     *
     * @param destination - The key of the destination sorted set.
     * @param source - The key of the sorted set.
     * @param searchFrom - The query's center point options, could be one of:
     * - {@link MemberOrigin} to use the position of the given existing member in the sorted set.
     * - {@link CoordOrigin} to use the given longitude and latitude coordinates.
     * @param searchBy - The query's shape options, could be one of:
     * - {@link GeoCircleShape} to search inside circular area according to given radius.
     * - {@link GeoBoxShape} to search inside an axis-aligned rectangle, determined by height and width.
     * @param options - (Optional) Parameters to request additional information and configure sorting/limiting the results,
     *     see {@link GeoSearchStoreResultOptions}.
     * @returns The number of elements in the resulting sorted set stored at `destination`.
     *
     * @example
     * ```typescript
     * const data = new Map([["Palermo", { longitude: 13.361389, latitude: 38.115556 }], ["Catania", { longitude: 15.087269, latitude: 37.502669 }]]);
     * await client.geoadd("mySortedSet", data);
     * // search for locations within 200 km circle around stored member named 'Palermo' and store in `destination`:
     * await client.geosearchstore("destination", "mySortedSet", { member: "Palermo" }, { radius: 200, unit: GeoUnit.KILOMETERS });
     * // query the stored results
     * const result1 = await client.zrangeWithScores("destination", { start: 0, end: -1 });
     * console.log(result1); // Output:
     * // {
     * //     Palermo: 3479099956230698,   // geohash of the location is stored as element's score
     * //     Catania: 3479447370796909
     * // }
     *
     * // search for locations in 200x300 mi rectangle centered at coordinate (15, 37), requesting to store distance instead of geohashes,
     * // limiting results by 2 best matches, ordered by ascending distance from the search area center
     * await client.geosearchstore(
     *     "destination",
     *     "mySortedSet",
     *     { position: { longitude: 15, latitude: 37 } },
     *     { width: 200, height: 300, unit: GeoUnit.MILES },
     *     {
     *         sortOrder: SortOrder.ASC,
     *         count: 2,
     *         storeDist: true,
     *     },
     * );
     * // query the stored results
     * const result2 = await client.zrangeWithScores("destination", { start: 0, end: -1 });
     * console.log(result2); // Output:
     * // {
     * //     Palermo: 190.4424,   // distance from the search area center is stored as element's score
     * //     Catania: 56.4413,    // the distance is measured in units used for the search query (miles)
     * // }
     * ```
     */
    geosearchstore(destination: GlideString, source: GlideString, searchFrom: SearchOrigin, searchBy: GeoSearchShape, options?: GeoSearchStoreResultOptions): Promise<number>;
    /**
     * Returns the positions (longitude, latitude) of all the specified `members` of the
     * geospatial index represented by the sorted set at `key`.
     *
     * @see {@link https://valkey.io/commands/geopos/|valkey.io} for more details.
     *
     * @param key - The key of the sorted set.
     * @param members - The members for which to get the positions.
     * @returns A 2D `Array` which represents positions (longitude and latitude) corresponding to the
     *     given members. The order of the returned positions matches the order of the input members.
     *     If a member does not exist, its position will be `null`.
     *
     * @example
     * ```typescript
     * const data = new Map([["Palermo", { longitude: 13.361389, latitude: 38.115556 }], ["Catania", { longitude: 15.087269, latitude: 37.502669 }]]);
     * await client.geoadd("mySortedSet", data);
     * const result = await client.geopos("mySortedSet", ["Palermo", "Catania", "NonExisting"]);
     * // When added via GEOADD, the geospatial coordinates are converted into a 52 bit geohash, so the coordinates
     * // returned might not be exactly the same as the input values
     * console.log(result); // Output:
     * // [
     * //     [13.36138933897018433, 38.11555639549629859],
     * //     [15.08726745843887329, 37.50266842333162032],
     * //     null
     * // ]
     * ```
     */
    geopos(key: GlideString, members: GlideString[]): Promise<([number, number] | null)[]>;
    /**
     * Pops member-score pairs from the first non-empty sorted set, with the given `keys`
     * being checked in the order they are provided.
     *
     * @see {@link https://valkey.io/commands/zmpop/|valkey.io} for more details.
     * @remarks When in cluster mode, all `keys` must map to the same hash slot.
     * @remarks Since Valkey version 7.0.0.
     *
     * @param keys - The keys of the sorted sets.
     * @param modifier - The element pop criteria - either {@link ScoreFilter.MIN} or
     *     {@link ScoreFilter.MAX} to pop the member with the lowest/highest score accordingly.
     * @param options - (Optional) Additional parameters:
     * - (Optional) `count`: the maximum number of popped elements. If not specified, pops one member.
     * - (Optional) `decoder`: see {@link DecoderOption}.
     * @returns A two-element `array` containing the key name of the set from which the element
     *     was popped, and a {@link SortedSetDataType} of the popped elements.
     *     If no member could be popped, returns `null`.
     *
     * @example
     * ```typescript
     * await client.zadd("zSet1", { one: 1.0, two: 2.0, three: 3.0 });
     * await client.zadd("zSet2", { four: 4.0 });
     * console.log(await client.zmpop(["zSet1", "zSet2"], ScoreFilter.MAX, 2));
     * // Output:
     * // "three" with score 3 and "two" with score 2 were popped from "zSet1"
     * // [ "zSet1", [
     * //     { element: 'three', score: 3 },
     * //     { element: 'two', score: 2 }
     * // ] ]
     * ```
     */
    zmpop(keys: GlideString[], modifier: ScoreFilter, options?: {
        count?: number;
    } & DecoderOption): Promise<[GlideString, SortedSetDataType] | null>;
    /**
     * Pops a member-score pair from the first non-empty sorted set, with the given `keys` being
     * checked in the order they are provided. Blocks the connection when there are no members
     * to pop from any of the given sorted sets. `BZMPOP` is the blocking variant of {@link zmpop}.
     *
     * @see {@link https://valkey.io/commands/bzmpop/|valkey.io} for more details.
     * @remarks When in cluster mode, all `keys` must map to the same hash slot.
     * @remarks `BZMPOP` is a client blocking command, see {@link https://github.com/valkey-io/valkey-glide/wiki/General-Concepts#blocking-commands | Valkey Glide Wiki} for more details and best practices.
     * @remarks Since Valkey version 7.0.0.
     *
     * @param keys - The keys of the sorted sets.
     * @param modifier - The element pop criteria - either {@link ScoreFilter.MIN} or
     *     {@link ScoreFilter.MAX} to pop the member with the lowest/highest score accordingly.
     * @param timeout - The number of seconds to wait for a blocking operation to complete.
     *     A value of 0 will block indefinitely.
     * @param options - (Optional) Additional parameters:
     * - (Optional) `count`: the maximum number of popped elements. If not specified, pops one member.
     * - (Optional) `decoder`: see {@link DecoderOption}.
     * @returns A two-element `array` containing the key name of the set from which the element
     *     was popped, and a {@link SortedSetDataType} of the popped elements.
     *     If no member could be popped, returns `null`.
     *
     * @example
     * ```typescript
     * await client.zadd("zSet1", { one: 1.0, two: 2.0, three: 3.0 });
     * await client.zadd("zSet2", { four: 4.0 });
     * console.log(await client.bzmpop(["zSet1", "zSet2"], ScoreFilter.MAX, 0.1, 2));
     * // Output:
     * // "three" with score 3 and "two" with score 2 were popped from "zSet1"
     * // [ "zSet1", [
     * //     { element: 'three', score: 3 },
     * //     { element: 'two', score: 2 }
     * // ] ]
     * ```
     */
    bzmpop(keys: GlideString[], modifier: ScoreFilter, timeout: number, options?: {
        count?: number;
    } & DecoderOption): Promise<[GlideString, SortedSetDataType] | null>;
    /**
     * Increments the score of `member` in the sorted set stored at `key` by `increment`.
     * If `member` does not exist in the sorted set, it is added with `increment` as its score.
     * If `key` does not exist, a new sorted set is created with the specified member as its sole member.
     *
     * @see {@link https://valkey.io/commands/zincrby/|valkey.io} for details.
     *
     * @param key - The key of the sorted set.
     * @param increment - The score increment.
     * @param member - A member of the sorted set.
     *
     * @returns The new score of `member`.
     *
     * @example
     * ```typescript
     * // Example usage of zincrBy method to increment the value of a member's score
     * await client.zadd("my_sorted_set", {"member": 10.5, "member2": 8.2});
     * console.log(await client.zincrby("my_sorted_set", 1.2, "member"));
     * // Output: 11.7 - The member existed in the set before score was altered, the new score is 11.7.
     * console.log(await client.zincrby("my_sorted_set", -1.7, "member"));
     * // Output: 10.0 - Negative increment, decrements the score.
     * console.log(await client.zincrby("my_sorted_set", 5.5, "non_existing_member"));
     * // Output: 5.5 - A new member is added to the sorted set with the score of 5.5.
     * ```
     */
    zincrby(key: GlideString, increment: number, member: GlideString): Promise<number>;
    /**
     * Iterates incrementally over a sorted set.
     *
     * @see {@link https://valkey.io/commands/zscan/|valkey.io} for more details.
     *
     * @param key - The key of the sorted set.
     * @param cursor - The cursor that points to the next iteration of results. A value of `"0"` indicates the start of
     *      the search.
     * @param options - (Optional) The `zscan` options - see {@link ZScanOptions} and {@link DecoderOption}.
     * @returns An `Array` of the `cursor` and the subset of the sorted set held by `key`.
     *      The first element is always the `cursor` for the next iteration of results. `0` will be the `cursor`
     *      returned on the last iteration of the sorted set. The second element is always an `Array` of the subset
     *      of the sorted set held in `key`. The `Array` in the second element is a flattened series of
     *      `string` pairs, where the value is at even indices and the score is at odd indices.
     *      If `options.noScores` is to `true`, the second element will only contain the members without scores.
     *
     * @example
     * ```typescript
     * // Assume "key1" contains a sorted set with multiple members
     * let cursor = "0";
     * do {
     *      const result = await client.zscan(key1, cursor, {
     *          match: "*",
     *          count: 5,
     *      });
     *      cursor = result[0];
     *      console.log("Cursor: ", cursor);
     *      console.log("Members: ", result[1]);
     * } while (cursor !== "0");
     * // The output of the code above is something similar to:
     * // Cursor:  123
     * // Members:  ['value 163', '163', 'value 114', '114', 'value 25', '25', 'value 82', '82', 'value 64', '64']
     * // Cursor:  47
     * // Members:  ['value 39', '39', 'value 127', '127', 'value 43', '43', 'value 139', '139', 'value 211', '211']
     * // Cursor:  0
     * // Members:  ['value 55', '55', 'value 24', '24', 'value 90', '90', 'value 113', '113']
     * ```
     *
     * @example
     * ```typescript
     * // Zscan with no scores
     * let newCursor = "0";
     * let result = [];
     *
     * do {
     *      result = await client.zscan(key1, newCursor, {
     *          match: "*",
     *          count: 5,
     *          noScores: true,
     *      });
     *      newCursor = result[0];
     *      console.log("Cursor: ", newCursor);
     *      console.log("Members: ", result[1]);
     * } while (newCursor !== "0");
     * // The output of the code above is something similar to:
     * // Cursor:  123
     * // Members:  ['value 163', 'value 114', 'value 25', 'value 82', 'value 64']
     * // Cursor:  47
     * // Members:  ['value 39', 'value 127', 'value 43', 'value 139', 'value 211']
     * // Cursor:  0
     * // Members:  ['value 55', 'value 24' 'value 90', 'value 113']
     * ```
     */
    zscan(key: GlideString, cursor: string, options?: ZScanOptions & DecoderOption): Promise<[string, GlideString[]]>;
    /**
     * Returns the distance between `member1` and `member2` saved in the geospatial index stored at `key`.
     *
     * @see {@link https://valkey.io/commands/geodist/|valkey.io} for more details.
     *
     * @param key - The key of the sorted set.
     * @param member1 - The name of the first member.
     * @param member2 - The name of the second member.
     * @param options - (Optional) Additional parameters:
     * - (Optional) `unit`: the unit of distance measurement - see {@link GeoUnit}.
     *   If not specified, the {@link GeoUnit.METERS} is used as a default unit.
     * @returns The distance between `member1` and `member2`. Returns `null`, if one or both members do not exist,
     *     or if the key does not exist.
     *
     * @example
     * ```typescript
     * const result = await client.geodist("mySortedSet", "Place1", "Place2", { unit: GeoUnit.KILOMETERS });
     * console.log(num); // Output: the distance between Place1 and Place2.
     * ```
     */
    geodist(key: GlideString, member1: GlideString, member2: GlideString, options?: {
        unit?: GeoUnit;
    }): Promise<number | null>;
    /**
     * Returns the `GeoHash` strings representing the positions of all the specified `members` in the sorted set stored at `key`.
     *
     * @see {@link https://valkey.io/commands/geohash/|valkey.io} for more details.
     *
     * @param key - The key of the sorted set.
     * @param members - The array of members whose `GeoHash` strings are to be retrieved.
     * @returns An array of `GeoHash` strings representing the positions of the specified members stored at `key`.
     *     If a member does not exist in the sorted set, a `null` value is returned for that member.
     *
     * @example
     * ```typescript
     * const result = await client.geohash("mySortedSet", ["Palermo", "Catania", "NonExisting"]);
     * console.log(result); // Output: ["sqc8b49rny0", "sqdtr74hyu0", null]
     * ```
     */
    geohash(key: GlideString, members: GlideString[]): Promise<(string | null)[]>;
    /**
     * Returns all the longest common subsequences combined between strings stored at `key1` and `key2`.
     *
     * @see {@link https://valkey.io/commands/lcs/|valkey.io} for more details.
     * @remarks When in cluster mode, `key1` and `key2` must map to the same hash slot.
     * @remarks Since Valkey version 7.0.0.
     *
     * @param key1 - The key that stores the first string.
     * @param key2 - The key that stores the second string.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns A `String` containing all the longest common subsequence combined between the 2 strings.
     *     An empty `String` is returned if the keys do not exist or have no common subsequences.
     *
     * @example
     * ```typescript
     * await client.mset({"testKey1": "abcd", "testKey2": "axcd"});
     * const result = await client.lcs("testKey1", "testKey2");
     * console.log(result); // Output: 'acd'
     * ```
     */
    lcs(key1: GlideString, key2: GlideString, options?: DecoderOption): Promise<string>;
    /**
     * Returns the total length of all the longest common subsequences between strings stored at `key1` and `key2`.
     *
     * @see {@link https://valkey.io/commands/lcs/|valkey.io} for more details.
     * @remarks When in cluster mode, `key1` and `key2` must map to the same hash slot.
     * @remarks Since Valkey version 7.0.0.
     *
     * @param key1 - The key that stores the first string.
     * @param key2 - The key that stores the second string.
     * @param options - (Optional) See {@link DecoderOption}.
     * @returns The total length of all the longest common subsequences between the 2 strings.
     *
     * @example
     * ```typescript
     * await client.mset({"testKey1": "abcd", "testKey2": "axcd"});
     * const result = await client.lcsLen("testKey1", "testKey2");
     * console.log(result); // Output: 3
     * ```
     */
    lcsLen(key1: GlideString, key2: GlideString, options?: DecoderOption): Promise<number>;
    /**
     * Returns the indices and lengths of the longest common subsequences between strings stored at
     * `key1` and `key2`.
     *
     * @see {@link https://valkey.io/commands/lcs/|valkey.io} for more details.
     * @remarks When in cluster mode, `key1` and `key2` must map to the same hash slot.
     * @remarks Since Valkey version 7.0.0.
     *
     * @param key1 - The key that stores the first string.
     * @param key2 - The key that stores the second string.
     * @param options - (Optional) Additional parameters:
     * - (Optional) `withMatchLen`: if `true`, include the length of the substring matched for the each match.
     * - (Optional) `minMatchLen`: the minimum length of matches to include in the result.
     * @returns A `Record` containing the indices of the longest common subsequences between the
     *     2 strings and the lengths of the longest common subsequences. The resulting map contains two
     *     keys, "matches" and "len":
     *     - `"len"` is mapped to the total length of the all longest common subsequences between the 2 strings
     *           stored as an integer. This value doesn't count towards the `minMatchLen` filter.
     *     - `"matches"` is mapped to a three dimensional array of integers that stores pairs
     *           of indices that represent the location of the common subsequences in the strings held
     *           by `key1` and `key2`.
     *
     *     See example for more details.
     *
     * @example
     * ```typescript
     * await client.mset({"key1": "ohmytext", "key2": "mynewtext"});
     * const result = await client.lcsIdx("key1", "key2");
     * console.log(result); // Output:
     * {
     *     "matches" :
     *     [
     *         [              // first substring match is "text"
     *             [4, 7],    // in `key1` it is located between indices 4 and 7
     *             [5, 8],    // and in `key2` - in between 5 and 8
     *             4          // the match length, returned if `withMatchLen` set to `true`
     *         ],
     *         [              // second substring match is "my"
     *             [2, 3],    // in `key1` it is located between indices 2 and 3
     *             [0, 1],    // and in `key2` - in between 0 and 1
     *             2          // the match length, returned if `withMatchLen` set to `true`
     *         ]
     *     ],
     *     "len" : 6          // total length of the all matches found
     * }
     * ```
     */
    lcsIdx(key1: GlideString, key2: GlideString, options?: {
        withMatchLen?: boolean;
        minMatchLen?: number;
    }): Promise<Record<string, (number | [number, number])[][] | number>>;
    /**
     * Updates the last access time of the specified keys.
     *
     * @see {@link https://valkey.io/commands/touch/|valkey.io} for more details.
     *
     * @remarks In cluster mode, if keys in `keys` map to different hash slots,
     * the command will be split across these slots and executed separately for each.
     * This means the command is atomic only at the slot level. If one or more slot-specific
     * requests fail, the entire call will return the first encountered error, even
     * though some requests may have succeeded while others did not.
     * If this behavior impacts your application logic, consider splitting the
     * request into sub-requests per slot to ensure atomicity.
     *
     * @param keys - The keys to update the last access time of.
     * @returns The number of keys that were updated. A key is ignored if it doesn't exist.
     *
     * @example
     * ```typescript
     * await client.set("key1", "value1");
     * await client.set("key2", "value2");
     * const result = await client.touch(["key1", "key2", "nonExistingKey"]);
     * console.log(result); // Output: 2 - The last access time of 2 keys has been updated.
     * ```
     */
    touch(keys: GlideString[]): Promise<number>;
    /**
     * Marks the given keys to be watched for conditional execution of a transaction. Transactions
     * will only execute commands if the watched keys are not modified before execution of the
     * transaction. Executing a transaction will automatically flush all previously watched keys.
     *
     * @see {@link https://valkey.io/commands/watch/|valkey.io} and {@link https://valkey.io/topics/transactions/#cas|Valkey Glide Wiki} for more details.
     *
     * @remarks In cluster mode, if keys in `keys` map to different hash slots,
     * the command will be split across these slots and executed separately for each.
     * This means the command is atomic only at the slot level. If one or more slot-specific
     * requests fail, the entire call will return the first encountered error, even
     * though some requests may have succeeded while others did not.
     * If this behavior impacts your application logic, consider splitting the
     * request into sub-requests per slot to ensure atomicity.
     *
     * @param keys - The keys to watch.
     * @returns A simple `"OK"` response.
     *
     * @example
     * ```typescript
     * const response = await client.watch(["sampleKey"]);
     * console.log(response); // Output: "OK"
     * const transaction = new Transaction().set("SampleKey", "foobar");
     * const result = await client.exec(transaction);
     * console.log(result); // Output: "OK" - Executes successfully and keys are unwatched.
     * ```
     * ```typescript
     * const response = await client.watch(["sampleKey"]);
     * console.log(response); // Output: "OK"
     * const transaction = new Transaction().set("SampleKey", "foobar");
     * await client.set("sampleKey", "hello world");
     * const result = await client.exec(transaction);
     * console.log(result); // Output: null - null is returned when the watched key is modified before transaction execution.
     * ```
     */
    watch(keys: GlideString[]): Promise<"OK">;
    /**
     * Blocks the current client until all the previous write commands are successfully transferred and
     * acknowledged by at least `numreplicas` of replicas. If `timeout` is reached, the command returns
     * the number of replicas that were not yet reached.
     *
     * @see {@link https://valkey.io/commands/wait/|valkey.io} for more details.
     *
     * @param numreplicas - The number of replicas to reach.
     * @param timeout - The timeout value specified in milliseconds. A value of 0 will block indefinitely.
     * @returns The number of replicas reached by all the writes performed in the context of the current connection.
     *
     * @example
     * ```typescript
     * await client.set(key, value);
     * let response = await client.wait(1, 1000);
     * console.log(response); // Output: return 1 when a replica is reached or 0 if 1000ms is reached.
     * ```
     */
    wait(numreplicas: number, timeout: number): Promise<number>;
    /**
     * Overwrites part of the string stored at `key`, starting at the specified byte `offset`,
     * for the entire length of `value`. If the `offset` is larger than the current length of the string at `key`,
     * the string is padded with zero bytes to make `offset` fit. Creates the `key` if it doesn't exist.
     *
     * @see {@link https://valkey.io/commands/setrange/|valkey.io} for more details.
     *
     * @param key - The key of the string to update.
     * @param offset - The byte position in the string where `value` should be written.
     * @param value - The string written with `offset`.
     * @returns The length of the string stored at `key` after it was modified.
     *
     * @example
     * ```typescript
     * const len = await client.setrange("key", 6, "GLIDE");
     * console.log(len); // Output: 11 - New key was created with length of 11 symbols
     * const value = await client.get("key");
     * console.log(result); // Output: "\0\0\0\0\0\0GLIDE" - The string was padded with zero bytes
     * ```
     */
    setrange(key: GlideString, offset: number, value: GlideString): Promise<number>;
    /**
     * Appends a `value` to a `key`. If `key` does not exist it is created and set as an empty string,
     * so `APPEND` will be similar to {@link set} in this special case.
     *
     * @see {@link https://valkey.io/commands/append/|valkey.io} for more details.
     *
     * @param key - The key of the string.
     * @param value - The key of the string.
     * @returns The length of the string after appending the value.
     *
     * @example
     * ```typescript
     * const len = await client.append("key", "Hello");
     * console.log(len);
     *     // Output: 5 - Indicates that "Hello" has been appended to the value of "key", which was initially
     *     // empty, resulting in a new value of "Hello" with a length of 5 - similar to the set operation.
     * len = await client.append("key", " world");
     * console.log(result);
     *     // Output: 11 - Indicates that " world" has been appended to the value of "key", resulting in a
     *     // new value of "Hello world" with a length of 11.
     * ```
     */
    append(key: GlideString, value: GlideString): Promise<number>;
    /**
     * Pops one or more elements from the first non-empty list from the provided `keys`.
     *
     * @see {@link https://valkey.io/commands/lmpop/|valkey.io} for more details.
     * @remarks When in cluster mode, all `keys` must map to the same hash slot.
     * @remarks Since Valkey version 7.0.0.
     *
     * @param keys - An array of keys.
     * @param direction - The direction based on which elements are popped from - see {@link ListDirection}.
     * @param options - (Optional) Additional parameters:
     * - (Optional) `count`: the maximum number of popped elements. If not specified, pops one member.
     * - (Optional) `decoder`: see {@link DecoderOption}.
     * @returns A `Record` which stores the key name where elements were popped out and the array of popped elements.
     *
     * @example
     * ```typescript
     * await client.lpush("testKey", ["one", "two", "three"]);
     * await client.lpush("testKey2", ["five", "six", "seven"]);
     * const result = await client.lmpop(["testKey", "testKey2"], ListDirection.LEFT, 1L);
     * console.log(result); // Output: { key: "testKey", elements: ["three"] }
     * ```
     */
    lmpop(keys: GlideString[], direction: ListDirection, options?: {
        count?: number;
    } & DecoderOption): Promise<{
        key: GlideString;
        elements: GlideString[];
    } | null>;
    /**
     * Blocks the connection until it pops one or more elements from the first non-empty list from the
     * provided `key`. `BLMPOP` is the blocking variant of {@link lmpop}.
     *
     * @see {@link https://valkey.io/commands/blmpop/|valkey.io} for more details.
     * @remarks When in cluster mode, all `keys` must map to the same hash slot.
     * @remarks Since Valkey version 7.0.0.
     *
     * @param keys - An array of keys.
     * @param direction - The direction based on which elements are popped from - see {@link ListDirection}.
     * @param timeout - The number of seconds to wait for a blocking operation to complete. A value of `0` will block indefinitely.
     * @param options - (Optional) Additional parameters:
     * - (Optional) `count`: the maximum number of popped elements. If not specified, pops one member.
     * - (Optional) `decoder`: see {@link DecoderOption}.
     * @returns A `Record` which stores the key name where elements were popped out and the array of popped elements.
     *     If no member could be popped and the timeout expired, returns `null`.
     *
     * @example
     * ```typescript
     * await client.lpush("testKey", ["one", "two", "three"]);
     * await client.lpush("testKey2", ["five", "six", "seven"]);
     * const result = await client.blmpop(["testKey", "testKey2"], ListDirection.LEFT, 0.1, 1);
     * console.log(result"testKey"); // Output: { key: "testKey", elements: ["three"] }
     * ```
     */
    blmpop(keys: GlideString[], direction: ListDirection, timeout: number, options?: {
        count?: number;
    } & DecoderOption): Promise<{
        key: GlideString;
        elements: GlideString[];
    } | null>;
    /**
     * Lists the currently active channels.
     * The command is routed to all nodes, and aggregates the response to a single array.
     *
     * @see {@link https://valkey.io/commands/pubsub-channels/|valkey.io} for more details.
     *
     * @param options - (Optional) Additional parameters:
     * - (Optional) `pattern`: A glob-style pattern to match active channels.
     *     If not provided, all active channels are returned.
     * - (Optional) `decoder`: see {@link DecoderOption}.
     * @returns A list of currently active channels matching the given pattern.
     *          If no pattern is specified, all active channels are returned.
     *
     * @example
     * ```typescript
     * const channels = await client.pubsubChannels();
     * console.log(channels); // Output: ["channel1", "channel2"]
     *
     * const newsChannels = await client.pubsubChannels("news.*");
     * console.log(newsChannels); // Output: ["news.sports", "news.weather"]
     * ```
     */
    pubsubChannels(options?: {
        pattern?: GlideString;
    } & DecoderOption): Promise<GlideString[]>;
    /**
     * Returns the number of unique patterns that are subscribed to by clients.
     *
     * Note: This is the total number of unique patterns all the clients are subscribed to,
     * not the count of clients subscribed to patterns.
     * The command is routed to all nodes, and aggregates the response to the sum of all pattern subscriptions.
     *
     * @see {@link https://valkey.io/commands/pubsub-numpat/|valkey.io} for more details.
     *
     * @returns The number of unique patterns.
     *
     * @example
     * ```typescript
     * const patternCount = await client.pubsubNumpat();
     * console.log(patternCount); // Output: 3
     * ```
     */
    pubsubNumPat(): Promise<number>;
    /**
     * Returns the number of subscribers (exclusive of clients subscribed to patterns) for the specified channels.
     *
     * @see {@link https://valkey.io/commands/pubsub-numsub/|valkey.io} for more details.
     * @remarks When in cluster mode, the command is routed to all nodes, and aggregates the response into a single list.
     *
     * @param channels - The list of channels to query for the number of subscribers.
     * @param options - (Optional) see {@link DecoderOption}.
     * @returns A list of the channel names and their numbers of subscribers.
     *
     * @example
     * ```typescript
     * const result1 = await client.pubsubNumsub(["channel1", "channel2"]);
     * console.log(result1); // Output:
     * // [{ channel: "channel1", numSub: 3}, { channel: "channel2", numSub: 5 }]
     *
     * const result2 = await client.pubsubNumsub([]);
     * console.log(result2); // Output: []
     * ```
     */
    pubsubNumSub(channels: GlideString[], options?: DecoderOption): Promise<{
        channel: GlideString;
        numSub: number;
    }[]>;
    /**
     * Sorts the elements in the list, set, or sorted set at `key` and returns the result.
     *
     * The `sort` command can be used to sort elements based on different criteria and
     * apply transformations on sorted elements.
     *
     * To store the result into a new key, see {@link sortStore}.
     *
     * @see {@link https://valkey.io/commands/sort/|valkey.io} for more details.
     * @remarks When in cluster mode, both `key` and the patterns specified in {@link SortOptions.byPattern}
     * and {@link SortOptions.getPatterns} must map to the same hash slot. The use of {@link SortOptions.byPattern}
     * and {@link SortOptions.getPatterns} in cluster mode is supported since Valkey version 8.0.
     * @param key - The key of the list, set, or sorted set to be sorted.
     * @param options - (Optional) The {@link SortOptions} and {@link DecoderOption}.
     *
     * @returns An `Array` of sorted elements.
     *
     * @example
     * ```typescript
     * await client.hset("user:1", new Map([["name", "Alice"], ["age", "30"]]));
     * await client.hset("user:2", new Map([["name", "Bob"], ["age", "25"]]));
     * await client.lpush("user_ids", ["2", "1"]);
     * const result = await client.sort("user_ids", { byPattern: "user:*->age", getPattern: ["user:*->name"] });
     * console.log(result); // Output: [ 'Bob', 'Alice' ] - Returns a list of the names sorted by age
     * ```
     */
    sort(key: GlideString, options?: SortOptions & DecoderOption): Promise<(GlideString | null)[]>;
    /**
     * Sorts the elements in the list, set, or sorted set at `key` and returns the result.
     *
     * The `sortReadOnly` command can be used to sort elements based on different criteria and
     * apply transformations on sorted elements.
     *
     * This command is routed depending on the client's {@link ReadFrom} strategy.
     *
     * @see {@link https://valkey.io/commands/sort/|valkey.io} for more details.
     * @remarks Since Valkey version 7.0.0.
     * @remarks When in cluster mode, both `key` and the patterns specified in {@link SortOptions.byPattern}
     * and {@link SortOptions.getPatterns} must map to the same hash slot. The use of {@link SortOptions.byPattern}
     * and {@link SortOptions.getPatterns} in cluster mode is supported since Valkey version 8.0.
     * @param key - The key of the list, set, or sorted set to be sorted.
     * @param options - (Optional) The {@link SortOptions} and {@link DecoderOption}.
     * @returns An `Array` of sorted elements
     *
     * @example
     * ```typescript
     * await client.hset("user:1", new Map([["name", "Alice"], ["age", "30"]]));
     * await client.hset("user:2", new Map([["name", "Bob"], ["age", "25"]]));
     * await client.lpush("user_ids", ["2", "1"]);
     * const result = await client.sortReadOnly("user_ids", { byPattern: "user:*->age", getPattern: ["user:*->name"] });
     * console.log(result); // Output: [ 'Bob', 'Alice' ] - Returns a list of the names sorted by age
     * ```
     */
    sortReadOnly(key: GlideString, options?: SortOptions & DecoderOption): Promise<(GlideString | null)[]>;
    /**
     * Sorts the elements in the list, set, or sorted set at `key` and stores the result in
     * `destination`.
     *
     * The `sort` command can be used to sort elements based on different criteria and
     * apply transformations on sorted elements, and store the result in a new key.
     *
     * To get the sort result without storing it into a key, see {@link sort} or {@link sortReadOnly}.
     *
     * @see {@link https://valkey.io/commands/sort|valkey.io} for more details.
     * @remarks When in cluster mode, `key`, `destination` and the patterns specified in {@link SortOptions.byPattern}
     * and {@link SortOptions.getPatterns} must map to the same hash slot. The use of {@link SortOptions.byPattern}
     * and {@link SortOptions.getPatterns} in cluster mode is supported since Valkey version 8.0.
     *
     * @param key - The key of the list, set, or sorted set to be sorted.
     * @param destination - The key where the sorted result will be stored.
     * @param options - (Optional) The {@link SortOptions}.
     * @returns The number of elements in the sorted key stored at `destination`.
     *
     * @example
     * ```typescript
     * await client.hset("user:1", new Map([["name", "Alice"], ["age", "30"]]));
     * await client.hset("user:2", new Map([["name", "Bob"], ["age", "25"]]));
     * await client.lpush("user_ids", ["2", "1"]);
     * const sortedElements = await client.sortStore("user_ids", "sortedList", { byPattern: "user:*->age", getPattern: ["user:*->name"] });
     * console.log(sortedElements); // Output: 2 - number of elements sorted and stored
     * console.log(await client.lrange("sortedList", 0, -1)); // Output: [ 'Bob', 'Alice' ] - Returns a list of the names sorted by age stored in `sortedList`
     * ```
     */
    sortStore(key: GlideString, destination: GlideString, options?: SortOptions): Promise<number>;
    /**
     * @internal
     */
    protected createClientRequest(options: BaseClientConfiguration): connection_request.IConnectionRequest;
    /**
     * @internal
     */
    protected configureAdvancedConfigurationBase(options: AdvancedBaseClientConfiguration, request: connection_request.IConnectionRequest): void;
    /**
     * @internal
     */
    protected connectToServer(options: BaseClientConfiguration): Promise<void>;
    /**
     *  Terminate the client by closing all associated resources, including the socket and any active promises.
     *  All open promises will be closed with an exception.
     * @param errorMessage - If defined, this error message will be passed along with the exceptions when closing all open promises.
     */
    close(errorMessage?: string): void;
    /**
     * @internal
     */
    protected static __createClientInternal<TConnection extends BaseClient>(options: BaseClientConfiguration, connectedSocket: net.Socket, constructor: (socket: net.Socket, options?: BaseClientConfiguration) => TConnection): Promise<TConnection>;
    /**
     * @internal
     */
    protected static GetSocket(path: string): Promise<net.Socket>;
    /**
     * @internal
     */
    protected static createClientInternal<TConnection extends BaseClient>(options: BaseClientConfiguration, constructor: (socket: net.Socket, options?: BaseClientConfiguration) => TConnection): Promise<TConnection>;
    /**
     * Update the current connection with a new password.
     *
     * This method is useful in scenarios where the server password has changed or when utilizing short-lived passwords for enhanced security.
     * It allows the client to update its password to reconnect upon disconnection without the need to recreate the client instance.
     * This ensures that the internal reconnection mechanism can handle reconnection seamlessly, preventing the loss of in-flight commands.
     *
     * This method updates the client's internal password configuration and does not perform password rotation on the server side.
     *
     * @param password - `String | null`. The new password to update the current password, or `null` to remove the current password.
     * @param immidiateAuth - A `boolean` flag. If `true`, the client will authenticate immediately with the new password against all connections, Using `AUTH` command.
     *                 If password supplied is an empty string, the client will not perform auth and instead a warning will be returned.
     *                 The default is `false`.
     *
     * @example
     * ```typescript
     * await client.updateConnectionPassword("newPassword", true) // "OK"
     * ```
     */
    updateConnectionPassword(password: string | null, immediateAuth?: boolean): Promise<GlideString>;
    /**
     * Return a statistics
     *
     * @return Return an object that contains the statistics collected internally by GLIDE core
     */
    getStatistics(): object;
}
export {};