@upstash/redis 1.36.0 → 1.37.0-rc

package/{zmscore-0SAuWM0q.d.mts → zmscore-BpOSd5F5.d.mts}

@@ -317,39 +317,350 @@ declare class ExpireCommand extends Command<"0" | "1", 0 | 1> {
     constructor(cmd: [key: string, seconds: number, option?: ExpireOption], opts?: CommandOptions<"0" | "1", 0 | 1>);
 }
 
-type FunctionListArgs = {
-    /**
-     * Pattern for matching library names. Supports glob patterns.
-     *
-     * Example: "my_library_*"
-     */
-    libraryName?: string;
-    /**
-     * Includes the library source code in the response.
-     *
-     * @default false
-     */
-    withCode?: boolean;
+declare const FIELD_TYPES: readonly ["TEXT", "U64", "I64", "F64", "BOOL", "DATE"];
+type FieldType = (typeof FIELD_TYPES)[number];
+type TextField = {
+    type: "TEXT";
+    noTokenize?: boolean;
+    noStem?: boolean;
+    from?: string;
 };
-
-type FunctionLoadArgs = {
-    /**
-     * The Lua code to load.
-     *
-     * Example:
-     * ```lua
-     * #!lua name=mylib
-     * redis.register_function('myfunc', function() return 'ok' end)
-     * ```
-     */
-    code: string;
-    /**
-     * If true, the library will replace the existing library with the same name.
-     *
-     * @default false
-     */
-    replace?: boolean;
+type NumericField = {
+    type: "U64" | "I64" | "F64";
+    fast: true;
+    from?: string;
+};
+type BoolField = {
+    type: "BOOL";
+    fast?: boolean;
+    from?: string;
+};
+type DateField = {
+    type: "DATE";
+    fast?: boolean;
+    from?: string;
+};
+type DetailedField = TextField | NumericField | BoolField | DateField;
+type NestedIndexSchema = {
+    [key: string]: FieldType | DetailedField | NestedIndexSchema;
+};
+type FlatIndexSchema = {
+    [key: string]: FieldType | DetailedField;
+};
+type SchemaPaths<T, Prefix extends string = ""> = {
+    [K in keyof T]: K extends string ? T[K] extends FieldType | DetailedField ? Prefix extends "" ? K : `${Prefix}${K}` : T[K] extends object ? SchemaPaths<T[K], `${Prefix}${K}.`> : never : never;
+}[keyof T];
+type ExtractFieldType<T> = T extends FieldType ? T : T extends {
+    type: infer U;
+} ? U extends FieldType ? U : never : never;
+type GetFieldAtPath<TSchema, Path extends string> = Path extends `${infer First}.${infer Rest}` ? First extends keyof TSchema ? GetFieldAtPath<TSchema[First], Rest> : never : Path extends keyof TSchema ? TSchema[Path] : never;
+type FieldValueType<T extends FieldType> = T extends "TEXT" ? string : T extends "U64" | "I64" | "F64" ? number : T extends "BOOL" ? boolean : T extends "DATE" ? string : never;
+type GetFieldValueType<TSchema, Path extends string> = GetFieldAtPath<TSchema, Path> extends infer Field ? Field extends FieldType | DetailedField ? FieldValueType<ExtractFieldType<Field>> : never : never;
+type HasFrom<T> = T extends {
+    from: string;
+} ? true : false;
+type InferSchemaData<TSchema> = {
+    [K in keyof TSchema as TSchema[K] extends DetailedField ? HasFrom<TSchema[K]> extends true ? never : K : K]: TSchema[K] extends FieldType ? FieldValueType<TSchema[K]> : TSchema[K] extends DetailedField ? FieldValueType<ExtractFieldType<TSchema[K]>> : TSchema[K] extends NestedIndexSchema ? InferSchemaData<TSchema[K]> : never;
+};
+type QueryOptions<TSchema extends NestedIndexSchema | FlatIndexSchema> = {
+    filter?: RootQueryFilter<TSchema>;
+    /** Maximum number of results to return */
+    limit?: number;
+    /** Number of results to skip */
+    offset?: number;
+    /** Sort by field (requires FAST option on field) */
+    orderBy?: {
+        [K in SchemaPaths<TSchema>]: {
+            [P in K]: "ASC" | "DESC";
+        };
+    }[SchemaPaths<TSchema>];
+    select?: Partial<{
+        [K in SchemaPaths<TSchema>]: true;
+    }>;
+    highlight?: {
+        fields: SchemaPaths<TSchema>[];
+        preTag?: string;
+        postTag?: string;
+    };
+};
+/**
+ * Converts dot notation paths to nested object structure type
+ * e.g. "content.title" | "content.author" becomes { content: { title: ..., author: ... } }
+ */
+type PathToNestedObject<TSchema, Path extends string, Value> = Path extends `${infer First}.${infer Rest}` ? {
+    [K in First]: PathToNestedObject<TSchema, Rest, Value>;
+} : {
+    [K in Path]: Value;
+};
+/**
+ * Merges intersection of objects into a single object type with proper nesting
+ */
+type DeepMerge<T> = T extends object ? {
+    [K in keyof T]: T[K] extends object ? DeepMerge<T[K]> : T[K];
+} : T;
+/**
+ * Build nested result type from selected paths
+ */
+type BuildNestedResult<TSchema, TFields> = DeepMerge<UnionToIntersection<{
+    [Path in keyof TFields & SchemaPaths<TSchema>]: PathToNestedObject<TSchema, Path & string, GetFieldValueType<TSchema, Path & string>>;
+}[keyof TFields & SchemaPaths<TSchema>]>>;
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type QueryResult<TSchema extends NestedIndexSchema | FlatIndexSchema, TOptions extends QueryOptions<TSchema> | undefined = undefined> = TOptions extends {
+    select: infer TFields;
+} ? {} extends TFields ? {
+    key: string;
+    score: string;
+} : {
+    key: string;
+    score: string;
+    data: BuildNestedResult<TSchema, TFields>;
+} : {
+    key: string;
+    score: string;
+    data: InferSchemaData<TSchema>;
+};
+type StringOperationMap<T extends string> = {
+    $eq: T;
+    $ne: T;
+    $in: T[];
+    $fuzzy: T | {
+        value: T;
+        distance?: number;
+        transpositionCostOne?: boolean;
+    };
+    $phrase: T | {
+        value: T;
+    } | {
+        value: T;
+        slop: number;
+        prefix?: never;
+    } | {
+        value: T;
+        prefix: boolean;
+        slop?: never;
+    };
+    $regex: T;
+};
+type NumberOperationMap<T extends number> = {
+    $eq: T;
+    $ne: T;
+    $in: T[];
+    $gt: T;
+    $gte: T;
+    $lt: T;
+    $lte: T;
+};
+type BooleanOperationMap<T extends boolean> = {
+    $eq: T;
+    $ne: T;
+    $in: T[];
+};
+type DateOperationMap<T extends string | Date> = {
+    $eq: T;
+    $ne: T;
+    $in: T[];
+    $gt: T;
+    $gte: T;
+    $lte: T;
+    $lt: T;
+};
+type StringOperations = {
+    [K in keyof StringOperationMap<string>]: {
+        [P in K]: StringOperationMap<string>[K];
+    } & {
+        $boost?: number;
+    };
+}[keyof StringOperationMap<string>];
+type NumberOperations = {
+    [K in keyof NumberOperationMap<number>]: {
+        [P in K]: NumberOperationMap<number>[K];
+    } & {
+        $boost?: number;
+    };
+}[keyof NumberOperationMap<number>];
+type BooleanOperations = {
+    [K in keyof BooleanOperationMap<boolean>]: {
+        [P in K]: BooleanOperationMap<boolean>[K];
+    } & {
+        $boost?: number;
+    };
+}[keyof BooleanOperationMap<boolean>];
+type DateOperations = {
+    [K in keyof DateOperationMap<string | Date>]: {
+        [P in K]: DateOperationMap<string | Date>[K];
+    } & {
+        $boost?: number;
+    };
+}[keyof DateOperationMap<string | Date>];
+type OperationsForFieldType<T extends FieldType> = T extends "TEXT" ? StringOperations : T extends "U64" | "I64" | "F64" ? NumberOperations : T extends "BOOL" ? BooleanOperations : T extends "DATE" ? DateOperations : never;
+type PathOperations<TSchema, TPath extends string> = GetFieldAtPath<TSchema, TPath> extends infer Field ? Field extends FieldType | DetailedField ? OperationsForFieldType<ExtractFieldType<Field>> | FieldValueType<ExtractFieldType<Field>> : never : never;
+type QueryLeaf<TSchema> = {
+    [K in SchemaPaths<TSchema>]?: PathOperations<TSchema, K>;
+} & {
+    $and?: never;
+    $or?: never;
+    $must?: never;
+    $should?: never;
+    $mustNot?: never;
+    $boost?: never;
+};
+type BoolBase<TSchema extends NestedIndexSchema | FlatIndexSchema> = {
+    [P in SchemaPaths<TSchema>]?: PathOperations<TSchema, P>;
+};
+type AndNode<TSchema extends NestedIndexSchema | FlatIndexSchema> = BoolBase<TSchema> & {
+    $and: QueryFilter<TSchema> | QueryFilter<TSchema>[];
+    $boost?: number;
+    $or?: never;
+    $must?: never;
+    $should?: never;
+    $mustNot?: never;
+};
+type OrNode<TSchema extends NestedIndexSchema | FlatIndexSchema> = BoolBase<TSchema> & {
+    $or: QueryFilter<TSchema> | QueryFilter<TSchema>[];
+    $boost?: number;
+    $and?: never;
+    $must?: never;
+    $should?: never;
+    $mustNot?: never;
 };
+type MustNode<TSchema extends NestedIndexSchema | FlatIndexSchema> = BoolBase<TSchema> & {
+    $must: QueryFilter<TSchema> | QueryFilter<TSchema>[];
+    $boost?: number;
+    $and?: never;
+    $or?: never;
+    $should?: never;
+    $mustNot?: never;
+};
+type ShouldNode<TSchema extends NestedIndexSchema | FlatIndexSchema> = BoolBase<TSchema> & {
+    $should: QueryFilter<TSchema> | QueryFilter<TSchema>[];
+    $boost?: number;
+    $and?: never;
+    $or?: never;
+    $must?: never;
+    $mustNot?: never;
+};
+type MustShouldNode<TSchema extends NestedIndexSchema | FlatIndexSchema> = BoolBase<TSchema> & {
+    $must: QueryFilter<TSchema> | QueryFilter<TSchema>[];
+    $should: QueryFilter<TSchema> | QueryFilter<TSchema>[];
+    $and?: never;
+    $or?: never;
+};
+type NotNode<TSchema extends NestedIndexSchema | FlatIndexSchema> = BoolBase<TSchema> & {
+    $mustNot: QueryFilter<TSchema> | QueryFilter<TSchema>[];
+    $boost?: number;
+    $and?: never;
+    $or?: never;
+    $must?: never;
+    $should?: never;
+};
+type AndNotNode<TSchema extends NestedIndexSchema | FlatIndexSchema> = BoolBase<TSchema> & {
+    $and: QueryFilter<TSchema> | QueryFilter<TSchema>[];
+    $mustNot: QueryFilter<TSchema> | QueryFilter<TSchema>[];
+    $boost?: number;
+    $or?: never;
+    $must?: never;
+    $should?: never;
+};
+type OrNotNode<TSchema extends NestedIndexSchema | FlatIndexSchema> = BoolBase<TSchema> & {
+    $or: QueryFilter<TSchema> | QueryFilter<TSchema>[];
+    $mustNot: QueryFilter<TSchema> | QueryFilter<TSchema>[];
+    $boost?: number;
+    $and?: never;
+    $must?: never;
+    $should?: never;
+};
+type ShouldNotNode<TSchema extends NestedIndexSchema | FlatIndexSchema> = BoolBase<TSchema> & {
+    $should: QueryFilter<TSchema> | QueryFilter<TSchema>[];
+    $mustNot: QueryFilter<TSchema> | QueryFilter<TSchema>[];
+    $boost?: number;
+    $and?: never;
+    $or?: never;
+    $must?: never;
+};
+type MustNotNode<TSchema extends NestedIndexSchema | FlatIndexSchema> = BoolBase<TSchema> & {
+    $must: QueryFilter<TSchema> | QueryFilter<TSchema>[];
+    $mustNot: QueryFilter<TSchema> | QueryFilter<TSchema>[];
+    $boost?: number;
+    $and?: never;
+    $or?: never;
+    $should?: never;
+};
+type BoolNode<TSchema extends NestedIndexSchema | FlatIndexSchema> = BoolBase<TSchema> & {
+    $must: QueryFilter<TSchema> | QueryFilter<TSchema>[];
+    $should: QueryFilter<TSchema> | QueryFilter<TSchema>[];
+    $mustNot: QueryFilter<TSchema> | QueryFilter<TSchema>[];
+    $boost?: number;
+    $and?: never;
+    $or?: never;
+};
+type QueryFilter<TSchema extends NestedIndexSchema | FlatIndexSchema> = QueryLeaf<TSchema> | AndNode<TSchema> | OrNode<TSchema> | MustNode<TSchema> | ShouldNode<TSchema> | MustShouldNode<TSchema> | NotNode<TSchema> | AndNotNode<TSchema> | OrNotNode<TSchema> | ShouldNotNode<TSchema> | MustNotNode<TSchema> | BoolNode<TSchema>;
+type RootQueryFilter<TSchema extends NestedIndexSchema | FlatIndexSchema> = QueryLeaf<TSchema> | AndNode<TSchema> | RootOrNode<TSchema> | MustNode<TSchema> | ShouldNode<TSchema> | MustShouldNode<TSchema> | AndNotNode<TSchema> | ShouldNotNode<TSchema> | BoolNode<TSchema>;
+type RootOrNode<TSchema extends NestedIndexSchema | FlatIndexSchema> = {
+    [P in SchemaPaths<TSchema>]?: never;
+} & {
+    $or: QueryFilter<TSchema> | QueryFilter<TSchema>[];
+    $boost?: number;
+    $and?: never;
+    $must?: never;
+    $should?: never;
+    $mustNot?: never;
+};
+type DescribeFieldInfo = {
+    type: FieldType;
+    noTokenize?: boolean;
+    noStem?: boolean;
+    fast?: boolean;
+};
+type IndexDescription<TSchema extends NestedIndexSchema | FlatIndexSchema> = {
+    name: string;
+    dataType: "hash" | "string" | "json";
+    prefixes: string[];
+    language?: Language;
+    schema: Record<SchemaPaths<TSchema>, DescribeFieldInfo>;
+};
+type Language = "english" | "arabic" | "danish" | "dutch" | "finnish" | "french" | "german" | "greek" | "hungarian" | "italian" | "norwegian" | "portuguese" | "romanian" | "russian" | "spanish" | "swedish" | "tamil" | "turkish";
+
+type CreateIndexParameters<TSchema extends NestedIndexSchema | FlatIndexSchema> = {
+    name: string;
+    prefix: string | string[];
+    language?: Language;
+    skipInitialScan?: boolean;
+    existsOk?: boolean;
+} & ({
+    dataType: "string";
+    schema: TSchema extends NestedIndexSchema ? TSchema : never;
+} | {
+    dataType: "json";
+    schema: TSchema extends NestedIndexSchema ? TSchema : never;
+} | {
+    dataType: "hash";
+    schema: TSchema extends FlatIndexSchema ? TSchema : never;
+});
+type InitIndexParameters<TSchema extends NestedIndexSchema | FlatIndexSchema> = {
+    name: string;
+    schema?: TSchema;
+};
+type SearchIndexParameters<TSchema extends NestedIndexSchema | FlatIndexSchema> = {
+    name: string;
+    client: Requester;
+    schema?: TSchema;
+};
+declare class SearchIndex<TSchema extends NestedIndexSchema | FlatIndexSchema> {
+    readonly name: SearchIndexParameters<TSchema>["name"];
+    readonly schema?: TSchema;
+    private client;
+    constructor({ name, schema, client }: SearchIndexParameters<TSchema>);
+    waitIndexing(): Promise<void>;
+    describe(): Promise<IndexDescription<TSchema>>;
+    query(options?: QueryOptions<TSchema>): Promise<QueryResult<TSchema, QueryOptions<TSchema>>[]>;
+    count({ filter }: {
+        filter: RootQueryFilter<TSchema>;
+    }): Promise<{
+        count: number;
+    }>;
+    drop(): Promise<1 | 0>;
+}
+type InferFilterFromSchema<TSchema extends NestedIndexSchema | FlatIndexSchema> = NonNullable<NonNullable<Parameters<SearchIndex<TSchema>["query"]>[0]>["filter"]>;
 
 /**
  * @see https://redis.io/commands/append
@@ -2922,52 +3233,6 @@ declare class Pipeline<TCommands extends Command<any, any>[] = []> {
          */
         type: (key: string, path?: string | undefined) => Pipeline<[...TCommands, Command<any, string[]>]>;
     };
-    get functions(): {
-        /**
-         * @see https://redis.io/docs/latest/commands/function-load/
-         */
-        load: (args: FunctionLoadArgs) => Pipeline<[...TCommands, Command<any, string>]>;
-        /**
-         * @see https://redis.io/docs/latest/commands/function-list/
-         */
-        list: (args?: FunctionListArgs | undefined) => Pipeline<[...TCommands, Command<any, {
-            libraryName: string;
-            engine: string;
-            functions: {
-                name: string;
-                description?: string;
-                flags: string[];
-            }[];
-            libraryCode?: string;
-        }[]>]>;
-        /**
-         * @see https://redis.io/docs/latest/commands/function-delete/
-         */
-        delete: (libraryName: string) => Pipeline<[...TCommands, Command<any, "OK">]>;
-        /**
-         * @see https://redis.io/docs/latest/commands/function-flush/
-         */
-        flush: () => Pipeline<[...TCommands, Command<any, "OK">]>;
-        /**
-         * @see https://redis.io/docs/latest/commands/function-stats/
-         */
-        stats: () => Pipeline<[...TCommands, Command<any, {
-            engines: {
-                [k: string]: {
-                    librariesCount: unknown;
-                    functionsCount: unknown;
-                };
-            };
-        }>]>;
-        /**
-         * @see https://redis.io/docs/latest/commands/fcall/
-         */
-        call: <TData = unknown>(functionName: string, keys?: string[] | undefined, args?: string[] | undefined) => Pipeline<[...TCommands, Command<any, TData>]>;
-        /**
-         * @see https://redis.io/docs/latest/commands/fcall_ro/
-         */
-        callRo: <TData = unknown>(functionName: string, keys?: string[] | undefined, args?: string[] | undefined) => Pipeline<[...TCommands, Command<any, TData>]>;
-    };
 }
 
 /**
@@ -3195,54 +3460,6 @@ declare class Redis {
          */
         type: (key: string, path?: string | undefined) => Promise<string[]>;
     };
-    get functions(): {
-        /**
-         * @see https://redis.io/docs/latest/commands/function-load/
-         */
-        load: (args: FunctionLoadArgs) => Promise<string>;
-        /**
-         * @see https://redis.io/docs/latest/commands/function-list/
-         */
-        list: (args?: FunctionListArgs | undefined) => Promise<{
-            libraryName: string;
-            engine: string;
-            functions: {
-                name: string;
-                description?: string;
-                flags: string[];
-            }[];
-            libraryCode?: string;
-        }[]>;
-        /**
-         * @see https://redis.io/docs/latest/commands/function-delete/
-         */
-        delete: (libraryName: string) => Promise<"OK">;
-        /**
-         * @see https://redis.io/docs/latest/commands/function-flush/
-         */
-        flush: () => Promise<"OK">;
-        /**
-         * @see https://redis.io/docs/latest/commands/function-stats/
-         *
-         * Note: `running_script` field is not supported and therefore not included in the type.
-         */
-        stats: () => Promise<{
-            engines: {
-                [k: string]: {
-                    librariesCount: unknown;
-                    functionsCount: unknown;
-                };
-            };
-        }>;
-        /**
-         * @see https://redis.io/docs/latest/commands/fcall/
-         */
-        call: <TData = unknown>(functionName: string, keys?: string[] | undefined, args?: string[] | undefined) => Promise<TData>;
-        /**
-         * @see https://redis.io/docs/latest/commands/fcall_ro/
-         */
-        callRo: <TData = unknown>(functionName: string, keys?: string[] | undefined, args?: string[] | undefined) => Promise<TData>;
-    };
     /**
      * Wrap a new middleware around the HTTP client.
      */
@@ -3282,6 +3499,10 @@ declare class Redis {
     createScript<TResult = unknown, TReadonly extends boolean = false>(script: string, opts?: {
         readonly?: TReadonly;
     }): TReadonly extends true ? ScriptRO<TResult> : Script<TResult>;
+    get search(): {
+        createIndex: <TSchema extends NestedIndexSchema | FlatIndexSchema>(params: CreateIndexParameters<TSchema>) => Promise<SearchIndex<TSchema>>;
+        index: <TSchema extends NestedIndexSchema | FlatIndexSchema>(params: InitIndexParameters<TSchema>) => SearchIndex<TSchema>;
+    };
     /**
      * Create a new pipeline that allows you to send requests in bulk.
      *
@@ -4187,4 +4408,4 @@ declare class ZMScoreCommand<TData> extends Command<string[] | null, number[] |
     constructor(cmd: [key: string, members: TData[]], opts?: CommandOptions<string[] | null, number[] | null>);
 }
 
-export { HPersistCommand as $, AppendCommand as A, BitCountCommand as B, CopyCommand as C, DBSizeCommand as D, EchoCommand as E, FlushAllCommand as F, GeoAddCommand as G, type HttpClientConfig as H, GetCommand as I, GetBitCommand as J, GetDelCommand as K, GetExCommand as L, GetRangeCommand as M, GetSetCommand as N, HDelCommand as O, Pipeline as P, HExistsCommand as Q, type RedisOptions as R, HExpireCommand as S, HExpireAtCommand as T, type UpstashRequest as U, HExpireTimeCommand as V, HTtlCommand as W, HPExpireCommand as X, HPExpireAtCommand as Y, HPExpireTimeCommand as Z, HPTtlCommand as _, type RequesterConfig as a, RenameNXCommand as a$, HGetCommand as a0, HGetAllCommand as a1, HIncrByCommand as a2, HIncrByFloatCommand as a3, HKeysCommand as a4, HLenCommand as a5, HMGetCommand as a6, HMSetCommand as a7, HRandFieldCommand as a8, HScanCommand 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, PersistCommand as aS, PExpireCommand as aT, PExpireAtCommand as aU, PingCommand as aV, PSetEXCommand as aW, PTtlCommand as aX, PublishCommand as aY, RandomKeyCommand as aZ, RenameCommand as a_, HSetCommand as aa, HSetNXCommand as ab, HStrLenCommand as ac, HValsCommand as ad, IncrCommand as ae, IncrByCommand as af, IncrByFloatCommand 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, JsonMergeCommand as ar, JsonMGetCommand as as, JsonNumIncrByCommand as at, JsonNumMultByCommand as au, JsonObjKeysCommand as av, JsonObjLenCommand as aw, JsonRespCommand as ax, JsonSetCommand as ay, JsonStrAppendCommand as az, Redis as b, type ZUnionCommandOptions as b$, RPopCommand as b0, RPushCommand as b1, RPushXCommand as b2, SAddCommand as b3, ScanCommand as b4, type ScanCommandOptions as b5, SCardCommand as b6, ScriptExistsCommand as b7, ScriptFlushCommand as b8, ScriptLoadCommand as b9, UnlinkCommand as bA, XAddCommand as bB, XRangeCommand as bC, type ScoreMember as bD, type ZAddCommandOptions as bE, ZAddCommand as bF, ZCardCommand as bG, ZCountCommand as bH, ZDiffStoreCommand as bI, ZIncrByCommand as bJ, ZInterStoreCommand as bK, type ZInterStoreCommandOptions as bL, ZLexCountCommand as bM, ZMScoreCommand as bN, ZPopMaxCommand as bO, ZPopMinCommand as bP, ZRangeCommand as bQ, type ZRangeCommandOptions as bR, ZRankCommand as bS, ZRemCommand as bT, ZRemRangeByLexCommand as bU, ZRemRangeByRankCommand as bV, ZRemRangeByScoreCommand as bW, ZRevRankCommand as bX, ZScanCommand as bY, ZScoreCommand as bZ, ZUnionCommand as b_, SDiffCommand as ba, SDiffStoreCommand as bb, SetCommand as bc, type SetCommandOptions as bd, SetBitCommand as be, SetExCommand as bf, SetNxCommand as bg, SetRangeCommand as bh, SInterCommand as bi, SInterStoreCommand as bj, SIsMemberCommand as bk, SMembersCommand as bl, SMIsMemberCommand as bm, SMoveCommand as bn, SPopCommand as bo, SRandMemberCommand as bp, SRemCommand as bq, SScanCommand as br, StrLenCommand as bs, SUnionCommand as bt, SUnionStoreCommand as bu, TimeCommand as bv, TouchCommand as bw, TtlCommand as bx, type Type as by, TypeCommand as bz, type Requester as c, ZUnionStoreCommand as c0, type ZUnionStoreCommandOptions as c1, type UpstashResponse as d, error as e, BitOpCommand as f, BitPosCommand as g, DecrCommand as h, DecrByCommand as i, DelCommand as j, EvalROCommand as k, EvalCommand as l, EvalshaROCommand as m, EvalshaCommand as n, ExistsCommand as o, ExpireCommand as p, type ExpireOption as q, ExpireAtCommand as r, FlushDBCommand as s, type GeoAddCommandOptions as t, type GeoMember as u, GeoDistCommand as v, GeoHashCommand as w, GeoPosCommand as x, GeoSearchCommand as y, GeoSearchStoreCommand as z };
+export { HPExpireTimeCommand as $, AppendCommand as A, BitCountCommand as B, CopyCommand as C, DBSizeCommand as D, EchoCommand as E, FlushAllCommand as F, GeoAddCommand as G, type HttpClientConfig as H, GeoSearchStoreCommand as I, GetCommand as J, GetBitCommand as K, GetDelCommand as L, GetExCommand as M, type NumericField as N, GetRangeCommand as O, Pipeline as P, GetSetCommand as Q, type RedisOptions as R, HDelCommand as S, HExistsCommand as T, type UpstashRequest as U, HExpireCommand as V, HExpireAtCommand as W, HExpireTimeCommand as X, HTtlCommand as Y, HPExpireCommand as Z, HPExpireAtCommand as _, type NestedIndexSchema as a, RandomKeyCommand as a$, HPTtlCommand as a0, HPersistCommand as a1, HGetCommand as a2, HGetAllCommand as a3, HIncrByCommand as a4, HIncrByFloatCommand as a5, HKeysCommand as a6, HLenCommand as a7, HMGetCommand as a8, HMSetCommand as a9, JsonSetCommand as aA, JsonStrAppendCommand as aB, JsonStrLenCommand as aC, JsonToggleCommand as aD, JsonTypeCommand as aE, KeysCommand as aF, LIndexCommand as aG, LInsertCommand as aH, LLenCommand as aI, LMoveCommand as aJ, LPopCommand as aK, LPushCommand as aL, LPushXCommand as aM, LRangeCommand as aN, LRemCommand as aO, LSetCommand as aP, LTrimCommand as aQ, MGetCommand as aR, MSetCommand as aS, MSetNXCommand as aT, PersistCommand as aU, PExpireCommand as aV, PExpireAtCommand as aW, PingCommand as aX, PSetEXCommand as aY, PTtlCommand as aZ, PublishCommand as a_, HRandFieldCommand as aa, HScanCommand as ab, HSetCommand as ac, HSetNXCommand as ad, HStrLenCommand as ae, HValsCommand as af, IncrCommand as ag, IncrByCommand as ah, IncrByFloatCommand as ai, JsonArrAppendCommand as aj, JsonArrIndexCommand as ak, JsonArrInsertCommand as al, JsonArrLenCommand as am, JsonArrPopCommand as an, JsonArrTrimCommand as ao, JsonClearCommand as ap, JsonDelCommand as aq, JsonForgetCommand as ar, JsonGetCommand as as, JsonMergeCommand as at, JsonMGetCommand as au, JsonNumIncrByCommand as av, JsonNumMultByCommand as aw, JsonObjKeysCommand as ax, JsonObjLenCommand as ay, JsonRespCommand as az, type RequesterConfig as b, ZScoreCommand as b$, RenameCommand as b0, RenameNXCommand as b1, RPopCommand as b2, RPushCommand as b3, RPushXCommand as b4, SAddCommand as b5, ScanCommand as b6, type ScanCommandOptions as b7, SCardCommand as b8, ScriptExistsCommand as b9, type Type as bA, TypeCommand as bB, UnlinkCommand as bC, XAddCommand as bD, XRangeCommand as bE, type ScoreMember as bF, type ZAddCommandOptions as bG, ZAddCommand as bH, ZCardCommand as bI, ZCountCommand as bJ, ZDiffStoreCommand as bK, ZIncrByCommand as bL, ZInterStoreCommand as bM, type ZInterStoreCommandOptions as bN, ZLexCountCommand as bO, ZMScoreCommand as bP, ZPopMaxCommand as bQ, ZPopMinCommand as bR, ZRangeCommand as bS, type ZRangeCommandOptions as bT, ZRankCommand as bU, ZRemCommand as bV, ZRemRangeByLexCommand as bW, ZRemRangeByRankCommand as bX, ZRemRangeByScoreCommand as bY, ZRevRankCommand as bZ, ZScanCommand as b_, ScriptFlushCommand as ba, ScriptLoadCommand as bb, SDiffCommand as bc, SDiffStoreCommand as bd, SetCommand as be, type SetCommandOptions as bf, SetBitCommand as bg, SetExCommand as bh, SetNxCommand as bi, SetRangeCommand as bj, SInterCommand as bk, SInterStoreCommand as bl, SIsMemberCommand as bm, SMembersCommand as bn, SMIsMemberCommand as bo, SMoveCommand as bp, SPopCommand as bq, SRandMemberCommand as br, SRemCommand as bs, SScanCommand as bt, StrLenCommand as bu, SUnionCommand as bv, SUnionStoreCommand as bw, TimeCommand as bx, TouchCommand as by, TtlCommand as bz, Redis as c, ZUnionCommand as c0, type ZUnionCommandOptions as c1, ZUnionStoreCommand as c2, type ZUnionStoreCommandOptions as c3, type SearchIndexParameters as c4, type CreateIndexParameters as c5, type InferFilterFromSchema as c6, type FlatIndexSchema as c7, type Requester as d, error as e, type UpstashResponse as f, BitOpCommand as g, BitPosCommand as h, DecrCommand as i, DecrByCommand as j, DelCommand as k, EvalROCommand as l, EvalCommand as m, EvalshaROCommand as n, EvalshaCommand as o, ExistsCommand as p, ExpireCommand as q, type ExpireOption as r, ExpireAtCommand as s, FlushDBCommand as t, type GeoAddCommandOptions as u, type GeoMember as v, GeoDistCommand as w, GeoHashCommand as x, GeoPosCommand as y, GeoSearchCommand as z };