/**
 * Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0
 */
import { GlideRecord, GlideString, HashDataType, ObjectType, SortedSetDataType } from "./BaseClient";
import { command_request } from "./ProtobufMessage";
/**
 * @internal
 */
export declare function parseInfoResponse(response: string): Record<string, string>;
/**
 * @internal
 */
export declare function createGet(key: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createGetDel(key: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createGetRange(key: GlideString, start: number, end: number): command_request.Command;
export interface SetOptions {
    /**
     *  `onlyIfDoesNotExist` - Only set the key if it does not already exist.
     * Equivalent to `NX` in the Valkey API. `onlyIfExists` - Only set the key if
     * it already exist. Equivalent to `EX` in the Valkey API. if `conditional` is
     * not set the value will be set regardless of prior value existence. If value
     * isn't set because of the condition, return null.
     */
    conditionalSet?: "onlyIfExists" | "onlyIfDoesNotExist";
    /**
     * Return the old string stored at key, or nil if key did not exist. An error
     * is returned and SET aborted if the value stored at key is not a string.
     * Equivalent to `GET` in the Valkey API.
     */
    returnOldValue?: boolean;
    /**
     * If not set, no expiry time will be set for the value.
     */
    expiry?: "keepExisting" | {
        type: TimeUnit;
        count: number;
    };
}
/**
 * @internal
 */
export declare function createSet(key: GlideString, value: GlideString, options?: SetOptions): command_request.Command;
/**
 * INFO option: a specific section of information:
 * When no parameter is provided, the default option is assumed.
 */
export declare enum InfoOptions {
    /**
     * SERVER: General information about the server
     */
    Server = "server",
    /**
     * CLIENTS: Client connections section
     */
    Clients = "clients",
    /**
     * MEMORY: Memory consumption related information
     */
    Memory = "memory",
    /**
     * PERSISTENCE: RDB and AOF related information
     */
    Persistence = "persistence",
    /**
     * STATS: General statistics
     */
    Stats = "stats",
    /**
     * REPLICATION: Master/replica replication information
     */
    Replication = "replication",
    /**
     * CPU: CPU consumption statistics
     */
    Cpu = "cpu",
    /**
     * COMMANDSTATS: Valkey command statistics
     */
    Commandstats = "commandstats",
    /**
     * LATENCYSTATS: Valkey command latency percentile distribution statistics
     */
    Latencystats = "latencystats",
    /**
     * SENTINEL: Valkey Sentinel section (only applicable to Sentinel instances)
     */
    Sentinel = "sentinel",
    /**
     * CLUSTER: Valkey Cluster section
     */
    Cluster = "cluster",
    /**
     * MODULES: Modules section
     */
    Modules = "modules",
    /**
     * KEYSPACE: Database related statistics
     */
    Keyspace = "keyspace",
    /**
     * ERRORSTATS: Valkey error statistics
     */
    Errorstats = "errorstats",
    /**
     * ALL: Return all sections (excluding module generated ones)
     */
    All = "all",
    /**
     * DEFAULT: Return only the default set of sections
     */
    Default = "default",
    /**
     * EVERYTHING: Includes all and modules
     */
    Everything = "everything"
}
/**
 * @internal
 */
export declare function createPing(str?: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createInfo(options?: InfoOptions[]): command_request.Command;
/**
 * @internal
 */
export declare function createDel(keys: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createSelect(index: number): command_request.Command;
/**
 * @internal
 */
export declare function createClientGetName(): command_request.Command;
/**
 * @internal
 */
export declare function createConfigRewrite(): command_request.Command;
/**
 * @internal
 */
export declare function createConfigResetStat(): command_request.Command;
/**
 * @internal
 */
export declare function createMGet(keys: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createMSet(keysAndValues: GlideRecord<GlideString>): command_request.Command;
/**
 * @internal
 */
export declare function createMSetNX(keysAndValues: GlideRecord<GlideString>): command_request.Command;
/**
 * @internal
 */
export declare function createIncr(key: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createIncrBy(key: GlideString, amount: number): command_request.Command;
/**
 * @internal
 */
export declare function createIncrByFloat(key: GlideString, amount: number): command_request.Command;
/**
 * @internal
 */
export declare function createClientId(): command_request.Command;
/**
 * @internal
 */
export declare function createConfigGet(parameters: string[]): command_request.Command;
/**
 * @internal
 */
export declare function createConfigSet(parameters: Record<string, GlideString>): command_request.Command;
/**
 * @internal
 */
export declare function createHGet(key: GlideString, field: GlideString): command_request.Command;
/**
 * This function converts an input from {@link HashDataType} or `Record` types to `HashDataType`.
 *
 * @param fieldsAndValues - field names and their values.
 * @returns HashDataType array containing field names and their values.
 */
export declare function convertFieldsAndValuesToHashDataType(fieldsAndValues: HashDataType | Record<string, GlideString>): HashDataType;
/**
 * @internal
 */
export declare function createHSet(key: GlideString, fieldValueList: HashDataType): command_request.Command;
/**
 * @internal
 */
export declare function createHKeys(key: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createHSetNX(key: GlideString, field: GlideString, value: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createDecr(key: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createDecrBy(key: GlideString, amount: number): command_request.Command;
/**
 * Enumeration defining the bitwise operation to use in the {@link BaseClient.bitop|bitop} command. Specifies the
 * bitwise operation to perform between the passed in keys.
 */
export declare enum BitwiseOperation {
    AND = "AND",
    OR = "OR",
    XOR = "XOR",
    NOT = "NOT"
}
/**
 * @internal
 */
export declare function createBitOp(operation: BitwiseOperation, destination: GlideString, keys: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createGetBit(key: GlideString, offset: number): command_request.Command;
/**
 * @internal
 */
export declare function createSetBit(key: GlideString, offset: number, value: number): command_request.Command;
/**
 * Represents a signed or unsigned argument encoding for the {@link BaseClient.bitfield|bitfield} or
 * {@link BaseClient.bitfieldReadOnly|bitfieldReadOnly} commands.
 */
export interface BitEncoding {
    /**
     * Returns the encoding as a string argument to be used in the {@link BaseClient.bitfield|bitfield} or
     * {@link BaseClient.bitfieldReadOnly|bitfieldReadOnly} commands.
     *
     * @returns The encoding as a string argument.
     */
    toArg(): string;
}
/**
 * Represents a signed argument encoding.
 */
export declare class SignedEncoding implements BitEncoding {
    private static readonly SIGNED_ENCODING_PREFIX;
    private readonly encoding;
    /**
     * Creates an instance of SignedEncoding.
     *
     * @param encodingLength - The bit size of the encoding. Must be less than 65 bits long.
     */
    constructor(encodingLength: number);
    toArg(): string;
}
/**
 * Represents an unsigned argument encoding.
 */
export declare class UnsignedEncoding implements BitEncoding {
    private static readonly UNSIGNED_ENCODING_PREFIX;
    private readonly encoding;
    /**
     * Creates an instance of UnsignedEncoding.
     *
     * @param encodingLength - The bit size of the encoding. Must be less than 64 bits long.
     */
    constructor(encodingLength: number);
    toArg(): string;
}
/**
 * Represents an offset for an array of bits for the {@link BaseClient.bitfield|bitfield} or
 * {@link BaseClient.bitfieldReadOnly|bitfieldReadOnly} commands.
 */
export interface BitFieldOffset {
    /**
     * Returns the offset as a string argument to be used in the {@link BaseClient.bitfield|bitfield} or
     * {@link BaseClient.bitfieldReadOnly|bitfieldReadOnly} commands.
     *
     * @returns The offset as a string argument.
     */
    toArg(): string;
}
/**
 * Represents an offset in an array of bits for the {@link BaseClient.bitfield|bitfield} or
 * {@link BaseClient.bitfieldReadOnly|bitfieldReadOnly} commands.
 *
 * For example, if we have the binary `01101001` with offset of 1 for an unsigned encoding of size 4, then the value
 * is 13 from `0(1101)001`.
 */
export declare class BitOffset implements BitFieldOffset {
    private readonly offset;
    /**
     * Creates an instance of BitOffset.
     *
     * @param offset - The bit index offset in the array of bits. Must be greater than or equal to 0.
     */
    constructor(offset: number);
    toArg(): string;
}
/**
 * Represents an offset in an array of bits for the {@link BaseClient.bitfield|bitfield} or
 * {@link BaseClient.bitfieldReadOnly|bitfieldReadOnly} commands. The bit offset index is calculated as the numerical
 * value of the offset multiplied by the encoding value.
 *
 * For example, if we have the binary 01101001 with offset multiplier of 1 for an unsigned encoding of size 4, then the
 * value is 9 from `0110(1001)`.
 */
export declare class BitOffsetMultiplier implements BitFieldOffset {
    private static readonly OFFSET_MULTIPLIER_PREFIX;
    private readonly offset;
    /**
     * Creates an instance of BitOffsetMultiplier.
     *
     * @param offset - The offset in the array of bits, which will be multiplied by the encoding value to get the final
     *      bit index offset.
     */
    constructor(offset: number);
    toArg(): string;
}
/**
 * Represents subcommands for the {@link BaseClient.bitfield|bitfield} or
 * {@link BaseClient.bitfieldReadOnly|bitfieldReadOnly} commands.
 */
export interface BitFieldSubCommands {
    /**
     * Returns the subcommand as a list of string arguments to be used in the {@link BaseClient.bitfield|bitfield} or
     * {@link BaseClient.bitfieldReadOnly|bitfieldReadOnly} commands.
     *
     * @returns The subcommand as a list of string arguments.
     */
    toArgs(): string[];
}
/**
 * Represents the "GET" subcommand for getting a value in the binary representation of the string stored in `key`.
 */
export declare class BitFieldGet implements BitFieldSubCommands {
    private static readonly GET_COMMAND_STRING;
    private readonly encoding;
    private readonly offset;
    /**
     * Creates an instance of BitFieldGet.
     *
     * @param encoding - The bit encoding for the subcommand.
     * @param offset - The offset in the array of bits from which to get the value.
     */
    constructor(encoding: BitEncoding, offset: BitFieldOffset);
    toArgs(): string[];
}
/**
 * Represents the "SET" subcommand for setting bits in the binary representation of the string stored in `key`.
 */
export declare class BitFieldSet implements BitFieldSubCommands {
    private static readonly SET_COMMAND_STRING;
    private readonly encoding;
    private readonly offset;
    private readonly value;
    /**
     * Creates an instance of BitFieldSet
     *
     * @param encoding - The bit encoding for the subcommand.
     * @param offset - The offset in the array of bits where the value will be set.
     * @param value - The value to set the bits in the binary value to.
     */
    constructor(encoding: BitEncoding, offset: BitFieldOffset, value: number);
    toArgs(): string[];
}
/**
 * Represents the "INCRBY" subcommand for increasing or decreasing bits in the binary representation of the string
 * stored in `key`.
 */
export declare class BitFieldIncrBy implements BitFieldSubCommands {
    private static readonly INCRBY_COMMAND_STRING;
    private readonly encoding;
    private readonly offset;
    private readonly increment;
    /**
     * Creates an instance of BitFieldIncrBy
     *
     * @param encoding - The bit encoding for the subcommand.
     * @param offset - The offset in the array of bits where the value will be incremented.
     * @param increment - The value to increment the bits in the binary value by.
     */
    constructor(encoding: BitEncoding, offset: BitFieldOffset, increment: number);
    toArgs(): string[];
}
/**
 * Enumeration specifying bit overflow controls for the {@link BaseClient.bitfield|bitfield} command.
 */
export declare enum BitOverflowControl {
    /**
     * Performs modulo when overflows occur with unsigned encoding. When overflows occur with signed encoding, the value
     * restarts at the most negative value. When underflows occur with signed encoding, the value restarts at the most
     * positive value.
     */
    WRAP = "WRAP",
    /**
     * Underflows remain set to the minimum value, and overflows remain set to the maximum value.
     */
    SAT = "SAT",
    /**
     * Returns `None` when overflows occur.
     */
    FAIL = "FAIL"
}
/**
 * Represents the "OVERFLOW" subcommand that determines the result of the "SET" or "INCRBY"
 * {@link BaseClient.bitfield|bitfield} subcommands when an underflow or overflow occurs.
 */
export declare class BitFieldOverflow implements BitFieldSubCommands {
    private static readonly OVERFLOW_COMMAND_STRING;
    private readonly overflowControl;
    /**
     * Creates an instance of BitFieldOverflow.
     *
     * @param overflowControl - The desired overflow behavior.
     */
    constructor(overflowControl: BitOverflowControl);
    toArgs(): string[];
}
/**
 * @internal
 */
export declare function createBitField(key: GlideString, subcommands: BitFieldSubCommands[], readOnly?: boolean): command_request.Command;
/**
 * @internal
 */
export declare function createHDel(key: GlideString, fields: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createHMGet(key: GlideString, fields: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createHExists(key: GlideString, field: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createHGetAll(key: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createLPush(key: GlideString, elements: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createLPushX(key: GlideString, elements: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createLPop(key: GlideString, count?: number): command_request.Command;
/**
 * @internal
 */
export declare function createLRange(key: GlideString, start: number, end: number): command_request.Command;
/**
 * @internal
 */
export declare function createLLen(key: GlideString): command_request.Command;
/**
 * Enumeration representing element popping or adding direction for the List Based Commands.
 */
export declare enum ListDirection {
    /**
     * Represents the option that elements should be popped from or added to the left side of a list.
     */
    LEFT = "LEFT",
    /**
     * Represents the option that elements should be popped from or added to the right side of a list.
     */
    RIGHT = "RIGHT"
}
/**
 * @internal
 */
export declare function createLMove(source: GlideString, destination: GlideString, whereFrom: ListDirection, whereTo: ListDirection): command_request.Command;
/**
 * @internal
 */
export declare function createBLMove(source: GlideString, destination: GlideString, whereFrom: ListDirection, whereTo: ListDirection, timeout: number): command_request.Command;
/**
 * @internal
 */
export declare function createLSet(key: GlideString, index: number, element: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createLTrim(key: GlideString, start: number, end: number): command_request.Command;
/**
 * @internal
 */
export declare function createLRem(key: GlideString, count: number, element: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createRPush(key: GlideString, elements: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createRPushX(key: GlideString, elements: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createRPop(key: GlideString, count?: number): command_request.Command;
/**
 * @internal
 */
export declare function createSAdd(key: GlideString, members: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createSRem(key: GlideString, members: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createSScan(key: GlideString, cursor: GlideString, options?: BaseScanOptions): command_request.Command;
/**
 * @internal
 */
export declare function createSMembers(key: GlideString): command_request.Command;
/**
 *
 * @internal
 */
export declare function createSMove(source: GlideString, destination: GlideString, member: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createSCard(key: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createSInter(keys: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createSInterCard(keys: GlideString[], limit?: number): command_request.Command;
/**
 * @internal
 */
export declare function createSInterStore(destination: GlideString, keys: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createSDiff(keys: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createSDiffStore(destination: GlideString, keys: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createSUnion(keys: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createSUnionStore(destination: GlideString, keys: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createSIsMember(key: GlideString, member: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createSMIsMember(key: GlideString, members: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createSPop(key: GlideString, count?: number): command_request.Command;
/**
 * @internal
 */
export declare function createSRandMember(key: GlideString, count?: number): command_request.Command;
/**
 * @internal
 */
export declare function createCustomCommand(args: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createHIncrBy(key: GlideString, field: GlideString, amount: number): command_request.Command;
/**
 * @internal
 */
export declare function createHIncrByFloat(key: GlideString, field: GlideString, amount: number): command_request.Command;
/**
 * @internal
 */
export declare function createHLen(key: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createHVals(key: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createExists(keys: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createUnlink(keys: GlideString[]): command_request.Command;
export declare enum ExpireOptions {
    /**
     * `HasNoExpiry` - Sets expiry only when the key has no expiry.
     */
    HasNoExpiry = "NX",
    /**
     * `HasExistingExpiry` - Sets expiry only when the key has an existing expiry.
     */
    HasExistingExpiry = "XX",
    /**
     * `NewExpiryGreaterThanCurrent` - Sets expiry only when the new expiry is
     * greater than current one.
     */
    NewExpiryGreaterThanCurrent = "GT",
    /**
     * `NewExpiryLessThanCurrent` - Sets expiry only when the new expiry is less
     * than current one.
     */
    NewExpiryLessThanCurrent = "LT"
}
/**
 * @internal
 */
export declare function createExpire(key: GlideString, seconds: number, option?: ExpireOptions): command_request.Command;
/**
 * @internal
 */
export declare function createExpireAt(key: GlideString, unixSeconds: number, option?: ExpireOptions): command_request.Command;
/**
 * @internal
 */
export declare function createExpireTime(key: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createPExpire(key: GlideString, milliseconds: number, option?: ExpireOptions): command_request.Command;
/**
 * @internal
 */
export declare function createPExpireAt(key: GlideString, unixMilliseconds: number, option?: ExpireOptions): command_request.Command;
/**
 * @internal
 */
export declare function createPExpireTime(key: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createTTL(key: GlideString): command_request.Command;
/**
 * Options for updating elements of a sorted set key.
 */
export declare enum UpdateByScore {
    /** Only update existing elements if the new score is less than the current score. */
    LESS_THAN = "LT",
    /** Only update existing elements if the new score is greater than the current score. */
    GREATER_THAN = "GT"
}
export interface ZAddOptions {
    /**
     * Options for handling existing members.
     */
    conditionalChange?: ConditionalChange;
    /**
     * Options for updating scores.
     */
    updateOptions?: UpdateByScore;
    /**
     * Modify the return value from the number of new elements added, to the total number of elements changed.
     */
    changed?: boolean;
}
/**
 * @internal
 * Convert input from `Record` to `SortedSetDataType` to ensure the only one type.
 */
export declare function convertElementsAndScores(membersAndScores: SortedSetDataType | Record<string, number>): SortedSetDataType;
/**
 * @internal
 */
export declare function createZAdd(key: GlideString, membersAndScores: SortedSetDataType, options?: ZAddOptions, incr?: boolean): command_request.Command;
/**
 * `KeyWeight` - pair of variables represents a weighted key for the `ZINTERSTORE` and `ZUNIONSTORE` sorted sets commands.
 */
export type KeyWeight = [GlideString, number];
/**
 * `AggregationType` - representing aggregation types for `ZINTERSTORE` and `ZUNIONSTORE` sorted set commands.
 */
export type AggregationType = "SUM" | "MIN" | "MAX";
/**
 * @internal
 */
export declare function createZInterstore(destination: GlideString, keys: GlideString[] | KeyWeight[], aggregationType?: AggregationType): command_request.Command;
/**
 * @internal
 */
export declare function createZInter(keys: GlideString[] | KeyWeight[], aggregationType?: AggregationType, withScores?: boolean): command_request.Command;
/**
 * @internal
 */
export declare function createZUnion(keys: GlideString[] | KeyWeight[], aggregationType?: AggregationType, withScores?: boolean): command_request.Command;
/**
 * @internal
 */
export declare function createZRem(key: GlideString, members: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createZCard(key: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createZInterCard(keys: GlideString[], limit?: number): command_request.Command;
/**
 * @internal
 */
export declare function createZDiff(keys: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createZDiffWithScores(keys: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createZDiffStore(destination: GlideString, keys: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createZScore(key: GlideString, member: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createZUnionStore(destination: GlideString, keys: GlideString[] | KeyWeight[], aggregationType?: AggregationType): command_request.Command;
/**
 * @internal
 */
export declare function createZMScore(key: GlideString, members: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createScan(cursor: GlideString, options?: ScanOptions): command_request.Command;
export declare enum InfBoundary {
    /**
     * Positive infinity bound.
     */
    PositiveInfinity = "+",
    /**
     * Negative infinity bound.
     */
    NegativeInfinity = "-"
}
/**
 * Defines the boundaries of a range.
 */
export type Boundary<T> = 
/**
 *  Represents an lower/upper boundary.
 */
InfBoundary
/**
 *  Represents a specific boundary.
 */
 | {
    /**
     * The comparison value.
     */
    value: T;
    /**
     * Whether the value is inclusive. Defaults to `true`.
     */
    isInclusive?: boolean;
};
/**
 * Represents a range by index (rank) in a sorted set.
 * The `start` and `end` arguments represent zero-based indexes.
 */
export interface RangeByIndex {
    /**
     * The start index of the range.
     */
    start: number;
    /**
     * The end index of the range.
     */
    end: number;
}
/**
 * Represents a range by score or a range by lex in a sorted set.
 * The `start` and `end` arguments represent score boundaries.
 */
interface SortedSetRange<T> {
    /**
     * The start boundary.
     */
    start: Boundary<T>;
    /**
     * The end boundary.
     */
    end: Boundary<T>;
    /**
     * The limit argument for a range query.
     * Represents a limit argument for a range query in a sorted set to
     * be used in [ZRANGE](https://valkey.io/commands/zrange) command.
     *
     * The optional LIMIT argument can be used to obtain a sub-range from the
     * matching elements (similar to SELECT LIMIT offset, count in SQL).
     */
    limit?: {
        /**
         * The offset from the start of the range.
         */
        offset: number;
        /**
         * The number of elements to include in the range.
         * A negative count returns all elements from the offset.
         */
        count: number;
    };
}
export type RangeByScore = SortedSetRange<number> & {
    type: "byScore";
};
export type RangeByLex = SortedSetRange<GlideString> & {
    type: "byLex";
};
/**
 * @internal
 */
export declare function createZCount(key: GlideString, minScore: Boundary<number>, maxScore: Boundary<number>): command_request.Command;
/**
 * @internal
 */
export declare function createZRange(key: GlideString, rangeQuery: RangeByIndex | RangeByScore | RangeByLex, reverse?: boolean): command_request.Command;
/**
 * @internal
 */
export declare function createZRangeWithScores(key: GlideString, rangeQuery: RangeByIndex | RangeByScore | RangeByLex, reverse?: boolean): command_request.Command;
/**
 * @internal
 */
export declare function createZRangeStore(destination: GlideString, source: GlideString, rangeQuery: RangeByIndex | RangeByScore | RangeByLex, reverse?: boolean): command_request.Command;
/**
 * @internal
 */
export declare function createType(key: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createStrlen(key: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createLIndex(key: GlideString, index: number): command_request.Command;
/**
 * Defines where to insert new elements into a list.
 */
export declare enum InsertPosition {
    /**
     * Insert new element before the pivot.
     */
    Before = "before",
    /**
     * Insert new element after the pivot.
     */
    After = "after"
}
/**
 * @internal
 */
export declare function createLInsert(key: GlideString, position: InsertPosition, pivot: GlideString, element: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createZPopMin(key: GlideString, count?: number): command_request.Command;
/**
 * @internal
 */
export declare function createZPopMax(key: GlideString, count?: number): command_request.Command;
/**
 * @internal
 */
export declare function createEcho(message: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createPTTL(key: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createZRemRangeByRank(key: GlideString, start: number, end: number): command_request.Command;
/**
 * @internal
 */
export declare function createZRemRangeByLex(key: GlideString, minLex: Boundary<GlideString>, maxLex: Boundary<GlideString>): command_request.Command;
/**
 * @internal
 */
export declare function createZRemRangeByScore(key: GlideString, minScore: Boundary<number>, maxScore: Boundary<number>): command_request.Command;
/** @internal */
export declare function createPersist(key: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createZLexCount(key: GlideString, minLex: Boundary<GlideString>, maxLex: Boundary<GlideString>): command_request.Command;
/** @internal */
export declare function createZRank(key: GlideString, member: GlideString, withScores?: boolean): command_request.Command;
export type StreamTrimOptions = ({
    /**
     * Trim the stream according to entry ID.
     * Equivalent to `MINID` in the Valkey API.
     */
    method: "minid";
    threshold: GlideString;
} | {
    /**
     * Trim the stream according to length.
     * Equivalent to `MAXLEN` in the Valkey API.
     */
    method: "maxlen";
    threshold: number;
}) & {
    /**
     * If `true`, the stream will be trimmed exactly. Equivalent to `=` in the
     * Valkey API. Otherwise the stream will be trimmed in a near-exact manner,
     * which is more efficient, equivalent to `~` in the Valkey API.
     */
    exact: boolean;
    /**
     * If set, sets the maximal amount of entries that will be deleted.
     */
    limit?: number;
};
export interface StreamAddOptions {
    /**
     * If set, the new entry will be added with this ID.
     */
    id?: string;
    /**
     * If set to `false`, a new stream won't be created if no stream matches the
     * given key. Equivalent to `NOMKSTREAM` in the Valkey API.
     */
    makeStream?: boolean;
    /**
     * If set, the add operation will also trim the older entries in the stream.
     */
    trim?: StreamTrimOptions;
}
/**
 * @internal
 */
export declare function createXAdd(key: GlideString, values: [GlideString, GlideString][], options?: StreamAddOptions): command_request.Command;
/**
 * @internal
 */
export declare function createXDel(key: GlideString, ids: string[]): command_request.Command;
/**
 * @internal
 */
export declare function createXTrim(key: GlideString, options: StreamTrimOptions): command_request.Command;
/**
 * @internal
 */
export declare function createXRange(key: GlideString, start: Boundary<string>, end: Boundary<string>, count?: number): command_request.Command;
/**
 * @internal
 */
export declare function createXRevRange(key: GlideString, start: Boundary<string>, end: Boundary<string>, count?: number): command_request.Command;
/**
 * @internal
 */
export declare function createXGroupCreateConsumer(key: GlideString, groupName: GlideString, consumerName: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createXGroupDelConsumer(key: GlideString, groupName: GlideString, consumerName: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createTime(): command_request.Command;
/**
 * @internal
 */
export declare function createPublish(message: GlideString, channel: GlideString, sharded?: boolean): command_request.Command;
/**
 * @internal
 */
export declare function createBRPop(keys: GlideString[], timeout: number): command_request.Command;
/**
 * @internal
 */
export declare function createBLPop(keys: GlideString[], timeout: number): command_request.Command;
/**
 * @internal
 */
export declare function createFCall(func: GlideString, keys: GlideString[], args: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createFCallReadOnly(func: GlideString, keys: GlideString[], args: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createFunctionDelete(libraryCode: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createFunctionFlush(mode?: FlushMode): command_request.Command;
/**
 * @internal
 */
export declare function createFunctionLoad(libraryCode: GlideString, replace?: boolean): command_request.Command;
/** Optional arguments for `FUNCTION LIST` command. */
export interface FunctionListOptions {
    /** A wildcard pattern for matching library names. */
    libNamePattern?: GlideString;
    /** Specifies whether to request the library code from the server or not. */
    withCode?: boolean;
}
/** Type of the response of `FUNCTION LIST` command. */
export type FunctionListResponse = Record<string, GlideString | Record<string, GlideString | null | GlideString[]>[]>[];
/**
 * @internal
 */
export declare function createFunctionList(options?: FunctionListOptions): command_request.Command;
/** Response for `FUNCTION STATS` command on a single node.
 *  The response is a map with 2 keys:
 *  1. Information about the current running function/script (or null if none).
 *  2. Details about the execution engines.
 */
export type FunctionStatsSingleResponse = Record<string, null | Record<string, GlideString | GlideString[] | number> | Record<string, Record<string, number>>>;
/** Full response for `FUNCTION STATS` command across multiple nodes.
 *  It maps node addresses to the per-node response.
 */
export type FunctionStatsFullResponse = Record<string, // Node address
FunctionStatsSingleResponse>;
/** @internal */
export declare function createFunctionStats(): command_request.Command;
/** @internal */
export declare function createFunctionKill(): command_request.Command;
/** @internal */
export declare function createFunctionDump(): command_request.Command;
/**
 * Option for `FUNCTION RESTORE` command: {@link GlideClient.functionRestore} and
 * {@link GlideClusterClient.functionRestore}.
 *
 * @see {@link https://valkey.io/commands/function-restore/"|valkey.io} for more details.
 */
export declare enum FunctionRestorePolicy {
    /**
     * Appends the restored libraries to the existing libraries and aborts on collision. This is the
     * default policy.
     */
    APPEND = "APPEND",
    /** Deletes all existing libraries before restoring the payload. */
    FLUSH = "FLUSH",
    /**
     * Appends the restored libraries to the existing libraries, replacing any existing ones in case
     * of name collisions. Note that this policy doesn't prevent function name collisions, only
     * libraries.
     */
    REPLACE = "REPLACE"
}
/** @internal */
export declare function createFunctionRestore(data: Buffer, policy?: FunctionRestorePolicy): command_request.Command;
/**
 * Represents offsets specifying a string interval to analyze in the {@link BaseClient.bitcount|bitcount} command. The offsets are
 * zero-based indexes, with `0` being the first index of the string, `1` being the next index and so on.
 * The offsets can also be negative numbers indicating offsets starting at the end of the string, with `-1` being
 * the last index of the string, `-2` being the penultimate, and so on.
 *
 * See https://valkey.io/commands/bitcount/ for more details.
 */
export interface BitOffsetOptions {
    /** The starting offset index. */
    start: number;
    /** The ending offset index. Optional since Valkey version 8.0 and above.
     * If not provided, it will default to the end of the string
     */
    end?: number;
    /**
     * The index offset type. This option can only be specified if you are using server version 7.0.0 or above.
     * Could be either {@link BitmapIndexType.BYTE} or {@link BitmapIndexType.BIT}.
     * If no index type is provided, the indexes will be assumed to be byte indexes.
     */
    indexType?: BitmapIndexType;
}
/**
 * @internal
 */
export declare function createBitCount(key: GlideString, options?: BitOffsetOptions): command_request.Command;
/**
 * Enumeration specifying if index arguments are BYTE indexes or BIT indexes.
 * Can be specified in {@link BitOffsetOptions}, which is an optional argument to the {@link BaseClient.bitcount|bitcount} command.
 * Can also be specified as an optional argument to the {@link BaseClient.bitposInverval|bitposInterval} command.
 *
 * since - Valkey version 7.0.0.
 */
export declare enum BitmapIndexType {
    /** Specifies that provided indexes are byte indexes. */
    BYTE = "BYTE",
    /** Specifies that provided indexes are bit indexes. */
    BIT = "BIT"
}
/**
 * @internal
 */
export declare function createBitPos(key: GlideString, bit: number, start?: number, end?: number, indexType?: BitmapIndexType): command_request.Command;
/**
 * Defines flushing mode for {@link GlideClient.flushall}, {@link GlideClusterClient.flushall},
 *      {@link GlideClient.functionFlush}, {@link GlideClusterClient.functionFlush},
 *      {@link GlideClient.flushdb} and {@link GlideClusterClient.flushdb} commands.
 *
 * See https://valkey.io/commands/flushall/ and https://valkey.io/commands/flushdb/ for details.
 */
export declare enum FlushMode {
    /**
     * Flushes synchronously.
     *
     * since Valkey version 6.2.0.
     */
    SYNC = "SYNC",
    /** Flushes asynchronously. */
    ASYNC = "ASYNC"
}
/**
 * @internal
 * This function converts an input from Record or GlideRecord types to GlideRecord.
 *
 * @param record - input record in either Record or GlideRecord types.
 * @returns same data in GlideRecord type.
 */
export declare function convertKeysAndEntries(record: Record<string, string> | GlideRecord<string>): GlideRecord<string>;
/** Optional arguments for {@link BaseClient.xread|xread} command. */
export interface StreamReadOptions {
    /**
     * If set, the read request will block for the set amount of milliseconds or
     * until the server has the required number of entries. A value of `0` will block indefinitely.
     * Equivalent to `BLOCK` in the Valkey API.
     */
    block?: number;
    /**
     * The maximal number of elements requested.
     * Equivalent to `COUNT` in the Valkey API.
     */
    count?: number;
}
/** Optional arguments for {@link BaseClient.xreadgroup|xreadgroup} command. */
export type StreamReadGroupOptions = StreamReadOptions & {
    /**
     * If set, messages are not added to the Pending Entries List (PEL). This is equivalent to
     * acknowledging the message when it is read.
     */
    noAck?: boolean;
};
/**
 * @internal
 */
export declare function createXRead(keys_and_ids: GlideRecord<string>, options?: StreamReadOptions): command_request.Command;
/** @internal */
export declare function createXReadGroup(group: GlideString, consumer: GlideString, keys_and_ids: GlideRecord<string>, options?: StreamReadGroupOptions): command_request.Command;
/**
 * @internal
 */
export declare function createXInfoStream(key: GlideString, options: boolean | number): command_request.Command;
/** @internal */
export declare function createXInfoGroups(key: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createXLen(key: GlideString): command_request.Command;
/** Optional arguments for {@link BaseClient.xpendingWithOptions|xpending}. */
export interface StreamPendingOptions {
    /** Filter pending entries by their idle time - in milliseconds. Available since Valkey 6.2.0. */
    minIdleTime?: number;
    /** Starting stream ID bound for range. Exclusive range is available since Valkey 6.2.0. */
    start: Boundary<string>;
    /** Ending stream ID bound for range. Exclusive range is available since Valkey 6.2.0. */
    end: Boundary<string>;
    /** Limit the number of messages returned. */
    count: number;
    /** Filter pending entries by consumer. */
    consumer?: GlideString;
}
/** @internal */
export declare function createXPending(key: GlideString, group: GlideString, options?: StreamPendingOptions): command_request.Command;
/** @internal */
export declare function createXInfoConsumers(key: GlideString, group: GlideString): command_request.Command;
/** Optional parameters for {@link BaseClient.xclaim|xclaim} command. */
export interface StreamClaimOptions {
    /**
     * Set the idle time (last time it was delivered) of the message in milliseconds. If `idle`
     * is not specified, an `idle` of `0` is assumed, that is, the time count is reset
     * because the message now has a new owner trying to process it.
     */
    idle?: number;
    /**
     * This is the same as {@link idle} but instead of a relative amount of milliseconds, it sets the
     * idle time to a specific Unix time (in milliseconds). This is useful in order to rewrite the AOF
     * file generating `XCLAIM` commands.
     */
    idleUnixTime?: number;
    /**
     * Set the retry counter to the specified value. This counter is incremented every time a message
     * is delivered again. Normally {@link BaseClient.xclaim|xclaim} does not alter this counter,
     * which is just served to clients when the {@link BaseClient.xpending|xpending} command is called:
     * this way clients can detect anomalies, like messages that are never processed for some reason
     * after a big number of delivery attempts.
     */
    retryCount?: number;
    /**
     * Creates the pending message entry in the PEL even if certain specified IDs are not already in
     * the PEL assigned to a different client. However, the message must exist in the stream,
     * otherwise the IDs of non-existing messages are ignored.
     */
    isForce?: boolean;
}
/** @internal */
export declare function createXClaim(key: GlideString, group: GlideString, consumer: GlideString, minIdleTime: number, ids: string[], options?: StreamClaimOptions, justId?: boolean): command_request.Command;
/** @internal */
export declare function createXAutoClaim(key: GlideString, group: GlideString, consumer: GlideString, minIdleTime: number, start: GlideString, count?: number, justId?: boolean): command_request.Command;
/**
 * Optional arguments for {@link BaseClient.xgroupCreate|xgroupCreate}.
 *
 * See https://valkey.io/commands/xgroup-create/ for more details.
 */
export interface StreamGroupOptions {
    /**
     * If `true`and the stream doesn't exist, creates a new stream with a length of `0`.
     */
    mkStream?: boolean;
    /**
     * An arbitrary ID (that isn't the first ID, last ID, or the zero `"0-0"`. Use it to
     * find out how many entries are between the arbitrary ID (excluding it) and the stream's last
     * entry.
     *
     * since Valkey version 7.0.0.
     */
    entriesRead?: string;
}
/**
 * @internal
 */
export declare function createXGroupCreate(key: GlideString, groupName: GlideString, id: string, options?: StreamGroupOptions): command_request.Command;
/**
 * @internal
 */
export declare function createXGroupDestroy(key: GlideString, groupName: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createRename(key: GlideString, newKey: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createRenameNX(key: GlideString, newKey: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createPfAdd(key: GlideString, elements: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createPfCount(keys: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createPfMerge(destination: GlideString, sourceKey: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createObjectEncoding(key: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createObjectFreq(key: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createObjectIdletime(key: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createObjectRefcount(key: GlideString): command_request.Command;
/** Additional parameters for `LOLWUT` command. */
export interface LolwutOptions {
    /**
     * An optional argument that can be used to specify the version of computer art to generate.
     */
    version?: number;
    /**
     * An optional argument that can be used to specify the output:
     * - For version `5`, those are length of the line, number of squares per row, and number of squares per column.
     * - For version `6`, those are number of columns and number of lines.
     */
    parameters?: number[];
}
/**
 * @internal
 */
export declare function createLolwut(options?: LolwutOptions): command_request.Command;
/**
 * @internal
 */
export declare function createFlushAll(mode?: FlushMode): command_request.Command;
/**
 * @internal
 */
export declare function createFlushDB(mode?: FlushMode): command_request.Command;
/**
 * @internal
 */
export declare function createCopy(source: GlideString, destination: GlideString, options?: {
    destinationDB?: number;
    replace?: boolean;
}): command_request.Command;
/**
 * @internal
 */
export declare function createMove(key: GlideString, dbIndex: number): command_request.Command;
/**
 * @internal
 */
export declare function createDump(key: GlideString): command_request.Command;
/**
 * Optional arguments for `RESTORE` command.
 *
 * @See {@link https://valkey.io/commands/restore/|valkey.io} for details.
 * @remarks `IDLETIME` and `FREQ` modifiers cannot be set at the same time.
 */
export interface RestoreOptions {
    /**
     * Set to `true` to replace the key if it exists.
     */
    replace?: boolean;
    /**
     * Set to `true` to specify that `ttl` argument of {@link BaseClient.restore} represents
     * an absolute Unix timestamp (in milliseconds).
     */
    absttl?: boolean;
    /**
     * Set the `IDLETIME` option with object idletime to the given key.
     */
    idletime?: number;
    /**
     * Set the `FREQ` option with object frequency to the given key.
     */
    frequency?: number;
}
/**
 * @internal
 */
export declare function createRestore(key: GlideString, ttl: number, value: GlideString, options?: RestoreOptions): command_request.Command;
/**
 * Optional arguments to LPOS command.
 *
 * See https://valkey.io/commands/lpos/ for more details.
 */
export interface LPosOptions {
    /** The rank of the match to return. */
    rank?: number;
    /** The specific number of matching indices from a list. */
    count?: number;
    /** The maximum number of comparisons to make between the element and the items in the list. */
    maxLength?: number;
}
/**
 * @internal
 */
export declare function createLPos(key: GlideString, element: GlideString, options?: LPosOptions): command_request.Command;
/**
 * @internal
 */
export declare function createDBSize(): command_request.Command;
/**
 * An optional condition to the {@link BaseClient.geoadd | geoadd},
 * {@link BaseClient.zadd | zadd} and {@link BaseClient.set | set} commands.
 */
export declare enum ConditionalChange {
    /**
     * Only update elements that already exist. Don't add new elements. Equivalent to `XX` in the Valkey API.
     */
    ONLY_IF_EXISTS = "XX",
    /**
     * Only add new elements. Don't update already existing elements. Equivalent to `NX` in the Valkey API.
     */
    ONLY_IF_DOES_NOT_EXIST = "NX"
}
/**
 * Represents a geographic position defined by longitude and latitude.
 * The exact limits, as specified by `EPSG:900913 / EPSG:3785 / OSGEO:41001` are the
 * following:
 *
 *   Valid longitudes are from `-180` to `180` degrees.
 *   Valid latitudes are from `-85.05112878` to `85.05112878` degrees.
 */
export interface GeospatialData {
    /** The longitude coordinate. */
    longitude: number;
    /** The latitude coordinate. */
    latitude: number;
}
/**
 * Optional arguments for the GeoAdd command.
 *
 * See https://valkey.io/commands/geoadd/ for more details.
 */
export interface GeoAddOptions {
    /** Options for handling existing members. See {@link ConditionalChange}. */
    updateMode?: ConditionalChange;
    /** If `true`, returns the count of changed elements instead of new elements added. */
    changed?: boolean;
}
/**
 * @internal
 */
export declare function createGeoAdd(key: GlideString, membersToGeospatialData: Map<GlideString, GeospatialData>, options?: GeoAddOptions): command_request.Command;
/** Enumeration representing distance units options. */
export declare enum GeoUnit {
    /** Represents distance in meters. */
    METERS = "m",
    /** Represents distance in kilometers. */
    KILOMETERS = "km",
    /** Represents distance in miles. */
    MILES = "mi",
    /** Represents distance in feet. */
    FEET = "ft"
}
/**
 * @internal
 */
export declare function createGeoPos(key: GlideString, members: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createGeoDist(key: GlideString, member1: GlideString, member2: GlideString, geoUnit?: GeoUnit): command_request.Command;
/**
 * @internal
 */
export declare function createGeoHash(key: GlideString, members: GlideString[]): command_request.Command;
/**
 * Optional parameters for {@link BaseClient.geosearch|geosearch} command which defines what should be included in the
 * search results and how results should be ordered and limited.
 */
export type GeoSearchResultOptions = GeoSearchCommonResultOptions & {
    /** Include the coordinate of the returned items. */
    withCoord?: boolean;
    /**
     * Include the distance of the returned items from the specified center point.
     * The distance is returned in the same unit as specified for the `searchBy` argument.
     */
    withDist?: boolean;
    /** Include the geohash of the returned items. */
    withHash?: boolean;
};
/**
 * Optional parameters for {@link BaseClient.geosearchstore|geosearchstore} command which defines what should be included in the
 * search results and how results should be ordered and limited.
 */
export type GeoSearchStoreResultOptions = GeoSearchCommonResultOptions & {
    /**
     * Determines what is stored as the sorted set score. Defaults to `false`.
     * - If set to `false`, the geohash of the location will be stored as the sorted set score.
     * - If set to `true`, the distance from the center of the shape (circle or box) will be stored as the sorted set score. The distance is represented as a floating-point number in the same unit specified for that shape.
     */
    storeDist?: boolean;
};
interface GeoSearchCommonResultOptions {
    /** Indicates the order the result should be sorted in. */
    sortOrder?: SortOrder;
    /** Indicates the number of matches the result should be limited to. */
    count?: number;
    /** Whether to allow returning as enough matches are found. This requires `count` parameter to be set. */
    isAny?: boolean;
}
/** Defines the sort order for nested results. */
export declare enum SortOrder {
    /** Sort by ascending order. */
    ASC = "ASC",
    /** Sort by descending order. */
    DESC = "DESC"
}
export type GeoSearchShape = GeoCircleShape | GeoBoxShape;
/** Circle search shape defined by the radius value and measurement unit. */
export interface GeoCircleShape {
    /** The radius to search by. */
    radius: number;
    /** The measurement unit of the radius. */
    unit: GeoUnit;
}
/** Rectangle search shape defined by the width and height and measurement unit. */
export interface GeoBoxShape {
    /** The width of the rectangle to search by. */
    width: number;
    /** The height of the rectangle to search by. */
    height: number;
    /** The measurement unit of the width and height. */
    unit: GeoUnit;
}
export type SearchOrigin = CoordOrigin | MemberOrigin;
/** The search origin represented by a {@link GeospatialData} position. */
export interface CoordOrigin {
    /** The pivot location to search from. */
    position: GeospatialData;
}
/** The search origin represented by an existing member. */
export interface MemberOrigin {
    /** Member (location) name stored in the sorted set to use as a search pivot. */
    member: GlideString;
}
/** @internal */
export declare function createGeoSearch(key: GlideString, searchFrom: SearchOrigin, searchBy: GeoSearchShape, resultOptions?: GeoSearchResultOptions): command_request.Command;
/** @internal */
export declare function createGeoSearchStore(destination: GlideString, source: GlideString, searchFrom: SearchOrigin, searchBy: GeoSearchShape, resultOptions?: GeoSearchStoreResultOptions): command_request.Command;
/**
 * @internal
 */
export declare function createZRevRank(key: GlideString, member: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createZRevRankWithScore(key: GlideString, member: GlideString): command_request.Command;
/**
 * Mandatory option for zmpop.
 * Defines which elements to pop from the sorted set.
 */
export declare enum ScoreFilter {
    /** Pop elements with the highest scores. */
    MAX = "MAX",
    /** Pop elements with the lowest scores. */
    MIN = "MIN"
}
/**
 * @internal
 */
export declare function createZMPop(keys: GlideString[], modifier: ScoreFilter, count?: number): command_request.Command;
/**
 * @internal
 */
export declare function createBZMPop(keys: GlideString[], modifier: ScoreFilter, timeout: number, count?: number): command_request.Command;
/**
 * @internal
 */
export declare function createZIncrBy(key: GlideString, increment: number, member: GlideString): command_request.Command;
/**
 * Optional arguments to {@link BaseClient.sort|sort}, {@link BaseClient.sortStore|sortStore} and {@link BaseClient.sortReadOnly|sortReadOnly} commands.
 *
 * See https://valkey.io/commands/sort/ for more details.
 *
 * @remarks When in cluster mode, {@link SortOptions.byPattern|byPattern} and {@link SortOptions.getPatterns|getPattern} must map to the same hash
 *     slot as the key, and this is supported only since Valkey version 8.0.
 */
export interface SortOptions {
    /**
     * A pattern to sort by external keys instead of by the elements stored at the key themselves. The
     * pattern should contain an asterisk (*) as a placeholder for the element values, where the value
     * from the key replaces the asterisk to create the key name. For example, if `key`
     * contains IDs of objects, `byPattern` can be used to sort these IDs based on an
     * attribute of the objects, like their weights or timestamps.
     * Supported in cluster mode since Valkey version 8.0 and above.
     */
    byPattern?: GlideString;
    /**
     * Limiting the range of the query by setting offset and result count. See {@link Limit} class for
     * more information.
     */
    limit?: Limit;
    /**
     * A pattern used to retrieve external keys' values, instead of the elements at `key`.
     * The pattern should contain an asterisk (`*`) as a placeholder for the element values, where the
     * value from `key` replaces the asterisk to create the `key` name. This
     * allows the sorted elements to be transformed based on the related keys values. For example, if
     * `key` contains IDs of users, `getPatterns` can be used to retrieve
     * specific attributes of these users, such as their names or email addresses. E.g., if
     * `getPatterns` is `name_*`, the command will return the values of the keys
     * `name_<element>` for each sorted element. Multiple `getPatterns`
     * arguments can be provided to retrieve multiple attributes. The special value `#` can
     * be used to include the actual element from `key` being sorted. If not provided, only
     * the sorted elements themselves are returned.
     * Supported in cluster mode since Valkey version 8.0 and above.
     */
    getPatterns?: GlideString[];
    /** Options for sorting order of elements. */
    orderBy?: SortOrder;
    /**
     * When `true`, sorts elements lexicographically. When `false` (default),
     * sorts elements numerically. Use this when the list, set, or sorted set contains string values
     * that cannot be converted into double precision floating point numbers.
     */
    isAlpha?: boolean;
}
/**
 * The `LIMIT` argument is commonly used to specify a subset of results from the
 * matching elements, similar to the `LIMIT` clause in SQL (e.g., `SELECT LIMIT offset, count`).
 */
export interface Limit {
    /** The starting position of the range, zero based. */
    offset: number;
    /** The maximum number of elements to include in the range. A negative count returns all elements from the offset. */
    count: number;
}
/** @internal */
export declare function createSort(key: GlideString, options?: SortOptions, destination?: GlideString): command_request.Command;
/** @internal */
export declare function createSortReadOnly(key: GlideString, options?: SortOptions): command_request.Command;
/**
 * @internal
 */
export declare function createHStrlen(key: GlideString, field: GlideString): command_request.Command;
/** @internal */
export declare function createHRandField(key: GlideString, count?: number, withValues?: boolean): command_request.Command;
/**
 * @internal
 */
export declare function createHScan(key: GlideString, cursor: string, options?: HScanOptions): command_request.Command;
/**
 * @internal
 */
export declare function createZRandMember(key: GlideString, count?: number, withscores?: boolean): command_request.Command;
/** @internal */
export declare function createLastSave(): command_request.Command;
/** @internal */
export declare function createLCS(key1: GlideString, key2: GlideString, options?: {
    len?: boolean;
    idx?: {
        withMatchLen?: boolean;
        minMatchLen?: number;
    };
}): command_request.Command;
/**
 * @internal
 */
export declare function createTouch(keys: GlideString[]): command_request.Command;
/** @internal */
export declare function createRandomKey(): command_request.Command;
/** @internal */
export declare function createWatch(keys: GlideString[]): command_request.Command;
/** @internal */
export declare function createUnWatch(): command_request.Command;
/** @internal */
export declare function createWait(numreplicas: number, timeout: number): command_request.Command;
/**
 * This base class represents the common set of optional arguments for the SCAN family of commands.
 * Concrete implementations of this class are tied to specific SCAN commands (`SCAN`, `SSCAN`).
 */
export interface BaseScanOptions {
    /**
     * The match filter is applied to the result of the command and will only include
     * strings that match the pattern specified. If the sorted set is large enough for scan commands to return
     * only a subset of the sorted set then there could be a case where the result is empty although there are
     * items that match the pattern specified. This is due to the default `COUNT` being `10` which indicates
     * that it will only fetch and match `10` items from the list.
     */
    match?: GlideString;
    /**
     * `COUNT` is a just a hint for the command for how many elements to fetch from the
     * sorted set. `COUNT` could be ignored until the sorted set is large enough for the `SCAN` commands to
     * represent the results as compact single-allocation packed encoding.
     */
    readonly count?: number;
}
/**
 * Options for the SCAN command.
 * `match`: The match filter is applied to the result of the command and will only include keys that match the pattern specified.
 * `count`: `COUNT` is a just a hint for the command for how many elements to fetch from the server, the default is 10.
 * `type`: The type of the object to scan.
 *  Types are the data types of Valkey: `string`, `list`, `set`, `zset`, `hash`, `stream`.
 */
export interface ScanOptions extends BaseScanOptions {
    type?: ObjectType;
}
/**
 * Options specific to the ZSCAN command, extending from the base scan options.
 */
export type ZScanOptions = BaseScanOptions & {
    /**
     * If true, the scores are not included in the results.
     * Supported from Valkey 8.0.0 and above.
     */
    readonly noScores?: boolean;
};
/**
 * Options specific to the HSCAN command, extending from the base scan options.
 */
export type HScanOptions = BaseScanOptions & {
    /**
     * If true, the values of the fields are not included in the results.
     * Supported from Valkey 8.0.0 and above.
     */
    readonly noValues?: boolean;
};
/**
 * @internal
 */
export declare function createZScan(key: GlideString, cursor: string, options?: ZScanOptions): command_request.Command;
/** @internal */
export declare function createSetRange(key: GlideString, offset: number, value: GlideString): command_request.Command;
/** @internal */
export declare function createAppend(key: GlideString, value: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createLMPop(keys: GlideString[], direction: ListDirection, count?: number): command_request.Command;
/**
 * @internal
 */
export declare function createBLMPop(keys: GlideString[], direction: ListDirection, timeout: number, count?: number): command_request.Command;
/**
 * @internal
 */
export declare function createPubSubChannels(pattern?: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createPubSubNumPat(): command_request.Command;
/**
 * @internal
 */
export declare function createPubSubNumSub(channels?: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createPubsubShardChannels(pattern?: GlideString): command_request.Command;
/**
 * @internal
 */
export declare function createPubSubShardNumSub(channels?: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createBZPopMax(keys: GlideString[], timeout: number): command_request.Command;
/**
 * @internal
 */
export declare function createBZPopMin(keys: GlideString[], timeout: number): command_request.Command;
/**
 * @internal
 */
export declare function createScriptShow(sha1: GlideString): command_request.Command;
/**
 * Time unit representation which is used in optional arguments for {@link BaseClient.getex|getex} and {@link BaseClient.set|set} command.
 */
export declare enum TimeUnit {
    /**
     * Set the specified expire time, in seconds. Equivalent to
     * `EX` in the VALKEY API.
     */
    Seconds = "EX",
    /**
     * Set the specified expire time, in milliseconds. Equivalent
     * to `PX` in the VALKEY API.
     */
    Milliseconds = "PX",
    /**
     * Set the specified Unix time at which the key will expire,
     * in seconds. Equivalent to `EXAT` in the VALKEY API.
     */
    UnixSeconds = "EXAT",
    /**
     * Set the specified Unix time at which the key will expire,
     * in milliseconds. Equivalent to `PXAT` in the VALKEY API.
     */
    UnixMilliseconds = "PXAT"
}
/**
 * @internal
 */
export declare function createGetEx(key: GlideString, options?: "persist" | {
    type: TimeUnit;
    duration: number;
}): command_request.Command;
/**
 * @internal
 */
export declare function createXAck(key: GlideString, group: GlideString, ids: string[]): command_request.Command;
/**
 * @internal
 */
export declare function createXGroupSetid(key: GlideString, groupName: GlideString, id: string, entriesRead?: number): command_request.Command;
/**
 * @internal
 */
export declare function createScriptExists(sha1s: GlideString[]): command_request.Command;
/**
 * @internal
 */
export declare function createScriptFlush(mode?: FlushMode): command_request.Command;
/** @internal */
export declare function createScriptKill(): command_request.Command;
export {};