@upstash/redis 1.38.4 → 1.39.0

package/{error-8y4qG0W2.d.ts → error-DOszGRxg.d.ts}

@@ -212,6 +212,235 @@ declare class TypeCommand extends Command<Type, Type> {
     constructor(cmd: [key: string], opts?: CommandOptions<Type, Type>);
 }
 
+type ArInfoOptions = {
+    /**
+     * Also report per-slice statistics. This walks the whole array.
+     */
+    full?: boolean;
+};
+type ArInfoResult = {
+    /** Highest occupied index plus one, as reported by `arlen`. A string, like every index. */
+    len: string;
+    /** Number of occupied slots, as reported by `arcount`. */
+    count: number;
+    /** Number of indexes covered by one slice. */
+    sliceSize: number;
+    /** Number of slices currently allocated. */
+    slices: number;
+    /** Number of entries in the slice directory. */
+    directorySize: number;
+    /** Number of entries in the top-level directory. */
+    superDirEntries: number;
+    /** Index the next `arinsert` would write to. A string, like every index. */
+    nextInsertIndex: string;
+    /** Slices stored in dense form. Only with `full`. */
+    denseSlices?: number;
+    /** Slices stored in sparse form. Only with `full`. */
+    sparseSlices?: number;
+    /** Average number of values in a dense slice. Only with `full`. */
+    avgDenseSize?: number;
+    /** Average fill ratio of a dense slice. Only with `full`. */
+    avgDenseFill?: number;
+    /** Average number of values in a sparse slice. Only with `full`. */
+    avgSparseSize?: number;
+};
+type RawArInfo = unknown[] | Record<string, unknown>;
+/**
+ * Describes how an array is laid out in memory. Throws if the key does not exist.
+ *
+ * @see https://upstash.com/docs/redis/commands/array/arinfo
+ */
+declare class ArInfoCommand extends Command<RawArInfo, ArInfoResult> {
+    constructor([key, opts]: [key: string, opts?: ArInfoOptions], cmdOpts?: CommandOptions<RawArInfo, ArInfoResult>);
+}
+
+/**
+ * A single `ARGREP` predicate:
+ * - `exact`: the whole value equals the pattern
+ * - `match`: the value contains the pattern as a substring
+ * - `glob`: the value matches a glob pattern (`*` and `?`)
+ * - `re`: the value matches a regular expression
+ */
+type ArGrepPredicate = {
+    exact: string;
+} | {
+    match: string;
+} | {
+    glob: string;
+} | {
+    re: string;
+};
+type ArGrepOptions = {
+    /**
+     * One or more predicates (at most 250).
+     */
+    predicates: ArGrepPredicate[];
+    /**
+     * How to combine several predicates. `OR` (the default) matches a slot when any predicate
+     * matches, `AND` requires all of them.
+     */
+    combine?: "AND" | "OR" | "and" | "or";
+    /**
+     * Compare case-insensitively.
+     */
+    noCase?: boolean;
+    /**
+     * Return `[index, value]` pairs instead of bare indexes.
+     */
+    withValues?: boolean;
+    /**
+     * Maximum number of matches to return.
+     */
+    limit?: number;
+};
+/**
+ * Matching indexes, or `[index, value]` pairs when `withValues` is `true`. Indexes are returned as
+ * strings; see `arlen`.
+ */
+type ArGrepResult<TData, TOpts extends ArGrepOptions> = TOpts extends {
+    withValues: true;
+} ? [string, TData][] : TOpts extends {
+    withValues: false;
+} ? string[] : "withValues" extends keyof TOpts ? string[] | [string, TData][] : string[];
+/**
+ * Returns the indexes in `[start, end]` whose value matches the given predicates, or
+ * `[index, value]` pairs with `withValues`. `start` and `end` accept `"-"` and `"+"` for the lowest
+ * and highest possible index.
+ *
+ * @see https://upstash.com/docs/redis/commands/array/argrep
+ */
+declare class ArGrepCommand<TData = string, TOpts extends ArGrepOptions = ArGrepOptions> extends Command<unknown[], ArGrepResult<TData, TOpts>> {
+    constructor([key, start, end, opts]: [
+        key: string,
+        start: number | string,
+        end: number | string,
+        opts: TOpts
+    ], cmdOpts?: CommandOptions<unknown[], ArGrepResult<TData, TOpts>>);
+}
+
+/**
+ * Distance metric used by a vector index.
+ */
+type VectorMetric = "COSINE" | "EUCLIDEAN" | "DOT";
+/**
+ * Speed / recall trade-off for `VECTOR.QUERY`.
+ *
+ * @default "BALANCED"
+ */
+type VectorQueryProfile = "FAST" | "BALANCED" | "PRECISE";
+/**
+ * A vector to add or query with. Accepts:
+ * - `number[]`: sent as `VALUES <n> <f1> ... <fn>`
+ * - `Float32Array`: encoded as little-endian FP32 and sent as `BASE64-FP32 <b64>`
+ * - `{ base64: string }`: a base64-encoded little-endian FP32 blob, sent as-is with `BASE64-FP32`
+ *   (e.g. the `encoding_format: "base64"` output of embedding providers)
+ */
+type VectorInput = number[] | Float32Array | {
+    base64: string;
+};
+type VectorCreateOptions = {
+    /**
+     * Number of dimensions of the vectors stored in the index. Must be between 1 and 32768.
+     */
+    dimension: number;
+    /**
+     * Distance metric used to compare vectors.
+     */
+    metric: VectorMetric;
+    /**
+     * When `true`, creating an index that already exists with the same dimension and metric
+     * succeeds (returns `0`) instead of throwing.
+     */
+    existsOk?: boolean;
+};
+type VectorQueryOptions = {
+    /**
+     * The query vector.
+     */
+    vector: VectorInput;
+    /**
+     * Number of nearest neighbours to return. Must be between 1 and 1000.
+     */
+    topK: number;
+    /**
+     * Speed / recall trade-off.
+     *
+     * @default "BALANCED"
+     */
+    profile?: VectorQueryProfile;
+};
+type VectorQueryResult = {
+    id: string;
+    score: number;
+};
+type VectorIndexInfo = {
+    dimension: number;
+    metric: VectorMetric;
+};
+
+type CreateVectorIndexParameters = VectorCreateOptions & {
+    /**
+     * Name (key) of the index.
+     */
+    name: string;
+};
+type VectorIndexParameters = {
+    name: string;
+    client: Requester;
+    commandOptions?: CommandOptions<any, any>;
+};
+/**
+ * A handle to a vector index. Obtain one with `redis.vector.createIndex(...)` or
+ * `redis.vector.index(name)`.
+ *
+ * @example
+ * ```typescript
+ * const index = await redis.vector.createIndex({ name: "docs", dimension: 3, metric: "COSINE" });
+ * await index.add("doc-1", [0.1, 0.2, 0.3]);
+ * const hits = await index.query({ vector: [0.1, 0.2, 0.3], topK: 5 });
+ * ```
+ */
+declare class VectorIndex {
+    readonly name: string;
+    private client;
+    private commandOptions?;
+    constructor({ name, client, commandOptions }: VectorIndexParameters);
+    /**
+     * Adds a vector to the index, or overwrites the vector stored under `id`.
+     *
+     * @returns `1` if a new vector was inserted, `0` if an existing one was overwritten.
+     */
+    add(id: string, vector: VectorInput): Promise<0 | 1>;
+    /**
+     * Returns the vector stored under `id`, or `null` if it does not exist.
+     */
+    get(id: string): Promise<number[] | null>;
+    /**
+     * Returns the `topK` nearest neighbours of the query vector.
+     */
+    query(options: VectorQueryOptions): Promise<VectorQueryResult[]>;
+    /**
+     * Deletes the vector stored under `id`.
+     *
+     * @returns `1` if the vector existed and was removed, `0` otherwise.
+     */
+    delete(id: string): Promise<0 | 1>;
+    /**
+     * Returns the number of vectors in the index.
+     */
+    count(): Promise<number>;
+    /**
+     * Returns the dimension and metric of the index, or `null` if it does not exist.
+     */
+    info(): Promise<VectorIndexInfo | null>;
+    /**
+     * Drops the index and all vectors in it.
+     *
+     * @returns `1` if the index existed and was dropped, `0` otherwise.
+     */
+    drop(): Promise<0 | 1>;
+}
+
 declare const FIELD_TYPES: readonly ["TEXT", "U64", "I64", "F64", "BOOL", "DATE", "KEYWORD", "FACET"];
 type FieldType = (typeof FIELD_TYPES)[number];
 type TextField = {
@@ -579,7 +808,10 @@ type DescribeFieldInfo = {
 };
 type IndexDescription<TSchema extends NestedIndexSchema | FlatIndexSchema> = {
     name: string;
-    dataType: "hash" | "string" | "json";
+    dataType: "hash" | "string" | "json" | "stream";
+    /**
+     * Key prefixes tracked by the index. For a stream index, this holds the single stream key.
+     */
     prefixes: string[];
     language?: Language;
     schema: IsDefaultSchema<TSchema> extends true ? Record<string, DescribeFieldInfo> : Record<SchemaPaths<TSchema>, DescribeFieldInfo>;
@@ -794,18 +1026,34 @@ type FacetResult = {
 
 type CreateIndexParameters<TSchema extends NestedIndexSchema | FlatIndexSchema> = {
     name: string;
-    prefix: string | string[];
     language?: Language;
     skipInitialScan?: boolean;
     existsOk?: boolean;
 } & ({
     dataType: "string";
+    prefix: string | string[];
     schema: TSchema extends NestedIndexSchema ? TSchema : never;
 } | {
     dataType: "json";
+    prefix: string | string[];
     schema: TSchema extends NestedIndexSchema ? TSchema : never;
 } | {
     dataType: "hash";
+    prefix: string | string[];
+    schema: TSchema extends FlatIndexSchema ? TSchema : never;
+} | {
+    /**
+     * Index the entries of a single Redis stream. Each entry becomes a document whose key is
+     * the entry ID and whose fields are the entry's fields.
+     *
+     * @see https://upstash.com/docs/redis/search/streams
+     */
+    dataType: "stream";
+    /**
+     * Exact key of the stream to index. The stream does not need to exist yet.
+     */
+    stream: string;
+    prefix?: never;
     schema: TSchema extends FlatIndexSchema ? TSchema : never;
 });
 type InitIndexParameters<TSchema extends NestedIndexSchema | FlatIndexSchema> = {
@@ -879,6 +1127,230 @@ declare class AppendCommand extends Command<number, number> {
     constructor(cmd: [key: string, value: string], opts?: CommandOptions<number, number>);
 }
 
+/**
+ * Returns the number of occupied slots in an array. A missing key counts as `0`.
+ *
+ * @see https://upstash.com/docs/redis/commands/array/arcount
+ */
+declare class ArCountCommand extends Command<number, number> {
+    constructor(cmd: [key: string], opts?: CommandOptions<number, number>);
+}
+
+/**
+ * Empties one or more array slots. Later values are not shifted.
+ *
+ * Returns the number of slots that held a value.
+ *
+ * @see https://upstash.com/docs/redis/commands/array/ardel
+ */
+declare class ArDelCommand extends Command<number, number> {
+    constructor(cmd: [key: string, ...indexes: (number | string)[]], opts?: CommandOptions<number, number>);
+}
+
+/**
+ * Empties every occupied slot inside one or more inclusive `[start, end]` ranges.
+ *
+ * Returns the total number of values removed across all ranges.
+ *
+ * @see https://upstash.com/docs/redis/commands/array/ardelrange
+ */
+declare class ArDelRangeCommand extends Command<number, number> {
+    constructor([key, ...ranges]: [key: string, ...ranges: [start: number | string, end: number | string][]], opts?: CommandOptions<number, number>);
+}
+
+/**
+ * Returns the value stored at `index`, or `null` if the slot is empty or the key does not exist.
+ *
+ * @see https://upstash.com/docs/redis/commands/array/arget
+ */
+declare class ArGetCommand<TData = string> extends Command<unknown | null, TData | null> {
+    constructor(cmd: [key: string, index: number | string], opts?: CommandOptions<unknown | null, TData | null>);
+}
+
+/**
+ * Returns every slot in the inclusive range `[start, end]`, with `null` for empty slots.
+ *
+ * When `start` is greater than `end`, the values are returned from the higher index down.
+ * Ranges wider than 1,000,000 indexes are rejected by the server.
+ *
+ * @see https://upstash.com/docs/redis/commands/array/argetrange
+ */
+declare class ArGetRangeCommand<TData = string> extends Command<unknown[], (TData | null)[]> {
+    constructor(cmd: [key: string, start: number | string, end: number | string], opts?: CommandOptions<unknown[], (TData | null)[]>);
+}
+
+/**
+ * Appends one or more values after the array's append cursor.
+ *
+ * Returns the index the last value was written to (not the number of values written).
+ *
+ * Indexes are returned as strings; see `arlen`.
+ *
+ * @see https://upstash.com/docs/redis/commands/array/arinsert
+ */
+declare class ArInsertCommand<TData = string> extends Command<number | string, string> {
+    constructor(cmd: [key: string, ...values: TData[]], opts?: CommandOptions<number | string, string>);
+}
+
+type ArLastItemsOptions = {
+    /**
+     * Return the newest value first instead of last.
+     */
+    rev?: boolean;
+};
+/**
+ * Returns up to `count` of the most recently appended values, walking backwards from the append
+ * cursor. Values come back oldest-first unless `rev` is set.
+ *
+ * @see https://upstash.com/docs/redis/commands/array/arlastitems
+ */
+declare class ArLastItemsCommand<TData = string> extends Command<unknown[], (TData | null)[]> {
+    constructor([key, count, opts]: [key: string, count: number, opts?: ArLastItemsOptions], cmdOpts?: CommandOptions<unknown[], (TData | null)[]>);
+}
+
+/**
+ * Returns the length of an array: the highest occupied index plus one. A missing key has length `0`.
+ *
+ * Because arrays are sparse this can be larger than the number of stored values, see `arcount`.
+ *
+ * Indexes are returned as strings: they run up to 2^64-2, past what a JavaScript number can hold
+ * exactly. This matches how the SDK keeps the `scan` cursor a string, and the value can be passed
+ * straight back into any command that takes an index.
+ *
+ * @see https://upstash.com/docs/redis/commands/array/arlen
+ */
+declare class ArLenCommand extends Command<number | string, string> {
+    constructor(cmd: [key: string], opts?: CommandOptions<number | string, string>);
+}
+
+/**
+ * Returns the values at several indexes, in the order the indexes were given, with `null` for
+ * empty slots.
+ *
+ * @see https://upstash.com/docs/redis/commands/array/armget
+ */
+declare class ArMGetCommand<TData = string> extends Command<unknown[], (TData | null)[]> {
+    constructor(cmd: [key: string, ...indexes: (number | string)[]], opts?: CommandOptions<unknown[], (TData | null)[]>);
+}
+
+/**
+ * Index-value pairs for `ARMSET`, either as an object (`{ 0: "a", 10: "b" }`) or as a list of
+ * `[index, value]` tuples.
+ */
+type ArMSetValues<TData> = Record<number | string, TData> | [number | string, TData][];
+/**
+ * Writes several index-value pairs into an array in one atomic call.
+ *
+ * Returns the number of slots that were newly occupied. Overwriting an existing value contributes `0`.
+ *
+ * @see https://upstash.com/docs/redis/commands/array/armset
+ */
+declare class ArMSetCommand<TData = string> extends Command<number, number> {
+    constructor([key, values]: [key: string, values: ArMSetValues<TData>], opts?: CommandOptions<number, number>);
+}
+
+/**
+ * Returns the index the next `arinsert` would write to, without moving the cursor.
+ *
+ * Returns `"0"` for a missing key or one that was never appended to, and `null` when the cursor is
+ * already at the highest supported index. Indexes are returned as strings; see `arlen`.
+ *
+ * @see https://upstash.com/docs/redis/commands/array/arnext
+ */
+declare class ArNextCommand extends Command<number | string | null, string | null> {
+    constructor(cmd: [key: string], opts?: CommandOptions<number | string | null, string | null>);
+}
+
+type ArOpKeyword = "SUM" | "MIN" | "MAX" | "AND" | "OR" | "XOR" | "USED";
+/**
+ * Reduction applied by `AROP`:
+ * - `SUM`, `MIN`, `MAX`: numeric aggregates
+ * - `AND`, `OR`, `XOR`: bitwise folds over the values as 64-bit integers
+ * - `USED`: number of occupied slots
+ * - `{ match: value }`: number of slots whose value equals `value`
+ */
+type ArOpOperation<TData = string> = ArOpKeyword | Lowercase<ArOpKeyword> | {
+    match: TData;
+};
+/**
+ * Reduces the values in the inclusive range `[start, end]` to a single number on the server.
+ *
+ * `SUM`, `MIN`, `MAX`, `AND`, `OR` and `XOR` skip non-numeric values and return `null` when the
+ * range contains nothing they could use. `USED` and `match` always return a number.
+ *
+ * Results are returned as JavaScript numbers, so bitwise results beyond `Number.MAX_SAFE_INTEGER`
+ * lose precision.
+ *
+ * @see https://upstash.com/docs/redis/commands/array/arop
+ */
+declare class ArOpCommand<TData = string> extends Command<string | number | null, number | null> {
+    constructor([key, start, end, operation]: [
+        key: string,
+        start: number | string,
+        end: number | string,
+        operation: ArOpOperation<TData>
+    ], opts?: CommandOptions<string | number | null, number | null>);
+}
+
+/**
+ * Appends values to a fixed-size ring of `size` slots, wrapping back to index `0` and overwriting
+ * the oldest values once the ring is full. Calling it with a different `size` reshapes the ring.
+ *
+ * Returns the index the last value was written to, as a string; see `arlen`.
+ *
+ * @see https://upstash.com/docs/redis/commands/array/arring
+ */
+declare class ArRingCommand<TData = string> extends Command<number | string, string> {
+    constructor(cmd: [key: string, size: number, ...values: TData[]], opts?: CommandOptions<number | string, string>);
+}
+
+type ArScanOptions = {
+    /**
+     * Maximum number of slots to return.
+     */
+    limit?: number;
+};
+/**
+ * Returns the occupied slots in the inclusive range `[start, end]` as `[index, value]` pairs, in
+ * ascending index order. Empty slots are skipped.
+ *
+ * Indexes are returned as strings; see `arlen`.
+ *
+ * @see https://upstash.com/docs/redis/commands/array/arscan
+ */
+declare class ArScanCommand<TData = string> extends Command<unknown[], [string, TData][]> {
+    constructor([key, start, end, opts]: [
+        key: string,
+        start: number | string,
+        end: number | string,
+        opts?: ArScanOptions
+    ], cmdOpts?: CommandOptions<unknown[], [string, TData][]>);
+}
+
+/**
+ * Moves the append cursor so that the next `arinsert` writes to `index`. Stored values are not
+ * touched.
+ *
+ * Returns `1` if the cursor was moved, `0` if the key does not exist.
+ *
+ * @see https://upstash.com/docs/redis/commands/array/arseek
+ */
+declare class ArSeekCommand extends Command<0 | 1, 0 | 1> {
+    constructor(cmd: [key: string, index: number | string], opts?: CommandOptions<0 | 1, 0 | 1>);
+}
+
+/**
+ * Writes one or more values into an array, starting at `index`: the first value goes to `index`,
+ * the next to `index + 1`, and so on.
+ *
+ * Returns the number of slots that were newly occupied. Overwriting an existing value contributes `0`.
+ *
+ * @see https://upstash.com/docs/redis/commands/array/arset
+ */
+declare class ArSetCommand<TData = string> extends Command<number, number> {
+    constructor(cmd: [key: string, index: number | string, ...values: TData[]], opts?: CommandOptions<number, number>);
+}
+
 /**
  * @see https://redis.io/commands/bitcount
  */
@@ -2320,6 +2792,70 @@ declare class UnlinkCommand extends Command<number, number> {
     constructor(cmd: [...keys: string[]], opts?: CommandOptions<number, number>);
 }
 
+/**
+ * Adds a vector to an index, or overwrites the vector stored under `id`.
+ *
+ * Returns `1` if a new vector was inserted, `0` if an existing one was overwritten.
+ */
+declare class VectorAddCommand extends Command<0 | 1, 0 | 1> {
+    constructor([index, id, vector]: [index: string, id: string, vector: VectorInput], cmdOpts?: CommandOptions<0 | 1, 0 | 1>);
+}
+
+/**
+ * Returns the number of vectors in the index. A missing index counts as `0`.
+ */
+declare class VectorCountCommand extends Command<number, number> {
+    constructor([index]: [index: string], cmdOpts?: CommandOptions<number, number>);
+}
+
+/**
+ * Creates a vector index.
+ *
+ * Returns `1` if the index was created, `0` if it already existed (only possible with `existsOk`).
+ */
+declare class VectorCreateCommand extends Command<0 | 1, 0 | 1> {
+    constructor([index, opts]: [index: string, opts: VectorCreateOptions], cmdOpts?: CommandOptions<0 | 1, 0 | 1>);
+}
+
+/**
+ * Deletes the vector stored under `id`.
+ *
+ * Returns `1` if the vector existed and was removed, `0` otherwise.
+ */
+declare class VectorDelCommand extends Command<0 | 1, 0 | 1> {
+    constructor([index, id]: [index: string, id: string], cmdOpts?: CommandOptions<0 | 1, 0 | 1>);
+}
+
+/**
+ * Drops the index and all vectors in it.
+ *
+ * Returns `1` if the index existed and was dropped, `0` otherwise.
+ */
+declare class VectorDropCommand extends Command<0 | 1, 0 | 1> {
+    constructor([index]: [index: string], cmdOpts?: CommandOptions<0 | 1, 0 | 1>);
+}
+
+/**
+ * Returns the vector stored under `id`, or `null` if it does not exist.
+ */
+declare class VectorGetCommand extends Command<(string | number)[] | null, number[] | null> {
+    constructor([index, id]: [index: string, id: string], cmdOpts?: CommandOptions<(string | number)[] | null, number[] | null>);
+}
+
+/**
+ * Returns the dimension and metric of the index, or `null` if it does not exist.
+ */
+declare class VectorInfoCommand extends Command<(string | number)[] | Record<string, string | number> | null, VectorIndexInfo | null> {
+    constructor([index]: [index: string], cmdOpts?: CommandOptions<(string | number)[] | Record<string, string | number> | null, VectorIndexInfo | null>);
+}
+
+/**
+ * Returns the `topK` nearest neighbours of the query vector as `{ id, score }` pairs.
+ */
+declare class VectorQueryCommand extends Command<[string, string | number][], VectorQueryResult[]> {
+    constructor([index, opts]: [index: string, opts: VectorQueryOptions], cmdOpts?: CommandOptions<[string, string | number][], VectorQueryResult[]>);
+}
+
 /**
  * @see https://redis.io/commands/xack
  */
@@ -2979,6 +3515,78 @@ declare class Pipeline<TCommands extends Command<any, any>[] = []> {
      * @see https://redis.io/commands/append
      */
     append: (...args: CommandArgs<typeof AppendCommand>) => Pipeline<[...TCommands, Command<any, number>]>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/arcount
+     */
+    arcount: (...args: CommandArgs<typeof ArCountCommand>) => Pipeline<[...TCommands, Command<any, number>]>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/ardel
+     */
+    ardel: (...args: CommandArgs<typeof ArDelCommand>) => Pipeline<[...TCommands, Command<any, number>]>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/ardelrange
+     */
+    ardelrange: (...args: CommandArgs<typeof ArDelRangeCommand>) => Pipeline<[...TCommands, Command<any, number>]>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/arget
+     */
+    arget: <TData = string>(...args: CommandArgs<typeof ArGetCommand>) => Pipeline<[...TCommands, Command<any, TData | null>]>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/argetrange
+     */
+    argetrange: <TData = string>(...args: CommandArgs<typeof ArGetRangeCommand>) => Pipeline<[...TCommands, Command<any, (TData | null)[]>]>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/argrep
+     */
+    argrep: <TData = string, TOpts extends ArGrepOptions = ArGrepOptions>(key: string, start: number | string, end: number | string, opts: TOpts) => Pipeline<[...TCommands, Command<any, ArGrepResult<TData, TOpts>>]>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/arinfo
+     */
+    arinfo: (...args: CommandArgs<typeof ArInfoCommand>) => Pipeline<[...TCommands, Command<any, ArInfoResult>]>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/arinsert
+     */
+    arinsert: <TData>(key: string, ...values: TData[]) => Pipeline<[...TCommands, Command<any, string>]>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/arlastitems
+     */
+    arlastitems: <TData = string>(...args: CommandArgs<typeof ArLastItemsCommand>) => Pipeline<[...TCommands, Command<any, (TData | null)[]>]>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/arlen
+     */
+    arlen: (...args: CommandArgs<typeof ArLenCommand>) => Pipeline<[...TCommands, Command<any, string>]>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/armget
+     */
+    armget: <TData = string>(...args: CommandArgs<typeof ArMGetCommand>) => Pipeline<[...TCommands, Command<any, (TData | null)[]>]>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/armset
+     */
+    armset: <TData>(key: string, values: ArMSetValues<TData>) => Pipeline<[...TCommands, Command<any, number>]>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/arnext
+     */
+    arnext: (...args: CommandArgs<typeof ArNextCommand>) => Pipeline<[...TCommands, Command<any, string | null>]>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/arop
+     */
+    arop: <TData = string>(key: string, start: number | string, end: number | string, operation: ArOpOperation<TData>) => Pipeline<[...TCommands, Command<any, number | null>]>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/arring
+     */
+    arring: <TData>(key: string, size: number, ...values: TData[]) => Pipeline<[...TCommands, Command<any, string>]>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/arscan
+     */
+    arscan: <TData = string>(...args: CommandArgs<typeof ArScanCommand>) => Pipeline<[...TCommands, Command<any, [string, TData][]>]>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/arseek
+     */
+    arseek: (...args: CommandArgs<typeof ArSeekCommand>) => Pipeline<[...TCommands, Command<any, 0 | 1>]>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/arset
+     */
+    arset: <TData>(key: string, index: number | string, ...values: TData[]) => Pipeline<[...TCommands, Command<any, number>]>;
     /**
      * @see https://redis.io/commands/bitcount
      */
@@ -4149,6 +4757,26 @@ declare class Redis {
             }) => Promise<0 | 1>;
         };
     };
+    /**
+     * Vector index commands.
+     *
+     * @example
+     * ```typescript
+     * const index = await redis.vector.createIndex({ name: "docs", dimension: 3, metric: "COSINE" });
+     * await index.add("doc-1", [0.1, 0.2, 0.3]);
+     * const hits = await index.query({ vector: [0.1, 0.2, 0.3], topK: 5 });
+     * ```
+     */
+    get vector(): {
+        /**
+         * Creates a vector index and returns a handle to it.
+         */
+        createIndex: (params: CreateVectorIndexParameters) => Promise<VectorIndex>;
+        /**
+         * Returns a handle to an existing vector index without sending any command.
+         */
+        index: (name: string) => VectorIndex;
+    };
     /**
      * Create a new pipeline that allows you to send requests in bulk.
      *
@@ -4186,6 +4814,78 @@ declare class Redis {
      * @see https://redis.io/commands/append
      */
     append: (...args: CommandArgs<typeof AppendCommand>) => Promise<number>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/arcount
+     */
+    arcount: (...args: CommandArgs<typeof ArCountCommand>) => Promise<number>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/ardel
+     */
+    ardel: (...args: CommandArgs<typeof ArDelCommand>) => Promise<number>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/ardelrange
+     */
+    ardelrange: (...args: CommandArgs<typeof ArDelRangeCommand>) => Promise<number>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/arget
+     */
+    arget: <TData = string>(...args: CommandArgs<typeof ArGetCommand>) => Promise<TData | null>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/argetrange
+     */
+    argetrange: <TData = string>(...args: CommandArgs<typeof ArGetRangeCommand>) => Promise<(TData | null)[]>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/argrep
+     */
+    argrep: <TData = string, TOpts extends ArGrepOptions = ArGrepOptions>(key: string, start: number | string, end: number | string, opts: TOpts) => Promise<ArGrepResult<TData, TOpts>>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/arinfo
+     */
+    arinfo: (...args: CommandArgs<typeof ArInfoCommand>) => Promise<ArInfoResult>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/arinsert
+     */
+    arinsert: <TData>(key: string, ...values: TData[]) => Promise<string>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/arlastitems
+     */
+    arlastitems: <TData = string>(...args: CommandArgs<typeof ArLastItemsCommand>) => Promise<(TData | null)[]>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/arlen
+     */
+    arlen: (...args: CommandArgs<typeof ArLenCommand>) => Promise<string>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/armget
+     */
+    armget: <TData = string>(...args: CommandArgs<typeof ArMGetCommand>) => Promise<(TData | null)[]>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/armset
+     */
+    armset: <TData>(key: string, values: ArMSetValues<TData>) => Promise<number>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/arnext
+     */
+    arnext: (...args: CommandArgs<typeof ArNextCommand>) => Promise<string | null>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/arop
+     */
+    arop: <TData = string>(key: string, start: number | string, end: number | string, operation: ArOpOperation<TData>) => Promise<number | null>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/arring
+     */
+    arring: <TData>(key: string, size: number, ...values: TData[]) => Promise<string>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/arscan
+     */
+    arscan: <TData = string>(...args: CommandArgs<typeof ArScanCommand>) => Promise<[string, TData][]>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/arseek
+     */
+    arseek: (...args: CommandArgs<typeof ArSeekCommand>) => Promise<0 | 1>;
+    /**
+     * @see https://upstash.com/docs/redis/commands/array/arset
+     */
+    arset: <TData>(key: string, index: number | string, ...values: TData[]) => Promise<number>;
     /**
      * @see https://redis.io/commands/bitcount
      */
@@ -4908,4 +5608,4 @@ declare namespace error {
   export { error_UpstashError as UpstashError, error_UpstashJSONParseError as UpstashJSONParseError, error_UrlError as UrlError };
 }
 
-export { HMGetCommand as $, AppendCommand as A, BitCountCommand as B, type ClientSetInfoAttribute as C, DBSizeCommand as D, EchoCommand as E, FlushAllCommand as F, GeoAddCommand as G, type HttpClientConfig as H, GetCommand as I, GetDelCommand as J, GetExCommand as K, GetRangeCommand as L, GetSetCommand as M, HDelCommand as N, HExistsCommand as O, HExpireAtCommand as P, HExpireCommand as Q, Redis as R, HExpireTimeCommand as S, HGetAllCommand as T, HGetCommand as U, HGetDelCommand as V, HGetExCommand as W, HIncrByCommand as X, HIncrByFloatCommand as Y, HKeysCommand as Z, HLenCommand as _, type RedisOptions as a, RPushCommand as a$, HMSetCommand as a0, HPExpireAtCommand as a1, HPExpireCommand as a2, HPExpireTimeCommand as a3, HPTtlCommand as a4, HPersistCommand as a5, HRandFieldCommand as a6, HScanCommand as a7, HSetCommand as a8, HSetExCommand as a9, JsonStrLenCommand as aA, JsonToggleCommand as aB, JsonTypeCommand as aC, KeysCommand as aD, LIndexCommand as aE, LInsertCommand as aF, LLenCommand as aG, LMoveCommand as aH, LPopCommand as aI, LPushCommand as aJ, LPushXCommand as aK, LRangeCommand as aL, LRemCommand as aM, LSetCommand as aN, LTrimCommand as aO, MGetCommand as aP, MSetCommand as aQ, MSetNXCommand as aR, PExpireAtCommand as aS, PExpireCommand as aT, PSetEXCommand as aU, PTtlCommand as aV, PersistCommand as aW, PingCommand as aX, Pipeline as aY, PublishCommand as aZ, RPopCommand as a_, HSetNXCommand as aa, HStrLenCommand as ab, HTtlCommand as ac, HValsCommand as ad, IncrByCommand as ae, IncrByFloatCommand as af, IncrCommand as ag, JsonArrAppendCommand as ah, JsonArrIndexCommand as ai, JsonArrInsertCommand as aj, JsonArrLenCommand as ak, JsonArrPopCommand as al, JsonArrTrimCommand as am, JsonClearCommand as an, JsonDelCommand as ao, JsonForgetCommand as ap, JsonGetCommand as aq, JsonMGetCommand as ar, JsonMergeCommand as as, JsonNumIncrByCommand as at, JsonNumMultByCommand as au, JsonObjKeysCommand as av, JsonObjLenCommand as aw, JsonRespCommand as ax, JsonSetCommand as ay, JsonStrAppendCommand as az, type RequesterConfig as b, ZRemRangeByLexCommand as b$, RPushXCommand as b0, RandomKeyCommand as b1, RenameCommand as b2, RenameNXCommand as b3, type Requester as b4, SAddCommand as b5, SCardCommand as b6, SDiffCommand as b7, SDiffStoreCommand as b8, SInterCardCommand as b9, TouchCommand as bA, TtlCommand as bB, type Type as bC, TypeCommand as bD, UnlinkCommand as bE, type UpstashRequest as bF, type UpstashResponse as bG, XAckDelCommand as bH, XAddCommand as bI, XDelExCommand as bJ, XRangeCommand as bK, ZAddCommand as bL, type ZAddCommandOptions as bM, ZCardCommand as bN, ZCountCommand as bO, ZDiffStoreCommand as bP, ZIncrByCommand as bQ, ZInterStoreCommand as bR, type ZInterStoreCommandOptions as bS, ZLexCountCommand as bT, ZMScoreCommand as bU, ZPopMaxCommand as bV, ZPopMinCommand as bW, ZRangeCommand as bX, type ZRangeCommandOptions as bY, ZRankCommand as bZ, ZRemCommand as b_, SInterCommand as ba, SInterStoreCommand as bb, SIsMemberCommand as bc, SMIsMemberCommand as bd, SMembersCommand as be, SMoveCommand as bf, SPopCommand as bg, SRandMemberCommand as bh, SRemCommand as bi, SScanCommand as bj, SUnionCommand as bk, SUnionStoreCommand as bl, ScanCommand as bm, type ScanCommandOptions as bn, type ScoreMember as bo, ScriptExistsCommand as bp, ScriptFlushCommand as bq, ScriptLoadCommand as br, SetBitCommand as bs, SetCommand as bt, type SetCommandOptions as bu, SetExCommand as bv, SetNxCommand as bw, SetRangeCommand as bx, StrLenCommand as by, TimeCommand as bz, BitOpCommand as c, ZRemRangeByRankCommand as c0, ZRemRangeByScoreCommand as c1, ZRevRankCommand as c2, ZScanCommand as c3, ZScoreCommand as c4, ZUnionCommand as c5, type ZUnionCommandOptions as c6, ZUnionStoreCommand as c7, type ZUnionStoreCommandOptions as c8, error as c9, type NumericField as ca, type NestedIndexSchema as cb, type CreateIndexParameters as cc, type FlatIndexSchema as cd, type InferFilterFromSchema as ce, type PublicQueryResult as cf, SearchIndex as cg, type SearchIndexParameters as ch, BitPosCommand as d, ClientSetInfoCommand as e, CopyCommand as f, DecrByCommand as g, DecrCommand as h, DelCommand as i, EvalCommand as j, EvalROCommand as k, EvalshaCommand as l, EvalshaROCommand as m, ExistsCommand as n, ExpireAtCommand as o, ExpireCommand as p, type ExpireOption as q, FlushDBCommand as r, type GeoAddCommandOptions as s, GeoDistCommand as t, GeoHashCommand as u, type GeoMember as v, GeoPosCommand as w, GeoSearchCommand as x, GeoSearchStoreCommand as y, GetBitCommand as z };
+export { GeoAddCommand as $, AppendCommand as A, type ArScanOptions as B, ArSeekCommand as C, ArSetCommand as D, BitCountCommand as E, BitOpCommand as F, BitPosCommand as G, type HttpClientConfig as H, type ClientSetInfoAttribute as I, ClientSetInfoCommand as J, CopyCommand as K, DBSizeCommand as L, DecrByCommand as M, DecrCommand as N, DelCommand as O, EchoCommand as P, EvalCommand as Q, Redis as R, EvalROCommand as S, EvalshaCommand as T, EvalshaROCommand as U, ExistsCommand as V, ExpireAtCommand as W, ExpireCommand as X, type ExpireOption as Y, FlushAllCommand as Z, FlushDBCommand as _, type RedisOptions as a, JsonStrLenCommand as a$, type GeoAddCommandOptions as a0, GeoDistCommand as a1, GeoHashCommand as a2, type GeoMember as a3, GeoPosCommand as a4, GeoSearchCommand as a5, GeoSearchStoreCommand as a6, GetBitCommand as a7, GetCommand as a8, GetDelCommand as a9, HSetExCommand as aA, HSetNXCommand as aB, HStrLenCommand as aC, HTtlCommand as aD, HValsCommand as aE, IncrByCommand as aF, IncrByFloatCommand as aG, IncrCommand as aH, JsonArrAppendCommand as aI, JsonArrIndexCommand as aJ, JsonArrInsertCommand as aK, JsonArrLenCommand as aL, JsonArrPopCommand as aM, JsonArrTrimCommand as aN, JsonClearCommand as aO, JsonDelCommand as aP, JsonForgetCommand as aQ, JsonGetCommand as aR, JsonMGetCommand as aS, JsonMergeCommand as aT, JsonNumIncrByCommand as aU, JsonNumMultByCommand as aV, JsonObjKeysCommand as aW, JsonObjLenCommand as aX, JsonRespCommand as aY, JsonSetCommand as aZ, JsonStrAppendCommand as a_, GetExCommand as aa, GetRangeCommand as ab, GetSetCommand as ac, HDelCommand as ad, HExistsCommand as ae, HExpireAtCommand as af, HExpireCommand as ag, HExpireTimeCommand as ah, HGetAllCommand as ai, HGetCommand as aj, HGetDelCommand as ak, HGetExCommand as al, HIncrByCommand as am, HIncrByFloatCommand as an, HKeysCommand as ao, HLenCommand as ap, HMGetCommand as aq, HMSetCommand as ar, HPExpireAtCommand as as, HPExpireCommand as at, HPExpireTimeCommand as au, HPTtlCommand as av, HPersistCommand as aw, HRandFieldCommand as ax, HScanCommand as ay, HSetCommand as az, type RequesterConfig as b, TouchCommand as b$, JsonToggleCommand as b0, JsonTypeCommand as b1, KeysCommand as b2, LIndexCommand as b3, LInsertCommand as b4, LLenCommand as b5, LMoveCommand as b6, LPopCommand as b7, LPushCommand as b8, LPushXCommand as b9, SInterCardCommand as bA, SInterCommand as bB, SInterStoreCommand as bC, SIsMemberCommand as bD, SMIsMemberCommand as bE, SMembersCommand as bF, SMoveCommand as bG, SPopCommand as bH, SRandMemberCommand as bI, SRemCommand as bJ, SScanCommand as bK, SUnionCommand as bL, SUnionStoreCommand as bM, ScanCommand as bN, type ScanCommandOptions as bO, type ScoreMember as bP, ScriptExistsCommand as bQ, ScriptFlushCommand as bR, ScriptLoadCommand as bS, SetBitCommand as bT, SetCommand as bU, type SetCommandOptions as bV, SetExCommand as bW, SetNxCommand as bX, SetRangeCommand as bY, StrLenCommand as bZ, TimeCommand as b_, LRangeCommand as ba, LRemCommand as bb, LSetCommand as bc, LTrimCommand as bd, MGetCommand as be, MSetCommand as bf, MSetNXCommand as bg, PExpireAtCommand as bh, PExpireCommand as bi, PSetEXCommand as bj, PTtlCommand as bk, PersistCommand as bl, PingCommand as bm, Pipeline as bn, PublishCommand as bo, RPopCommand as bp, RPushCommand as bq, RPushXCommand as br, RandomKeyCommand as bs, RenameCommand as bt, RenameNXCommand as bu, type Requester as bv, SAddCommand as bw, SCardCommand as bx, SDiffCommand as by, SDiffStoreCommand as bz, ArCountCommand as c, TtlCommand as c0, type Type as c1, TypeCommand as c2, UnlinkCommand as c3, type UpstashRequest as c4, type UpstashResponse as c5, VectorAddCommand as c6, VectorCountCommand as c7, VectorCreateCommand as c8, VectorDelCommand as c9, ZRemRangeByScoreCommand as cA, ZRevRankCommand as cB, ZScanCommand as cC, ZScoreCommand as cD, ZUnionCommand as cE, type ZUnionCommandOptions as cF, ZUnionStoreCommand as cG, type ZUnionStoreCommandOptions as cH, error as cI, type NumericField as cJ, type NestedIndexSchema as cK, type CreateIndexParameters as cL, type CreateVectorIndexParameters as cM, type FlatIndexSchema as cN, type InferFilterFromSchema as cO, type PublicQueryResult as cP, SearchIndex as cQ, type SearchIndexParameters as cR, type VectorCreateOptions as cS, VectorIndex as cT, type VectorIndexInfo as cU, type VectorIndexParameters as cV, type VectorInput as cW, type VectorMetric as cX, type VectorQueryOptions as cY, type VectorQueryProfile as cZ, type VectorQueryResult as c_, VectorDropCommand as ca, VectorGetCommand as cb, VectorInfoCommand as cc, VectorQueryCommand as cd, XAckDelCommand as ce, XAddCommand as cf, XDelExCommand as cg, XRangeCommand as ch, ZAddCommand as ci, type ZAddCommandOptions as cj, ZCardCommand as ck, ZCountCommand as cl, ZDiffStoreCommand as cm, ZIncrByCommand as cn, ZInterStoreCommand as co, type ZInterStoreCommandOptions as cp, ZLexCountCommand as cq, ZMScoreCommand as cr, ZPopMaxCommand as cs, ZPopMinCommand as ct, ZRangeCommand as cu, type ZRangeCommandOptions as cv, ZRankCommand as cw, ZRemCommand as cx, ZRemRangeByLexCommand as cy, ZRemRangeByRankCommand as cz, ArDelCommand as d, ArDelRangeCommand as e, ArGetCommand as f, ArGetRangeCommand as g, ArGrepCommand as h, type ArGrepOptions as i, type ArGrepPredicate as j, type ArGrepResult as k, ArInfoCommand as l, type ArInfoOptions as m, type ArInfoResult as n, ArInsertCommand as o, ArLastItemsCommand as p, type ArLastItemsOptions as q, ArLenCommand as r, ArMGetCommand as s, ArMSetCommand as t, type ArMSetValues as u, ArNextCommand as v, ArOpCommand as w, type ArOpOperation as x, ArRingCommand as y, ArScanCommand as z };