@devvit/protos 0.11.0-next-2024-07-24-e3a20f1a9.0 → 0.11.0-next-2024-07-25-e11c6b2a8.0

package/schema/.snootobuf/output/devenv_ts_files/devvit/plugin/redis/redisapi.ts

@@ -0,0 +1,3347 @@
+// @generated by protobuf-ts 2.9.3
+// @generated from protobuf file "devvit/plugin/redis/redisapi.proto" (package "devvit.plugin.redis", syntax proto3)
+// tslint:disable
+import { DoubleValue } from "../../../google/protobuf/wrappers";
+import { ServiceType } from "@protobuf-ts/runtime-rpc";
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import { WireType } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { Int64Value } from "../../../google/protobuf/wrappers";
+import { Empty } from "../../../google/protobuf/empty";
+import { StringValue } from "../../../google/protobuf/wrappers";
+/**
+ * @generated from protobuf message devvit.plugin.redis.TransactionResponses
+ */
+export interface TransactionResponses {
+    /**
+     * @generated from protobuf field: repeated devvit.plugin.redis.TransactionResponse response = 1;
+     */
+    response: TransactionResponse[];
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.TransactionResponse
+ */
+export interface TransactionResponse {
+    /**
+     * @generated from protobuf oneof: value
+     */
+    value: {
+        oneofKind: "str";
+        /**
+         * @generated from protobuf field: google.protobuf.StringValue str = 1;
+         */
+        str: StringValue;
+    } | {
+        oneofKind: "nil";
+        /**
+         * @generated from protobuf field: google.protobuf.Empty nil = 2;
+         */
+        nil: Empty;
+    } | {
+        oneofKind: "num";
+        /**
+         * @generated from protobuf field: google.protobuf.Int64Value num = 3;
+         */
+        num: Int64Value;
+    } | {
+        oneofKind: "members";
+        /**
+         * @generated from protobuf field: devvit.plugin.redis.ZMembers members = 4;
+         */
+        members: ZMembers;
+    } | {
+        oneofKind: "values";
+        /**
+         * @generated from protobuf field: devvit.plugin.redis.RedisValues values = 5;
+         */
+        values: RedisValues;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.ZRangeRequest
+ */
+export interface ZRangeRequest {
+    /**
+     * @generated from protobuf field: devvit.plugin.redis.KeyRequest key = 1;
+     */
+    key?: KeyRequest;
+    /**
+     * @generated from protobuf field: string start = 2;
+     */
+    start: string;
+    /**
+     * @generated from protobuf field: string stop = 3;
+     */
+    stop: string;
+    /**
+     * @generated from protobuf field: bool by_score = 4;
+     */
+    byScore: boolean;
+    /**
+     * @generated from protobuf field: bool by_lex = 5;
+     */
+    byLex: boolean;
+    /**
+     * @generated from protobuf field: bool rev = 6;
+     */
+    rev: boolean;
+    /**
+     * @generated from protobuf field: int32 offset = 7;
+     */
+    offset: number;
+    /**
+     * @generated from protobuf field: int32 count = 8;
+     */
+    count: number;
+    /**
+     * @generated from protobuf field: optional devvit.plugin.redis.RedisKeyScope scope = 100;
+     */
+    scope?: RedisKeyScope;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.ZRangeByLexRequest
+ */
+export interface ZRangeByLexRequest {
+    /**
+     * @generated from protobuf field: devvit.plugin.redis.KeyRequest key = 1;
+     */
+    key?: KeyRequest;
+    /**
+     * @generated from protobuf field: string min = 2;
+     */
+    min: string;
+    /**
+     * @generated from protobuf field: string max = 3;
+     */
+    max: string;
+    /**
+     * @generated from protobuf field: optional devvit.plugin.redis.RedisKeyScope scope = 100;
+     */
+    scope?: RedisKeyScope;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.ZRangeByScoreRequest
+ */
+export interface ZRangeByScoreRequest {
+    /**
+     * @generated from protobuf field: devvit.plugin.redis.KeyRequest key = 1;
+     */
+    key?: KeyRequest;
+    /**
+     * @generated from protobuf field: double min = 2;
+     */
+    min: number;
+    /**
+     * @generated from protobuf field: double max = 3;
+     */
+    max: number;
+    /**
+     * @generated from protobuf field: bool with_scores = 4;
+     */
+    withScores: boolean;
+    /**
+     * @generated from protobuf field: optional devvit.plugin.redis.RedisKeyScope scope = 100;
+     */
+    scope?: RedisKeyScope;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.ZRemRequest
+ */
+export interface ZRemRequest {
+    /**
+     * @generated from protobuf field: devvit.plugin.redis.KeyRequest key = 1;
+     */
+    key?: KeyRequest;
+    /**
+     * @generated from protobuf field: repeated string members = 2;
+     */
+    members: string[];
+    /**
+     * @generated from protobuf field: optional devvit.plugin.redis.RedisKeyScope scope = 100;
+     */
+    scope?: RedisKeyScope;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.ZRemRangeByLexRequest
+ */
+export interface ZRemRangeByLexRequest {
+    /**
+     * @generated from protobuf field: devvit.plugin.redis.KeyRequest key = 1;
+     */
+    key?: KeyRequest;
+    /**
+     * @generated from protobuf field: string min = 2;
+     */
+    min: string;
+    /**
+     * @generated from protobuf field: string max = 3;
+     */
+    max: string;
+    /**
+     * @generated from protobuf field: optional devvit.plugin.redis.RedisKeyScope scope = 100;
+     */
+    scope?: RedisKeyScope;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.ZRemRangeByRankRequest
+ */
+export interface ZRemRangeByRankRequest {
+    /**
+     * @generated from protobuf field: devvit.plugin.redis.KeyRequest key = 1;
+     */
+    key?: KeyRequest;
+    /**
+     * @generated from protobuf field: int32 start = 2;
+     */
+    start: number;
+    /**
+     * @generated from protobuf field: int32 stop = 3;
+     */
+    stop: number;
+    /**
+     * @generated from protobuf field: optional devvit.plugin.redis.RedisKeyScope scope = 100;
+     */
+    scope?: RedisKeyScope;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.ZRemRangeByScoreRequest
+ */
+export interface ZRemRangeByScoreRequest {
+    /**
+     * @generated from protobuf field: devvit.plugin.redis.KeyRequest key = 1;
+     */
+    key?: KeyRequest;
+    /**
+     * @generated from protobuf field: double min = 2;
+     */
+    min: number;
+    /**
+     * @generated from protobuf field: double max = 3;
+     */
+    max: number;
+    /**
+     * @generated from protobuf field: optional devvit.plugin.redis.RedisKeyScope scope = 100;
+     */
+    scope?: RedisKeyScope;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.ZScoreRequest
+ */
+export interface ZScoreRequest {
+    /**
+     * @generated from protobuf field: devvit.plugin.redis.KeyRequest key = 1;
+     */
+    key?: KeyRequest;
+    /**
+     * @generated from protobuf field: string member = 2;
+     */
+    member: string;
+    /**
+     * @generated from protobuf field: optional devvit.plugin.redis.RedisKeyScope scope = 100;
+     */
+    scope?: RedisKeyScope;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.ZRankRequest
+ */
+export interface ZRankRequest {
+    /**
+     * @generated from protobuf field: devvit.plugin.redis.KeyRequest key = 1;
+     */
+    key?: KeyRequest;
+    /**
+     * @generated from protobuf field: string member = 2;
+     */
+    member: string;
+    /**
+     * @generated from protobuf field: optional devvit.plugin.redis.RedisKeyScope scope = 100;
+     */
+    scope?: RedisKeyScope;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.ZIncrByRequest
+ */
+export interface ZIncrByRequest {
+    /**
+     * @generated from protobuf field: string key = 1;
+     */
+    key: string;
+    /**
+     * @generated from protobuf field: string member = 2;
+     */
+    member: string;
+    /**
+     * @generated from protobuf field: double value = 3;
+     */
+    value: number;
+    /**
+     * @generated from protobuf field: devvit.plugin.redis.TransactionId transaction_id = 6;
+     */
+    transactionId?: TransactionId; // Optional transaction id
+    /**
+     * @generated from protobuf field: optional devvit.plugin.redis.RedisKeyScope scope = 100;
+     */
+    scope?: RedisKeyScope;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.KeyRequest
+ */
+export interface KeyRequest {
+    /**
+     * @generated from protobuf field: string key = 1;
+     */
+    key: string;
+    /**
+     * @generated from protobuf field: devvit.plugin.redis.TransactionId transaction_id = 2;
+     */
+    transactionId?: TransactionId; // Optional transaction id
+    /**
+     * @generated from protobuf field: optional devvit.plugin.redis.RedisKeyScope scope = 100;
+     */
+    scope?: RedisKeyScope;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.IncrByRequest
+ */
+export interface IncrByRequest {
+    /**
+     * @generated from protobuf field: string key = 1;
+     */
+    key: string;
+    /**
+     * @generated from protobuf field: int64 value = 2;
+     */
+    value: bigint;
+    /**
+     * @generated from protobuf field: devvit.plugin.redis.TransactionId transaction_id = 6;
+     */
+    transactionId?: TransactionId; // Optional transaction id
+    /**
+     * @generated from protobuf field: optional devvit.plugin.redis.RedisKeyScope scope = 100;
+     */
+    scope?: RedisKeyScope;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.SetRequest
+ */
+export interface SetRequest {
+    /**
+     * @generated from protobuf field: string key = 1;
+     */
+    key: string;
+    /**
+     * @generated from protobuf field: string value = 2;
+     */
+    value: string;
+    /**
+     * @generated from protobuf field: int64 expiration = 3;
+     */
+    expiration: bigint; // Expiration time in seconds
+    /**
+     * @generated from protobuf field: bool nx = 4;
+     */
+    nx: boolean; // Set only if key does not exist
+    /**
+     * @generated from protobuf field: bool xx = 5;
+     */
+    xx: boolean; // Set only if key already exists
+    /**
+     * @generated from protobuf field: devvit.plugin.redis.TransactionId transaction_id = 6;
+     */
+    transactionId?: TransactionId; // Optional transaction id
+    /**
+     * @generated from protobuf field: optional devvit.plugin.redis.RedisKeyScope scope = 100;
+     */
+    scope?: RedisKeyScope;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.KeyRangeRequest
+ */
+export interface KeyRangeRequest {
+    /**
+     * @generated from protobuf field: string key = 1;
+     */
+    key: string;
+    /**
+     * @generated from protobuf field: int32 start = 2;
+     */
+    start: number;
+    /**
+     * @generated from protobuf field: int32 end = 3;
+     */
+    end: number;
+    /**
+     * @generated from protobuf field: devvit.plugin.redis.TransactionId transaction_id = 4;
+     */
+    transactionId?: TransactionId; // Optional transaction id
+    /**
+     * @generated from protobuf field: optional devvit.plugin.redis.RedisKeyScope scope = 100;
+     */
+    scope?: RedisKeyScope;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.SetRangeRequest
+ */
+export interface SetRangeRequest {
+    /**
+     * @generated from protobuf field: string key = 1;
+     */
+    key: string;
+    /**
+     * @generated from protobuf field: int32 offset = 2;
+     */
+    offset: number;
+    /**
+     * @generated from protobuf field: string value = 3;
+     */
+    value: string;
+    /**
+     * @generated from protobuf field: devvit.plugin.redis.TransactionId transaction_id = 4;
+     */
+    transactionId?: TransactionId; // Optional transaction id
+    /**
+     * @generated from protobuf field: optional devvit.plugin.redis.RedisKeyScope scope = 100;
+     */
+    scope?: RedisKeyScope;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.KeysRequest
+ */
+export interface KeysRequest {
+    /**
+     * @generated from protobuf field: repeated string keys = 1;
+     */
+    keys: string[];
+    /**
+     * @generated from protobuf field: devvit.plugin.redis.TransactionId transaction_id = 2;
+     */
+    transactionId?: TransactionId; // Optional transaction id
+    /**
+     * @generated from protobuf field: optional devvit.plugin.redis.RedisKeyScope scope = 100;
+     */
+    scope?: RedisKeyScope;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.KeysResponse
+ */
+export interface KeysResponse {
+    /**
+     * @generated from protobuf field: repeated string keys = 1;
+     */
+    keys: string[];
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.HGetRequest
+ */
+export interface HGetRequest {
+    /**
+     * @generated from protobuf field: string key = 1;
+     */
+    key: string;
+    /**
+     * @generated from protobuf field: string field = 2;
+     */
+    field: string;
+    /**
+     * @generated from protobuf field: devvit.plugin.redis.TransactionId transaction_id = 3;
+     */
+    transactionId?: TransactionId; // Optional transaction id
+    /**
+     * @generated from protobuf field: optional devvit.plugin.redis.RedisKeyScope scope = 100;
+     */
+    scope?: RedisKeyScope;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.HSetRequest
+ */
+export interface HSetRequest {
+    /**
+     * @generated from protobuf field: string key = 1;
+     */
+    key: string;
+    /**
+     * @generated from protobuf field: repeated devvit.plugin.redis.RedisFieldValue fv = 2;
+     */
+    fv: RedisFieldValue[];
+    /**
+     * @generated from protobuf field: devvit.plugin.redis.TransactionId transaction_id = 3;
+     */
+    transactionId?: TransactionId; // Optional transaction id
+    /**
+     * @generated from protobuf field: optional devvit.plugin.redis.RedisKeyScope scope = 100;
+     */
+    scope?: RedisKeyScope;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.HDelRequest
+ */
+export interface HDelRequest {
+    /**
+     * @generated from protobuf field: string key = 1;
+     */
+    key: string;
+    /**
+     * @generated from protobuf field: repeated string fields = 2;
+     */
+    fields: string[];
+    /**
+     * @generated from protobuf field: devvit.plugin.redis.TransactionId transaction_id = 3;
+     */
+    transactionId?: TransactionId; // Optional transaction id
+    /**
+     * @generated from protobuf field: optional devvit.plugin.redis.RedisKeyScope scope = 100;
+     */
+    scope?: RedisKeyScope;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.HScanRequest
+ */
+export interface HScanRequest {
+    /**
+     * @generated from protobuf field: string key = 1;
+     */
+    key: string;
+    /**
+     * @generated from protobuf field: uint64 cursor = 2;
+     */
+    cursor: bigint;
+    /**
+     * @generated from protobuf field: optional string pattern = 3;
+     */
+    pattern?: string;
+    /**
+     * @generated from protobuf field: optional int64 count = 4;
+     */
+    count?: bigint;
+    /**
+     * @generated from protobuf field: devvit.plugin.redis.TransactionId transaction_id = 5;
+     */
+    transactionId?: TransactionId; // Optional transaction id
+    /**
+     * @generated from protobuf field: optional devvit.plugin.redis.RedisKeyScope scope = 100;
+     */
+    scope?: RedisKeyScope;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.HScanResponse
+ */
+export interface HScanResponse {
+    /**
+     * @generated from protobuf field: uint64 cursor = 1;
+     */
+    cursor: bigint;
+    /**
+     * @generated from protobuf field: repeated devvit.plugin.redis.RedisFieldValue field_values = 2;
+     */
+    fieldValues: RedisFieldValue[];
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.HIncrByRequest
+ */
+export interface HIncrByRequest {
+    /**
+     * @generated from protobuf field: string key = 1;
+     */
+    key: string;
+    /**
+     * @generated from protobuf field: string field = 2;
+     */
+    field: string;
+    /**
+     * @generated from protobuf field: int64 value = 3;
+     */
+    value: bigint;
+    /**
+     * @generated from protobuf field: devvit.plugin.redis.TransactionId transaction_id = 6;
+     */
+    transactionId?: TransactionId; // Optional transaction id
+    /**
+     * @generated from protobuf field: optional devvit.plugin.redis.RedisKeyScope scope = 100;
+     */
+    scope?: RedisKeyScope;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.RedisFieldValue
+ */
+export interface RedisFieldValue {
+    /**
+     * @generated from protobuf field: string field = 1;
+     */
+    field: string;
+    /**
+     * @generated from protobuf field: string value = 2;
+     */
+    value: string;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.RedisFieldValues
+ */
+export interface RedisFieldValues {
+    /**
+     * @generated from protobuf field: map<string, string> field_values = 1;
+     */
+    fieldValues: {
+        [key: string]: string;
+    };
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.KeyValuesRequest
+ */
+export interface KeyValuesRequest {
+    /**
+     * @generated from protobuf field: repeated devvit.plugin.redis.RedisKeyValue kv = 1;
+     */
+    kv: RedisKeyValue[];
+    /**
+     * @generated from protobuf field: devvit.plugin.redis.TransactionId transaction_id = 2;
+     */
+    transactionId?: TransactionId; // Optional transaction id
+    /**
+     * @generated from protobuf field: optional devvit.plugin.redis.RedisKeyScope scope = 100;
+     */
+    scope?: RedisKeyScope;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.RedisKeyValue
+ */
+export interface RedisKeyValue {
+    /**
+     * @generated from protobuf field: string key = 1;
+     */
+    key: string;
+    /**
+     * @generated from protobuf field: string value = 2;
+     */
+    value: string;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.RedisValues
+ */
+export interface RedisValues {
+    /**
+     * @generated from protobuf field: repeated google.protobuf.StringValue values = 1;
+     */
+    values: StringValue[];
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.ExpireRequest
+ */
+export interface ExpireRequest {
+    /**
+     * @generated from protobuf field: string key = 1;
+     */
+    key: string;
+    /**
+     * @generated from protobuf field: int32 seconds = 2;
+     */
+    seconds: number;
+    /**
+     * @generated from protobuf field: devvit.plugin.redis.TransactionId transaction_id = 3;
+     */
+    transactionId?: TransactionId; // Optional transaction id
+    /**
+     * @generated from protobuf field: optional devvit.plugin.redis.RedisKeyScope scope = 100;
+     */
+    scope?: RedisKeyScope;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.ZAddRequest
+ */
+export interface ZAddRequest {
+    /**
+     * @generated from protobuf field: string key = 1;
+     */
+    key: string;
+    /**
+     * @generated from protobuf field: repeated devvit.plugin.redis.ZMember members = 2;
+     */
+    members: ZMember[];
+    /**
+     * @generated from protobuf field: devvit.plugin.redis.TransactionId transaction_id = 3;
+     */
+    transactionId?: TransactionId; // Optional transaction id
+    /**
+     * @generated from protobuf field: optional devvit.plugin.redis.RedisKeyScope scope = 100;
+     */
+    scope?: RedisKeyScope;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.ZScanRequest
+ */
+export interface ZScanRequest {
+    /**
+     * @generated from protobuf field: string key = 1;
+     */
+    key: string;
+    /**
+     * @generated from protobuf field: uint64 cursor = 2;
+     */
+    cursor: bigint;
+    /**
+     * @generated from protobuf field: optional string pattern = 3;
+     */
+    pattern?: string;
+    /**
+     * @generated from protobuf field: optional int64 count = 4;
+     */
+    count?: bigint;
+    /**
+     * @generated from protobuf field: devvit.plugin.redis.TransactionId transaction_id = 5;
+     */
+    transactionId?: TransactionId; // Optional transaction id
+    /**
+     * @generated from protobuf field: optional devvit.plugin.redis.RedisKeyScope scope = 100;
+     */
+    scope?: RedisKeyScope;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.ZScanResponse
+ */
+export interface ZScanResponse {
+    /**
+     * @generated from protobuf field: uint64 cursor = 1;
+     */
+    cursor: bigint;
+    /**
+     * @generated from protobuf field: repeated devvit.plugin.redis.ZMember members = 2;
+     */
+    members: ZMember[];
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.ZMembers
+ */
+export interface ZMembers {
+    /**
+     * @generated from protobuf field: repeated devvit.plugin.redis.ZMember members = 1;
+     */
+    members: ZMember[];
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.ZMember
+ */
+export interface ZMember {
+    /**
+     * @generated from protobuf field: double score = 1;
+     */
+    score: number;
+    /**
+     * @generated from protobuf field: string member = 2;
+     */
+    member: string;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.TransactionId
+ */
+export interface TransactionId {
+    /**
+     * @generated from protobuf field: string id = 1;
+     */
+    id: string;
+}
+/**
+ * @generated from protobuf message devvit.plugin.redis.WatchRequest
+ */
+export interface WatchRequest {
+    /**
+     * @generated from protobuf field: devvit.plugin.redis.TransactionId transaction_id = 1;
+     */
+    transactionId?: TransactionId;
+    /**
+     * @generated from protobuf field: repeated string keys = 2;
+     */
+    keys: string[];
+}
+/**
+ * This key scope determines the key namespacing in Redis storage
+ * By default, all keys in Redis are namespaced to an installation
+ * Global redis enables apps to persist and access state across subreddit installations
+ * Default key format - installation:app:custom-key
+ * Global redis key format - global:app:custom-key
+ *
+ * @generated from protobuf enum devvit.plugin.redis.RedisKeyScope
+ */
+export enum RedisKeyScope {
+    /**
+     * @generated from protobuf enum value: INSTALLATION = 0;
+     */
+    INSTALLATION = 0,
+    /**
+     * @generated from protobuf enum value: GLOBAL = 1;
+     */
+    GLOBAL = 1
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class TransactionResponses$Type extends MessageType<TransactionResponses> {
+    constructor() {
+        super("devvit.plugin.redis.TransactionResponses", [
+            { no: 1, name: "response", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => TransactionResponse }
+        ]);
+    }
+    create(value?: PartialMessage<TransactionResponses>): TransactionResponses {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.response = [];
+        if (value !== undefined)
+            reflectionMergePartial<TransactionResponses>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TransactionResponses): TransactionResponses {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated devvit.plugin.redis.TransactionResponse response */ 1:
+                    message.response.push(TransactionResponse.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: TransactionResponses, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated devvit.plugin.redis.TransactionResponse response = 1; */
+        for (let i = 0; i < message.response.length; i++)
+            TransactionResponse.internalBinaryWrite(message.response[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.TransactionResponses
+ */
+export const TransactionResponses = new TransactionResponses$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TransactionResponse$Type extends MessageType<TransactionResponse> {
+    constructor() {
+        super("devvit.plugin.redis.TransactionResponse", [
+            { no: 1, name: "str", kind: "message", oneof: "value", T: () => StringValue },
+            { no: 2, name: "nil", kind: "message", oneof: "value", T: () => Empty },
+            { no: 3, name: "num", kind: "message", oneof: "value", T: () => Int64Value },
+            { no: 4, name: "members", kind: "message", oneof: "value", T: () => ZMembers },
+            { no: 5, name: "values", kind: "message", oneof: "value", T: () => RedisValues }
+        ]);
+    }
+    create(value?: PartialMessage<TransactionResponse>): TransactionResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.value = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial<TransactionResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TransactionResponse): TransactionResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* google.protobuf.StringValue str */ 1:
+                    message.value = {
+                        oneofKind: "str",
+                        str: StringValue.internalBinaryRead(reader, reader.uint32(), options, (message.value as any).str)
+                    };
+                    break;
+                case /* google.protobuf.Empty nil */ 2:
+                    message.value = {
+                        oneofKind: "nil",
+                        nil: Empty.internalBinaryRead(reader, reader.uint32(), options, (message.value as any).nil)
+                    };
+                    break;
+                case /* google.protobuf.Int64Value num */ 3:
+                    message.value = {
+                        oneofKind: "num",
+                        num: Int64Value.internalBinaryRead(reader, reader.uint32(), options, (message.value as any).num)
+                    };
+                    break;
+                case /* devvit.plugin.redis.ZMembers members */ 4:
+                    message.value = {
+                        oneofKind: "members",
+                        members: ZMembers.internalBinaryRead(reader, reader.uint32(), options, (message.value as any).members)
+                    };
+                    break;
+                case /* devvit.plugin.redis.RedisValues values */ 5:
+                    message.value = {
+                        oneofKind: "values",
+                        values: RedisValues.internalBinaryRead(reader, reader.uint32(), options, (message.value as any).values)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: TransactionResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* google.protobuf.StringValue str = 1; */
+        if (message.value.oneofKind === "str")
+            StringValue.internalBinaryWrite(message.value.str, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Empty nil = 2; */
+        if (message.value.oneofKind === "nil")
+            Empty.internalBinaryWrite(message.value.nil, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Int64Value num = 3; */
+        if (message.value.oneofKind === "num")
+            Int64Value.internalBinaryWrite(message.value.num, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* devvit.plugin.redis.ZMembers members = 4; */
+        if (message.value.oneofKind === "members")
+            ZMembers.internalBinaryWrite(message.value.members, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* devvit.plugin.redis.RedisValues values = 5; */
+        if (message.value.oneofKind === "values")
+            RedisValues.internalBinaryWrite(message.value.values, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.TransactionResponse
+ */
+export const TransactionResponse = new TransactionResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ZRangeRequest$Type extends MessageType<ZRangeRequest> {
+    constructor() {
+        super("devvit.plugin.redis.ZRangeRequest", [
+            { no: 1, name: "key", kind: "message", T: () => KeyRequest },
+            { no: 2, name: "start", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "stop", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "by_score", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 5, name: "by_lex", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 6, name: "rev", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 7, name: "offset", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 8, name: "count", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 100, name: "scope", kind: "enum", opt: true, T: () => ["devvit.plugin.redis.RedisKeyScope", RedisKeyScope] }
+        ]);
+    }
+    create(value?: PartialMessage<ZRangeRequest>): ZRangeRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.start = "";
+        message.stop = "";
+        message.byScore = false;
+        message.byLex = false;
+        message.rev = false;
+        message.offset = 0;
+        message.count = 0;
+        if (value !== undefined)
+            reflectionMergePartial<ZRangeRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ZRangeRequest): ZRangeRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* devvit.plugin.redis.KeyRequest key */ 1:
+                    message.key = KeyRequest.internalBinaryRead(reader, reader.uint32(), options, message.key);
+                    break;
+                case /* string start */ 2:
+                    message.start = reader.string();
+                    break;
+                case /* string stop */ 3:
+                    message.stop = reader.string();
+                    break;
+                case /* bool by_score */ 4:
+                    message.byScore = reader.bool();
+                    break;
+                case /* bool by_lex */ 5:
+                    message.byLex = reader.bool();
+                    break;
+                case /* bool rev */ 6:
+                    message.rev = reader.bool();
+                    break;
+                case /* int32 offset */ 7:
+                    message.offset = reader.int32();
+                    break;
+                case /* int32 count */ 8:
+                    message.count = reader.int32();
+                    break;
+                case /* optional devvit.plugin.redis.RedisKeyScope scope */ 100:
+                    message.scope = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ZRangeRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* devvit.plugin.redis.KeyRequest key = 1; */
+        if (message.key)
+            KeyRequest.internalBinaryWrite(message.key, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string start = 2; */
+        if (message.start !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.start);
+        /* string stop = 3; */
+        if (message.stop !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.stop);
+        /* bool by_score = 4; */
+        if (message.byScore !== false)
+            writer.tag(4, WireType.Varint).bool(message.byScore);
+        /* bool by_lex = 5; */
+        if (message.byLex !== false)
+            writer.tag(5, WireType.Varint).bool(message.byLex);
+        /* bool rev = 6; */
+        if (message.rev !== false)
+            writer.tag(6, WireType.Varint).bool(message.rev);
+        /* int32 offset = 7; */
+        if (message.offset !== 0)
+            writer.tag(7, WireType.Varint).int32(message.offset);
+        /* int32 count = 8; */
+        if (message.count !== 0)
+            writer.tag(8, WireType.Varint).int32(message.count);
+        /* optional devvit.plugin.redis.RedisKeyScope scope = 100; */
+        if (message.scope !== undefined)
+            writer.tag(100, WireType.Varint).int32(message.scope);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.ZRangeRequest
+ */
+export const ZRangeRequest = new ZRangeRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ZRangeByLexRequest$Type extends MessageType<ZRangeByLexRequest> {
+    constructor() {
+        super("devvit.plugin.redis.ZRangeByLexRequest", [
+            { no: 1, name: "key", kind: "message", T: () => KeyRequest },
+            { no: 2, name: "min", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "max", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 100, name: "scope", kind: "enum", opt: true, T: () => ["devvit.plugin.redis.RedisKeyScope", RedisKeyScope] }
+        ]);
+    }
+    create(value?: PartialMessage<ZRangeByLexRequest>): ZRangeByLexRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.min = "";
+        message.max = "";
+        if (value !== undefined)
+            reflectionMergePartial<ZRangeByLexRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ZRangeByLexRequest): ZRangeByLexRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* devvit.plugin.redis.KeyRequest key */ 1:
+                    message.key = KeyRequest.internalBinaryRead(reader, reader.uint32(), options, message.key);
+                    break;
+                case /* string min */ 2:
+                    message.min = reader.string();
+                    break;
+                case /* string max */ 3:
+                    message.max = reader.string();
+                    break;
+                case /* optional devvit.plugin.redis.RedisKeyScope scope */ 100:
+                    message.scope = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ZRangeByLexRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* devvit.plugin.redis.KeyRequest key = 1; */
+        if (message.key)
+            KeyRequest.internalBinaryWrite(message.key, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string min = 2; */
+        if (message.min !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.min);
+        /* string max = 3; */
+        if (message.max !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.max);
+        /* optional devvit.plugin.redis.RedisKeyScope scope = 100; */
+        if (message.scope !== undefined)
+            writer.tag(100, WireType.Varint).int32(message.scope);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.ZRangeByLexRequest
+ */
+export const ZRangeByLexRequest = new ZRangeByLexRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ZRangeByScoreRequest$Type extends MessageType<ZRangeByScoreRequest> {
+    constructor() {
+        super("devvit.plugin.redis.ZRangeByScoreRequest", [
+            { no: 1, name: "key", kind: "message", T: () => KeyRequest },
+            { no: 2, name: "min", kind: "scalar", T: 1 /*ScalarType.DOUBLE*/ },
+            { no: 3, name: "max", kind: "scalar", T: 1 /*ScalarType.DOUBLE*/ },
+            { no: 4, name: "with_scores", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 100, name: "scope", kind: "enum", opt: true, T: () => ["devvit.plugin.redis.RedisKeyScope", RedisKeyScope] }
+        ]);
+    }
+    create(value?: PartialMessage<ZRangeByScoreRequest>): ZRangeByScoreRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.min = 0;
+        message.max = 0;
+        message.withScores = false;
+        if (value !== undefined)
+            reflectionMergePartial<ZRangeByScoreRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ZRangeByScoreRequest): ZRangeByScoreRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* devvit.plugin.redis.KeyRequest key */ 1:
+                    message.key = KeyRequest.internalBinaryRead(reader, reader.uint32(), options, message.key);
+                    break;
+                case /* double min */ 2:
+                    message.min = reader.double();
+                    break;
+                case /* double max */ 3:
+                    message.max = reader.double();
+                    break;
+                case /* bool with_scores */ 4:
+                    message.withScores = reader.bool();
+                    break;
+                case /* optional devvit.plugin.redis.RedisKeyScope scope */ 100:
+                    message.scope = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ZRangeByScoreRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* devvit.plugin.redis.KeyRequest key = 1; */
+        if (message.key)
+            KeyRequest.internalBinaryWrite(message.key, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* double min = 2; */
+        if (message.min !== 0)
+            writer.tag(2, WireType.Bit64).double(message.min);
+        /* double max = 3; */
+        if (message.max !== 0)
+            writer.tag(3, WireType.Bit64).double(message.max);
+        /* bool with_scores = 4; */
+        if (message.withScores !== false)
+            writer.tag(4, WireType.Varint).bool(message.withScores);
+        /* optional devvit.plugin.redis.RedisKeyScope scope = 100; */
+        if (message.scope !== undefined)
+            writer.tag(100, WireType.Varint).int32(message.scope);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.ZRangeByScoreRequest
+ */
+export const ZRangeByScoreRequest = new ZRangeByScoreRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ZRemRequest$Type extends MessageType<ZRemRequest> {
+    constructor() {
+        super("devvit.plugin.redis.ZRemRequest", [
+            { no: 1, name: "key", kind: "message", T: () => KeyRequest },
+            { no: 2, name: "members", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
+            { no: 100, name: "scope", kind: "enum", opt: true, T: () => ["devvit.plugin.redis.RedisKeyScope", RedisKeyScope] }
+        ]);
+    }
+    create(value?: PartialMessage<ZRemRequest>): ZRemRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.members = [];
+        if (value !== undefined)
+            reflectionMergePartial<ZRemRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ZRemRequest): ZRemRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* devvit.plugin.redis.KeyRequest key */ 1:
+                    message.key = KeyRequest.internalBinaryRead(reader, reader.uint32(), options, message.key);
+                    break;
+                case /* repeated string members */ 2:
+                    message.members.push(reader.string());
+                    break;
+                case /* optional devvit.plugin.redis.RedisKeyScope scope */ 100:
+                    message.scope = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ZRemRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* devvit.plugin.redis.KeyRequest key = 1; */
+        if (message.key)
+            KeyRequest.internalBinaryWrite(message.key, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* repeated string members = 2; */
+        for (let i = 0; i < message.members.length; i++)
+            writer.tag(2, WireType.LengthDelimited).string(message.members[i]);
+        /* optional devvit.plugin.redis.RedisKeyScope scope = 100; */
+        if (message.scope !== undefined)
+            writer.tag(100, WireType.Varint).int32(message.scope);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.ZRemRequest
+ */
+export const ZRemRequest = new ZRemRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ZRemRangeByLexRequest$Type extends MessageType<ZRemRangeByLexRequest> {
+    constructor() {
+        super("devvit.plugin.redis.ZRemRangeByLexRequest", [
+            { no: 1, name: "key", kind: "message", T: () => KeyRequest },
+            { no: 2, name: "min", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "max", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 100, name: "scope", kind: "enum", opt: true, T: () => ["devvit.plugin.redis.RedisKeyScope", RedisKeyScope] }
+        ]);
+    }
+    create(value?: PartialMessage<ZRemRangeByLexRequest>): ZRemRangeByLexRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.min = "";
+        message.max = "";
+        if (value !== undefined)
+            reflectionMergePartial<ZRemRangeByLexRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ZRemRangeByLexRequest): ZRemRangeByLexRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* devvit.plugin.redis.KeyRequest key */ 1:
+                    message.key = KeyRequest.internalBinaryRead(reader, reader.uint32(), options, message.key);
+                    break;
+                case /* string min */ 2:
+                    message.min = reader.string();
+                    break;
+                case /* string max */ 3:
+                    message.max = reader.string();
+                    break;
+                case /* optional devvit.plugin.redis.RedisKeyScope scope */ 100:
+                    message.scope = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ZRemRangeByLexRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* devvit.plugin.redis.KeyRequest key = 1; */
+        if (message.key)
+            KeyRequest.internalBinaryWrite(message.key, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string min = 2; */
+        if (message.min !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.min);
+        /* string max = 3; */
+        if (message.max !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.max);
+        /* optional devvit.plugin.redis.RedisKeyScope scope = 100; */
+        if (message.scope !== undefined)
+            writer.tag(100, WireType.Varint).int32(message.scope);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.ZRemRangeByLexRequest
+ */
+export const ZRemRangeByLexRequest = new ZRemRangeByLexRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ZRemRangeByRankRequest$Type extends MessageType<ZRemRangeByRankRequest> {
+    constructor() {
+        super("devvit.plugin.redis.ZRemRangeByRankRequest", [
+            { no: 1, name: "key", kind: "message", T: () => KeyRequest },
+            { no: 2, name: "start", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 3, name: "stop", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 100, name: "scope", kind: "enum", opt: true, T: () => ["devvit.plugin.redis.RedisKeyScope", RedisKeyScope] }
+        ]);
+    }
+    create(value?: PartialMessage<ZRemRangeByRankRequest>): ZRemRangeByRankRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.start = 0;
+        message.stop = 0;
+        if (value !== undefined)
+            reflectionMergePartial<ZRemRangeByRankRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ZRemRangeByRankRequest): ZRemRangeByRankRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* devvit.plugin.redis.KeyRequest key */ 1:
+                    message.key = KeyRequest.internalBinaryRead(reader, reader.uint32(), options, message.key);
+                    break;
+                case /* int32 start */ 2:
+                    message.start = reader.int32();
+                    break;
+                case /* int32 stop */ 3:
+                    message.stop = reader.int32();
+                    break;
+                case /* optional devvit.plugin.redis.RedisKeyScope scope */ 100:
+                    message.scope = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ZRemRangeByRankRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* devvit.plugin.redis.KeyRequest key = 1; */
+        if (message.key)
+            KeyRequest.internalBinaryWrite(message.key, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* int32 start = 2; */
+        if (message.start !== 0)
+            writer.tag(2, WireType.Varint).int32(message.start);
+        /* int32 stop = 3; */
+        if (message.stop !== 0)
+            writer.tag(3, WireType.Varint).int32(message.stop);
+        /* optional devvit.plugin.redis.RedisKeyScope scope = 100; */
+        if (message.scope !== undefined)
+            writer.tag(100, WireType.Varint).int32(message.scope);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.ZRemRangeByRankRequest
+ */
+export const ZRemRangeByRankRequest = new ZRemRangeByRankRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ZRemRangeByScoreRequest$Type extends MessageType<ZRemRangeByScoreRequest> {
+    constructor() {
+        super("devvit.plugin.redis.ZRemRangeByScoreRequest", [
+            { no: 1, name: "key", kind: "message", T: () => KeyRequest },
+            { no: 2, name: "min", kind: "scalar", T: 1 /*ScalarType.DOUBLE*/ },
+            { no: 3, name: "max", kind: "scalar", T: 1 /*ScalarType.DOUBLE*/ },
+            { no: 100, name: "scope", kind: "enum", opt: true, T: () => ["devvit.plugin.redis.RedisKeyScope", RedisKeyScope] }
+        ]);
+    }
+    create(value?: PartialMessage<ZRemRangeByScoreRequest>): ZRemRangeByScoreRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.min = 0;
+        message.max = 0;
+        if (value !== undefined)
+            reflectionMergePartial<ZRemRangeByScoreRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ZRemRangeByScoreRequest): ZRemRangeByScoreRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* devvit.plugin.redis.KeyRequest key */ 1:
+                    message.key = KeyRequest.internalBinaryRead(reader, reader.uint32(), options, message.key);
+                    break;
+                case /* double min */ 2:
+                    message.min = reader.double();
+                    break;
+                case /* double max */ 3:
+                    message.max = reader.double();
+                    break;
+                case /* optional devvit.plugin.redis.RedisKeyScope scope */ 100:
+                    message.scope = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ZRemRangeByScoreRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* devvit.plugin.redis.KeyRequest key = 1; */
+        if (message.key)
+            KeyRequest.internalBinaryWrite(message.key, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* double min = 2; */
+        if (message.min !== 0)
+            writer.tag(2, WireType.Bit64).double(message.min);
+        /* double max = 3; */
+        if (message.max !== 0)
+            writer.tag(3, WireType.Bit64).double(message.max);
+        /* optional devvit.plugin.redis.RedisKeyScope scope = 100; */
+        if (message.scope !== undefined)
+            writer.tag(100, WireType.Varint).int32(message.scope);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.ZRemRangeByScoreRequest
+ */
+export const ZRemRangeByScoreRequest = new ZRemRangeByScoreRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ZScoreRequest$Type extends MessageType<ZScoreRequest> {
+    constructor() {
+        super("devvit.plugin.redis.ZScoreRequest", [
+            { no: 1, name: "key", kind: "message", T: () => KeyRequest },
+            { no: 2, name: "member", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 100, name: "scope", kind: "enum", opt: true, T: () => ["devvit.plugin.redis.RedisKeyScope", RedisKeyScope] }
+        ]);
+    }
+    create(value?: PartialMessage<ZScoreRequest>): ZScoreRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.member = "";
+        if (value !== undefined)
+            reflectionMergePartial<ZScoreRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ZScoreRequest): ZScoreRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* devvit.plugin.redis.KeyRequest key */ 1:
+                    message.key = KeyRequest.internalBinaryRead(reader, reader.uint32(), options, message.key);
+                    break;
+                case /* string member */ 2:
+                    message.member = reader.string();
+                    break;
+                case /* optional devvit.plugin.redis.RedisKeyScope scope */ 100:
+                    message.scope = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ZScoreRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* devvit.plugin.redis.KeyRequest key = 1; */
+        if (message.key)
+            KeyRequest.internalBinaryWrite(message.key, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string member = 2; */
+        if (message.member !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.member);
+        /* optional devvit.plugin.redis.RedisKeyScope scope = 100; */
+        if (message.scope !== undefined)
+            writer.tag(100, WireType.Varint).int32(message.scope);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.ZScoreRequest
+ */
+export const ZScoreRequest = new ZScoreRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ZRankRequest$Type extends MessageType<ZRankRequest> {
+    constructor() {
+        super("devvit.plugin.redis.ZRankRequest", [
+            { no: 1, name: "key", kind: "message", T: () => KeyRequest },
+            { no: 2, name: "member", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 100, name: "scope", kind: "enum", opt: true, T: () => ["devvit.plugin.redis.RedisKeyScope", RedisKeyScope] }
+        ]);
+    }
+    create(value?: PartialMessage<ZRankRequest>): ZRankRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.member = "";
+        if (value !== undefined)
+            reflectionMergePartial<ZRankRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ZRankRequest): ZRankRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* devvit.plugin.redis.KeyRequest key */ 1:
+                    message.key = KeyRequest.internalBinaryRead(reader, reader.uint32(), options, message.key);
+                    break;
+                case /* string member */ 2:
+                    message.member = reader.string();
+                    break;
+                case /* optional devvit.plugin.redis.RedisKeyScope scope */ 100:
+                    message.scope = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ZRankRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* devvit.plugin.redis.KeyRequest key = 1; */
+        if (message.key)
+            KeyRequest.internalBinaryWrite(message.key, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string member = 2; */
+        if (message.member !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.member);
+        /* optional devvit.plugin.redis.RedisKeyScope scope = 100; */
+        if (message.scope !== undefined)
+            writer.tag(100, WireType.Varint).int32(message.scope);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.ZRankRequest
+ */
+export const ZRankRequest = new ZRankRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ZIncrByRequest$Type extends MessageType<ZIncrByRequest> {
+    constructor() {
+        super("devvit.plugin.redis.ZIncrByRequest", [
+            { no: 1, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "member", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "value", kind: "scalar", T: 1 /*ScalarType.DOUBLE*/ },
+            { no: 6, name: "transaction_id", kind: "message", T: () => TransactionId },
+            { no: 100, name: "scope", kind: "enum", opt: true, T: () => ["devvit.plugin.redis.RedisKeyScope", RedisKeyScope] }
+        ]);
+    }
+    create(value?: PartialMessage<ZIncrByRequest>): ZIncrByRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.key = "";
+        message.member = "";
+        message.value = 0;
+        if (value !== undefined)
+            reflectionMergePartial<ZIncrByRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ZIncrByRequest): ZIncrByRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string key */ 1:
+                    message.key = reader.string();
+                    break;
+                case /* string member */ 2:
+                    message.member = reader.string();
+                    break;
+                case /* double value */ 3:
+                    message.value = reader.double();
+                    break;
+                case /* devvit.plugin.redis.TransactionId transaction_id */ 6:
+                    message.transactionId = TransactionId.internalBinaryRead(reader, reader.uint32(), options, message.transactionId);
+                    break;
+                case /* optional devvit.plugin.redis.RedisKeyScope scope */ 100:
+                    message.scope = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ZIncrByRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string key = 1; */
+        if (message.key !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.key);
+        /* string member = 2; */
+        if (message.member !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.member);
+        /* double value = 3; */
+        if (message.value !== 0)
+            writer.tag(3, WireType.Bit64).double(message.value);
+        /* devvit.plugin.redis.TransactionId transaction_id = 6; */
+        if (message.transactionId)
+            TransactionId.internalBinaryWrite(message.transactionId, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* optional devvit.plugin.redis.RedisKeyScope scope = 100; */
+        if (message.scope !== undefined)
+            writer.tag(100, WireType.Varint).int32(message.scope);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.ZIncrByRequest
+ */
+export const ZIncrByRequest = new ZIncrByRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class KeyRequest$Type extends MessageType<KeyRequest> {
+    constructor() {
+        super("devvit.plugin.redis.KeyRequest", [
+            { no: 1, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "transaction_id", kind: "message", T: () => TransactionId },
+            { no: 100, name: "scope", kind: "enum", opt: true, T: () => ["devvit.plugin.redis.RedisKeyScope", RedisKeyScope] }
+        ]);
+    }
+    create(value?: PartialMessage<KeyRequest>): KeyRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.key = "";
+        if (value !== undefined)
+            reflectionMergePartial<KeyRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: KeyRequest): KeyRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string key */ 1:
+                    message.key = reader.string();
+                    break;
+                case /* devvit.plugin.redis.TransactionId transaction_id */ 2:
+                    message.transactionId = TransactionId.internalBinaryRead(reader, reader.uint32(), options, message.transactionId);
+                    break;
+                case /* optional devvit.plugin.redis.RedisKeyScope scope */ 100:
+                    message.scope = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: KeyRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string key = 1; */
+        if (message.key !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.key);
+        /* devvit.plugin.redis.TransactionId transaction_id = 2; */
+        if (message.transactionId)
+            TransactionId.internalBinaryWrite(message.transactionId, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* optional devvit.plugin.redis.RedisKeyScope scope = 100; */
+        if (message.scope !== undefined)
+            writer.tag(100, WireType.Varint).int32(message.scope);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.KeyRequest
+ */
+export const KeyRequest = new KeyRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class IncrByRequest$Type extends MessageType<IncrByRequest> {
+    constructor() {
+        super("devvit.plugin.redis.IncrByRequest", [
+            { no: 1, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "value", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 6, name: "transaction_id", kind: "message", T: () => TransactionId },
+            { no: 100, name: "scope", kind: "enum", opt: true, T: () => ["devvit.plugin.redis.RedisKeyScope", RedisKeyScope] }
+        ]);
+    }
+    create(value?: PartialMessage<IncrByRequest>): IncrByRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.key = "";
+        message.value = 0n;
+        if (value !== undefined)
+            reflectionMergePartial<IncrByRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: IncrByRequest): IncrByRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string key */ 1:
+                    message.key = reader.string();
+                    break;
+                case /* int64 value */ 2:
+                    message.value = reader.int64().toBigInt();
+                    break;
+                case /* devvit.plugin.redis.TransactionId transaction_id */ 6:
+                    message.transactionId = TransactionId.internalBinaryRead(reader, reader.uint32(), options, message.transactionId);
+                    break;
+                case /* optional devvit.plugin.redis.RedisKeyScope scope */ 100:
+                    message.scope = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: IncrByRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string key = 1; */
+        if (message.key !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.key);
+        /* int64 value = 2; */
+        if (message.value !== 0n)
+            writer.tag(2, WireType.Varint).int64(message.value);
+        /* devvit.plugin.redis.TransactionId transaction_id = 6; */
+        if (message.transactionId)
+            TransactionId.internalBinaryWrite(message.transactionId, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* optional devvit.plugin.redis.RedisKeyScope scope = 100; */
+        if (message.scope !== undefined)
+            writer.tag(100, WireType.Varint).int32(message.scope);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.IncrByRequest
+ */
+export const IncrByRequest = new IncrByRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SetRequest$Type extends MessageType<SetRequest> {
+    constructor() {
+        super("devvit.plugin.redis.SetRequest", [
+            { no: 1, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "value", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "expiration", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 4, name: "nx", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 5, name: "xx", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 6, name: "transaction_id", kind: "message", T: () => TransactionId },
+            { no: 100, name: "scope", kind: "enum", opt: true, T: () => ["devvit.plugin.redis.RedisKeyScope", RedisKeyScope] }
+        ]);
+    }
+    create(value?: PartialMessage<SetRequest>): SetRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.key = "";
+        message.value = "";
+        message.expiration = 0n;
+        message.nx = false;
+        message.xx = false;
+        if (value !== undefined)
+            reflectionMergePartial<SetRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SetRequest): SetRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string key */ 1:
+                    message.key = reader.string();
+                    break;
+                case /* string value */ 2:
+                    message.value = reader.string();
+                    break;
+                case /* int64 expiration */ 3:
+                    message.expiration = reader.int64().toBigInt();
+                    break;
+                case /* bool nx */ 4:
+                    message.nx = reader.bool();
+                    break;
+                case /* bool xx */ 5:
+                    message.xx = reader.bool();
+                    break;
+                case /* devvit.plugin.redis.TransactionId transaction_id */ 6:
+                    message.transactionId = TransactionId.internalBinaryRead(reader, reader.uint32(), options, message.transactionId);
+                    break;
+                case /* optional devvit.plugin.redis.RedisKeyScope scope */ 100:
+                    message.scope = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: SetRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string key = 1; */
+        if (message.key !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.key);
+        /* string value = 2; */
+        if (message.value !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.value);
+        /* int64 expiration = 3; */
+        if (message.expiration !== 0n)
+            writer.tag(3, WireType.Varint).int64(message.expiration);
+        /* bool nx = 4; */
+        if (message.nx !== false)
+            writer.tag(4, WireType.Varint).bool(message.nx);
+        /* bool xx = 5; */
+        if (message.xx !== false)
+            writer.tag(5, WireType.Varint).bool(message.xx);
+        /* devvit.plugin.redis.TransactionId transaction_id = 6; */
+        if (message.transactionId)
+            TransactionId.internalBinaryWrite(message.transactionId, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* optional devvit.plugin.redis.RedisKeyScope scope = 100; */
+        if (message.scope !== undefined)
+            writer.tag(100, WireType.Varint).int32(message.scope);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.SetRequest
+ */
+export const SetRequest = new SetRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class KeyRangeRequest$Type extends MessageType<KeyRangeRequest> {
+    constructor() {
+        super("devvit.plugin.redis.KeyRangeRequest", [
+            { no: 1, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "start", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 3, name: "end", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 4, name: "transaction_id", kind: "message", T: () => TransactionId },
+            { no: 100, name: "scope", kind: "enum", opt: true, T: () => ["devvit.plugin.redis.RedisKeyScope", RedisKeyScope] }
+        ]);
+    }
+    create(value?: PartialMessage<KeyRangeRequest>): KeyRangeRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.key = "";
+        message.start = 0;
+        message.end = 0;
+        if (value !== undefined)
+            reflectionMergePartial<KeyRangeRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: KeyRangeRequest): KeyRangeRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string key */ 1:
+                    message.key = reader.string();
+                    break;
+                case /* int32 start */ 2:
+                    message.start = reader.int32();
+                    break;
+                case /* int32 end */ 3:
+                    message.end = reader.int32();
+                    break;
+                case /* devvit.plugin.redis.TransactionId transaction_id */ 4:
+                    message.transactionId = TransactionId.internalBinaryRead(reader, reader.uint32(), options, message.transactionId);
+                    break;
+                case /* optional devvit.plugin.redis.RedisKeyScope scope */ 100:
+                    message.scope = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: KeyRangeRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string key = 1; */
+        if (message.key !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.key);
+        /* int32 start = 2; */
+        if (message.start !== 0)
+            writer.tag(2, WireType.Varint).int32(message.start);
+        /* int32 end = 3; */
+        if (message.end !== 0)
+            writer.tag(3, WireType.Varint).int32(message.end);
+        /* devvit.plugin.redis.TransactionId transaction_id = 4; */
+        if (message.transactionId)
+            TransactionId.internalBinaryWrite(message.transactionId, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* optional devvit.plugin.redis.RedisKeyScope scope = 100; */
+        if (message.scope !== undefined)
+            writer.tag(100, WireType.Varint).int32(message.scope);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.KeyRangeRequest
+ */
+export const KeyRangeRequest = new KeyRangeRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SetRangeRequest$Type extends MessageType<SetRangeRequest> {
+    constructor() {
+        super("devvit.plugin.redis.SetRangeRequest", [
+            { no: 1, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "offset", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 3, name: "value", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "transaction_id", kind: "message", T: () => TransactionId },
+            { no: 100, name: "scope", kind: "enum", opt: true, T: () => ["devvit.plugin.redis.RedisKeyScope", RedisKeyScope] }
+        ]);
+    }
+    create(value?: PartialMessage<SetRangeRequest>): SetRangeRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.key = "";
+        message.offset = 0;
+        message.value = "";
+        if (value !== undefined)
+            reflectionMergePartial<SetRangeRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SetRangeRequest): SetRangeRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string key */ 1:
+                    message.key = reader.string();
+                    break;
+                case /* int32 offset */ 2:
+                    message.offset = reader.int32();
+                    break;
+                case /* string value */ 3:
+                    message.value = reader.string();
+                    break;
+                case /* devvit.plugin.redis.TransactionId transaction_id */ 4:
+                    message.transactionId = TransactionId.internalBinaryRead(reader, reader.uint32(), options, message.transactionId);
+                    break;
+                case /* optional devvit.plugin.redis.RedisKeyScope scope */ 100:
+                    message.scope = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: SetRangeRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string key = 1; */
+        if (message.key !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.key);
+        /* int32 offset = 2; */
+        if (message.offset !== 0)
+            writer.tag(2, WireType.Varint).int32(message.offset);
+        /* string value = 3; */
+        if (message.value !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.value);
+        /* devvit.plugin.redis.TransactionId transaction_id = 4; */
+        if (message.transactionId)
+            TransactionId.internalBinaryWrite(message.transactionId, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* optional devvit.plugin.redis.RedisKeyScope scope = 100; */
+        if (message.scope !== undefined)
+            writer.tag(100, WireType.Varint).int32(message.scope);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.SetRangeRequest
+ */
+export const SetRangeRequest = new SetRangeRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class KeysRequest$Type extends MessageType<KeysRequest> {
+    constructor() {
+        super("devvit.plugin.redis.KeysRequest", [
+            { no: 1, name: "keys", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "transaction_id", kind: "message", T: () => TransactionId },
+            { no: 100, name: "scope", kind: "enum", opt: true, T: () => ["devvit.plugin.redis.RedisKeyScope", RedisKeyScope] }
+        ]);
+    }
+    create(value?: PartialMessage<KeysRequest>): KeysRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.keys = [];
+        if (value !== undefined)
+            reflectionMergePartial<KeysRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: KeysRequest): KeysRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated string keys */ 1:
+                    message.keys.push(reader.string());
+                    break;
+                case /* devvit.plugin.redis.TransactionId transaction_id */ 2:
+                    message.transactionId = TransactionId.internalBinaryRead(reader, reader.uint32(), options, message.transactionId);
+                    break;
+                case /* optional devvit.plugin.redis.RedisKeyScope scope */ 100:
+                    message.scope = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: KeysRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated string keys = 1; */
+        for (let i = 0; i < message.keys.length; i++)
+            writer.tag(1, WireType.LengthDelimited).string(message.keys[i]);
+        /* devvit.plugin.redis.TransactionId transaction_id = 2; */
+        if (message.transactionId)
+            TransactionId.internalBinaryWrite(message.transactionId, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* optional devvit.plugin.redis.RedisKeyScope scope = 100; */
+        if (message.scope !== undefined)
+            writer.tag(100, WireType.Varint).int32(message.scope);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.KeysRequest
+ */
+export const KeysRequest = new KeysRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class KeysResponse$Type extends MessageType<KeysResponse> {
+    constructor() {
+        super("devvit.plugin.redis.KeysResponse", [
+            { no: 1, name: "keys", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<KeysResponse>): KeysResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.keys = [];
+        if (value !== undefined)
+            reflectionMergePartial<KeysResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: KeysResponse): KeysResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated string keys */ 1:
+                    message.keys.push(reader.string());
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: KeysResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated string keys = 1; */
+        for (let i = 0; i < message.keys.length; i++)
+            writer.tag(1, WireType.LengthDelimited).string(message.keys[i]);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.KeysResponse
+ */
+export const KeysResponse = new KeysResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class HGetRequest$Type extends MessageType<HGetRequest> {
+    constructor() {
+        super("devvit.plugin.redis.HGetRequest", [
+            { no: 1, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "field", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "transaction_id", kind: "message", T: () => TransactionId },
+            { no: 100, name: "scope", kind: "enum", opt: true, T: () => ["devvit.plugin.redis.RedisKeyScope", RedisKeyScope] }
+        ]);
+    }
+    create(value?: PartialMessage<HGetRequest>): HGetRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.key = "";
+        message.field = "";
+        if (value !== undefined)
+            reflectionMergePartial<HGetRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: HGetRequest): HGetRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string key */ 1:
+                    message.key = reader.string();
+                    break;
+                case /* string field */ 2:
+                    message.field = reader.string();
+                    break;
+                case /* devvit.plugin.redis.TransactionId transaction_id */ 3:
+                    message.transactionId = TransactionId.internalBinaryRead(reader, reader.uint32(), options, message.transactionId);
+                    break;
+                case /* optional devvit.plugin.redis.RedisKeyScope scope */ 100:
+                    message.scope = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: HGetRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string key = 1; */
+        if (message.key !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.key);
+        /* string field = 2; */
+        if (message.field !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.field);
+        /* devvit.plugin.redis.TransactionId transaction_id = 3; */
+        if (message.transactionId)
+            TransactionId.internalBinaryWrite(message.transactionId, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* optional devvit.plugin.redis.RedisKeyScope scope = 100; */
+        if (message.scope !== undefined)
+            writer.tag(100, WireType.Varint).int32(message.scope);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.HGetRequest
+ */
+export const HGetRequest = new HGetRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class HSetRequest$Type extends MessageType<HSetRequest> {
+    constructor() {
+        super("devvit.plugin.redis.HSetRequest", [
+            { no: 1, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "fv", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => RedisFieldValue },
+            { no: 3, name: "transaction_id", kind: "message", T: () => TransactionId },
+            { no: 100, name: "scope", kind: "enum", opt: true, T: () => ["devvit.plugin.redis.RedisKeyScope", RedisKeyScope] }
+        ]);
+    }
+    create(value?: PartialMessage<HSetRequest>): HSetRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.key = "";
+        message.fv = [];
+        if (value !== undefined)
+            reflectionMergePartial<HSetRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: HSetRequest): HSetRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string key */ 1:
+                    message.key = reader.string();
+                    break;
+                case /* repeated devvit.plugin.redis.RedisFieldValue fv */ 2:
+                    message.fv.push(RedisFieldValue.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* devvit.plugin.redis.TransactionId transaction_id */ 3:
+                    message.transactionId = TransactionId.internalBinaryRead(reader, reader.uint32(), options, message.transactionId);
+                    break;
+                case /* optional devvit.plugin.redis.RedisKeyScope scope */ 100:
+                    message.scope = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: HSetRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string key = 1; */
+        if (message.key !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.key);
+        /* repeated devvit.plugin.redis.RedisFieldValue fv = 2; */
+        for (let i = 0; i < message.fv.length; i++)
+            RedisFieldValue.internalBinaryWrite(message.fv[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* devvit.plugin.redis.TransactionId transaction_id = 3; */
+        if (message.transactionId)
+            TransactionId.internalBinaryWrite(message.transactionId, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* optional devvit.plugin.redis.RedisKeyScope scope = 100; */
+        if (message.scope !== undefined)
+            writer.tag(100, WireType.Varint).int32(message.scope);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.HSetRequest
+ */
+export const HSetRequest = new HSetRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class HDelRequest$Type extends MessageType<HDelRequest> {
+    constructor() {
+        super("devvit.plugin.redis.HDelRequest", [
+            { no: 1, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "fields", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "transaction_id", kind: "message", T: () => TransactionId },
+            { no: 100, name: "scope", kind: "enum", opt: true, T: () => ["devvit.plugin.redis.RedisKeyScope", RedisKeyScope] }
+        ]);
+    }
+    create(value?: PartialMessage<HDelRequest>): HDelRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.key = "";
+        message.fields = [];
+        if (value !== undefined)
+            reflectionMergePartial<HDelRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: HDelRequest): HDelRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string key */ 1:
+                    message.key = reader.string();
+                    break;
+                case /* repeated string fields */ 2:
+                    message.fields.push(reader.string());
+                    break;
+                case /* devvit.plugin.redis.TransactionId transaction_id */ 3:
+                    message.transactionId = TransactionId.internalBinaryRead(reader, reader.uint32(), options, message.transactionId);
+                    break;
+                case /* optional devvit.plugin.redis.RedisKeyScope scope */ 100:
+                    message.scope = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: HDelRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string key = 1; */
+        if (message.key !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.key);
+        /* repeated string fields = 2; */
+        for (let i = 0; i < message.fields.length; i++)
+            writer.tag(2, WireType.LengthDelimited).string(message.fields[i]);
+        /* devvit.plugin.redis.TransactionId transaction_id = 3; */
+        if (message.transactionId)
+            TransactionId.internalBinaryWrite(message.transactionId, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* optional devvit.plugin.redis.RedisKeyScope scope = 100; */
+        if (message.scope !== undefined)
+            writer.tag(100, WireType.Varint).int32(message.scope);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.HDelRequest
+ */
+export const HDelRequest = new HDelRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class HScanRequest$Type extends MessageType<HScanRequest> {
+    constructor() {
+        super("devvit.plugin.redis.HScanRequest", [
+            { no: 1, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "cursor", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 3, name: "pattern", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "count", kind: "scalar", opt: true, T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 5, name: "transaction_id", kind: "message", T: () => TransactionId },
+            { no: 100, name: "scope", kind: "enum", opt: true, T: () => ["devvit.plugin.redis.RedisKeyScope", RedisKeyScope] }
+        ]);
+    }
+    create(value?: PartialMessage<HScanRequest>): HScanRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.key = "";
+        message.cursor = 0n;
+        if (value !== undefined)
+            reflectionMergePartial<HScanRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: HScanRequest): HScanRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string key */ 1:
+                    message.key = reader.string();
+                    break;
+                case /* uint64 cursor */ 2:
+                    message.cursor = reader.uint64().toBigInt();
+                    break;
+                case /* optional string pattern */ 3:
+                    message.pattern = reader.string();
+                    break;
+                case /* optional int64 count */ 4:
+                    message.count = reader.int64().toBigInt();
+                    break;
+                case /* devvit.plugin.redis.TransactionId transaction_id */ 5:
+                    message.transactionId = TransactionId.internalBinaryRead(reader, reader.uint32(), options, message.transactionId);
+                    break;
+                case /* optional devvit.plugin.redis.RedisKeyScope scope */ 100:
+                    message.scope = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: HScanRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string key = 1; */
+        if (message.key !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.key);
+        /* uint64 cursor = 2; */
+        if (message.cursor !== 0n)
+            writer.tag(2, WireType.Varint).uint64(message.cursor);
+        /* optional string pattern = 3; */
+        if (message.pattern !== undefined)
+            writer.tag(3, WireType.LengthDelimited).string(message.pattern);
+        /* optional int64 count = 4; */
+        if (message.count !== undefined)
+            writer.tag(4, WireType.Varint).int64(message.count);
+        /* devvit.plugin.redis.TransactionId transaction_id = 5; */
+        if (message.transactionId)
+            TransactionId.internalBinaryWrite(message.transactionId, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* optional devvit.plugin.redis.RedisKeyScope scope = 100; */
+        if (message.scope !== undefined)
+            writer.tag(100, WireType.Varint).int32(message.scope);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.HScanRequest
+ */
+export const HScanRequest = new HScanRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class HScanResponse$Type extends MessageType<HScanResponse> {
+    constructor() {
+        super("devvit.plugin.redis.HScanResponse", [
+            { no: 1, name: "cursor", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "field_values", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => RedisFieldValue }
+        ]);
+    }
+    create(value?: PartialMessage<HScanResponse>): HScanResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.cursor = 0n;
+        message.fieldValues = [];
+        if (value !== undefined)
+            reflectionMergePartial<HScanResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: HScanResponse): HScanResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* uint64 cursor */ 1:
+                    message.cursor = reader.uint64().toBigInt();
+                    break;
+                case /* repeated devvit.plugin.redis.RedisFieldValue field_values */ 2:
+                    message.fieldValues.push(RedisFieldValue.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: HScanResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* uint64 cursor = 1; */
+        if (message.cursor !== 0n)
+            writer.tag(1, WireType.Varint).uint64(message.cursor);
+        /* repeated devvit.plugin.redis.RedisFieldValue field_values = 2; */
+        for (let i = 0; i < message.fieldValues.length; i++)
+            RedisFieldValue.internalBinaryWrite(message.fieldValues[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.HScanResponse
+ */
+export const HScanResponse = new HScanResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class HIncrByRequest$Type extends MessageType<HIncrByRequest> {
+    constructor() {
+        super("devvit.plugin.redis.HIncrByRequest", [
+            { no: 1, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "field", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "value", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 6, name: "transaction_id", kind: "message", T: () => TransactionId },
+            { no: 100, name: "scope", kind: "enum", opt: true, T: () => ["devvit.plugin.redis.RedisKeyScope", RedisKeyScope] }
+        ]);
+    }
+    create(value?: PartialMessage<HIncrByRequest>): HIncrByRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.key = "";
+        message.field = "";
+        message.value = 0n;
+        if (value !== undefined)
+            reflectionMergePartial<HIncrByRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: HIncrByRequest): HIncrByRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string key */ 1:
+                    message.key = reader.string();
+                    break;
+                case /* string field */ 2:
+                    message.field = reader.string();
+                    break;
+                case /* int64 value */ 3:
+                    message.value = reader.int64().toBigInt();
+                    break;
+                case /* devvit.plugin.redis.TransactionId transaction_id */ 6:
+                    message.transactionId = TransactionId.internalBinaryRead(reader, reader.uint32(), options, message.transactionId);
+                    break;
+                case /* optional devvit.plugin.redis.RedisKeyScope scope */ 100:
+                    message.scope = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: HIncrByRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string key = 1; */
+        if (message.key !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.key);
+        /* string field = 2; */
+        if (message.field !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.field);
+        /* int64 value = 3; */
+        if (message.value !== 0n)
+            writer.tag(3, WireType.Varint).int64(message.value);
+        /* devvit.plugin.redis.TransactionId transaction_id = 6; */
+        if (message.transactionId)
+            TransactionId.internalBinaryWrite(message.transactionId, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* optional devvit.plugin.redis.RedisKeyScope scope = 100; */
+        if (message.scope !== undefined)
+            writer.tag(100, WireType.Varint).int32(message.scope);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.HIncrByRequest
+ */
+export const HIncrByRequest = new HIncrByRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RedisFieldValue$Type extends MessageType<RedisFieldValue> {
+    constructor() {
+        super("devvit.plugin.redis.RedisFieldValue", [
+            { no: 1, name: "field", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "value", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<RedisFieldValue>): RedisFieldValue {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.field = "";
+        message.value = "";
+        if (value !== undefined)
+            reflectionMergePartial<RedisFieldValue>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RedisFieldValue): RedisFieldValue {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string field */ 1:
+                    message.field = reader.string();
+                    break;
+                case /* string value */ 2:
+                    message.value = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: RedisFieldValue, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string field = 1; */
+        if (message.field !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.field);
+        /* string value = 2; */
+        if (message.value !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.value);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.RedisFieldValue
+ */
+export const RedisFieldValue = new RedisFieldValue$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RedisFieldValues$Type extends MessageType<RedisFieldValues> {
+    constructor() {
+        super("devvit.plugin.redis.RedisFieldValues", [
+            { no: 1, name: "field_values", kind: "map", K: 9 /*ScalarType.STRING*/, V: { kind: "scalar", T: 9 /*ScalarType.STRING*/ } }
+        ]);
+    }
+    create(value?: PartialMessage<RedisFieldValues>): RedisFieldValues {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.fieldValues = {};
+        if (value !== undefined)
+            reflectionMergePartial<RedisFieldValues>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RedisFieldValues): RedisFieldValues {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* map<string, string> field_values */ 1:
+                    this.binaryReadMap1(message.fieldValues, reader, options);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    private binaryReadMap1(map: RedisFieldValues["fieldValues"], reader: IBinaryReader, options: BinaryReadOptions): void {
+        let len = reader.uint32(), end = reader.pos + len, key: keyof RedisFieldValues["fieldValues"] | undefined, val: RedisFieldValues["fieldValues"][any] | undefined;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case 1:
+                    key = reader.string();
+                    break;
+                case 2:
+                    val = reader.string();
+                    break;
+                default: throw new globalThis.Error("unknown map entry field for field devvit.plugin.redis.RedisFieldValues.field_values");
+            }
+        }
+        map[key ?? ""] = val ?? "";
+    }
+    internalBinaryWrite(message: RedisFieldValues, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* map<string, string> field_values = 1; */
+        for (let k of globalThis.Object.keys(message.fieldValues))
+            writer.tag(1, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k).tag(2, WireType.LengthDelimited).string(message.fieldValues[k]).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.RedisFieldValues
+ */
+export const RedisFieldValues = new RedisFieldValues$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class KeyValuesRequest$Type extends MessageType<KeyValuesRequest> {
+    constructor() {
+        super("devvit.plugin.redis.KeyValuesRequest", [
+            { no: 1, name: "kv", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => RedisKeyValue },
+            { no: 2, name: "transaction_id", kind: "message", T: () => TransactionId },
+            { no: 100, name: "scope", kind: "enum", opt: true, T: () => ["devvit.plugin.redis.RedisKeyScope", RedisKeyScope] }
+        ]);
+    }
+    create(value?: PartialMessage<KeyValuesRequest>): KeyValuesRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.kv = [];
+        if (value !== undefined)
+            reflectionMergePartial<KeyValuesRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: KeyValuesRequest): KeyValuesRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated devvit.plugin.redis.RedisKeyValue kv */ 1:
+                    message.kv.push(RedisKeyValue.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* devvit.plugin.redis.TransactionId transaction_id */ 2:
+                    message.transactionId = TransactionId.internalBinaryRead(reader, reader.uint32(), options, message.transactionId);
+                    break;
+                case /* optional devvit.plugin.redis.RedisKeyScope scope */ 100:
+                    message.scope = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: KeyValuesRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated devvit.plugin.redis.RedisKeyValue kv = 1; */
+        for (let i = 0; i < message.kv.length; i++)
+            RedisKeyValue.internalBinaryWrite(message.kv[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* devvit.plugin.redis.TransactionId transaction_id = 2; */
+        if (message.transactionId)
+            TransactionId.internalBinaryWrite(message.transactionId, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* optional devvit.plugin.redis.RedisKeyScope scope = 100; */
+        if (message.scope !== undefined)
+            writer.tag(100, WireType.Varint).int32(message.scope);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.KeyValuesRequest
+ */
+export const KeyValuesRequest = new KeyValuesRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RedisKeyValue$Type extends MessageType<RedisKeyValue> {
+    constructor() {
+        super("devvit.plugin.redis.RedisKeyValue", [
+            { no: 1, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "value", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<RedisKeyValue>): RedisKeyValue {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.key = "";
+        message.value = "";
+        if (value !== undefined)
+            reflectionMergePartial<RedisKeyValue>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RedisKeyValue): RedisKeyValue {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string key */ 1:
+                    message.key = reader.string();
+                    break;
+                case /* string value */ 2:
+                    message.value = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: RedisKeyValue, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string key = 1; */
+        if (message.key !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.key);
+        /* string value = 2; */
+        if (message.value !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.value);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.RedisKeyValue
+ */
+export const RedisKeyValue = new RedisKeyValue$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RedisValues$Type extends MessageType<RedisValues> {
+    constructor() {
+        super("devvit.plugin.redis.RedisValues", [
+            { no: 1, name: "values", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => StringValue }
+        ]);
+    }
+    create(value?: PartialMessage<RedisValues>): RedisValues {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.values = [];
+        if (value !== undefined)
+            reflectionMergePartial<RedisValues>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RedisValues): RedisValues {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated google.protobuf.StringValue values */ 1:
+                    message.values.push(StringValue.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: RedisValues, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated google.protobuf.StringValue values = 1; */
+        for (let i = 0; i < message.values.length; i++)
+            StringValue.internalBinaryWrite(message.values[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.RedisValues
+ */
+export const RedisValues = new RedisValues$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExpireRequest$Type extends MessageType<ExpireRequest> {
+    constructor() {
+        super("devvit.plugin.redis.ExpireRequest", [
+            { no: 1, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "seconds", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 3, name: "transaction_id", kind: "message", T: () => TransactionId },
+            { no: 100, name: "scope", kind: "enum", opt: true, T: () => ["devvit.plugin.redis.RedisKeyScope", RedisKeyScope] }
+        ]);
+    }
+    create(value?: PartialMessage<ExpireRequest>): ExpireRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.key = "";
+        message.seconds = 0;
+        if (value !== undefined)
+            reflectionMergePartial<ExpireRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExpireRequest): ExpireRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string key */ 1:
+                    message.key = reader.string();
+                    break;
+                case /* int32 seconds */ 2:
+                    message.seconds = reader.int32();
+                    break;
+                case /* devvit.plugin.redis.TransactionId transaction_id */ 3:
+                    message.transactionId = TransactionId.internalBinaryRead(reader, reader.uint32(), options, message.transactionId);
+                    break;
+                case /* optional devvit.plugin.redis.RedisKeyScope scope */ 100:
+                    message.scope = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ExpireRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string key = 1; */
+        if (message.key !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.key);
+        /* int32 seconds = 2; */
+        if (message.seconds !== 0)
+            writer.tag(2, WireType.Varint).int32(message.seconds);
+        /* devvit.plugin.redis.TransactionId transaction_id = 3; */
+        if (message.transactionId)
+            TransactionId.internalBinaryWrite(message.transactionId, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* optional devvit.plugin.redis.RedisKeyScope scope = 100; */
+        if (message.scope !== undefined)
+            writer.tag(100, WireType.Varint).int32(message.scope);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.ExpireRequest
+ */
+export const ExpireRequest = new ExpireRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ZAddRequest$Type extends MessageType<ZAddRequest> {
+    constructor() {
+        super("devvit.plugin.redis.ZAddRequest", [
+            { no: 1, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "members", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => ZMember },
+            { no: 3, name: "transaction_id", kind: "message", T: () => TransactionId },
+            { no: 100, name: "scope", kind: "enum", opt: true, T: () => ["devvit.plugin.redis.RedisKeyScope", RedisKeyScope] }
+        ]);
+    }
+    create(value?: PartialMessage<ZAddRequest>): ZAddRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.key = "";
+        message.members = [];
+        if (value !== undefined)
+            reflectionMergePartial<ZAddRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ZAddRequest): ZAddRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string key */ 1:
+                    message.key = reader.string();
+                    break;
+                case /* repeated devvit.plugin.redis.ZMember members */ 2:
+                    message.members.push(ZMember.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* devvit.plugin.redis.TransactionId transaction_id */ 3:
+                    message.transactionId = TransactionId.internalBinaryRead(reader, reader.uint32(), options, message.transactionId);
+                    break;
+                case /* optional devvit.plugin.redis.RedisKeyScope scope */ 100:
+                    message.scope = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ZAddRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string key = 1; */
+        if (message.key !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.key);
+        /* repeated devvit.plugin.redis.ZMember members = 2; */
+        for (let i = 0; i < message.members.length; i++)
+            ZMember.internalBinaryWrite(message.members[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* devvit.plugin.redis.TransactionId transaction_id = 3; */
+        if (message.transactionId)
+            TransactionId.internalBinaryWrite(message.transactionId, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* optional devvit.plugin.redis.RedisKeyScope scope = 100; */
+        if (message.scope !== undefined)
+            writer.tag(100, WireType.Varint).int32(message.scope);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.ZAddRequest
+ */
+export const ZAddRequest = new ZAddRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ZScanRequest$Type extends MessageType<ZScanRequest> {
+    constructor() {
+        super("devvit.plugin.redis.ZScanRequest", [
+            { no: 1, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "cursor", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 3, name: "pattern", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "count", kind: "scalar", opt: true, T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 5, name: "transaction_id", kind: "message", T: () => TransactionId },
+            { no: 100, name: "scope", kind: "enum", opt: true, T: () => ["devvit.plugin.redis.RedisKeyScope", RedisKeyScope] }
+        ]);
+    }
+    create(value?: PartialMessage<ZScanRequest>): ZScanRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.key = "";
+        message.cursor = 0n;
+        if (value !== undefined)
+            reflectionMergePartial<ZScanRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ZScanRequest): ZScanRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string key */ 1:
+                    message.key = reader.string();
+                    break;
+                case /* uint64 cursor */ 2:
+                    message.cursor = reader.uint64().toBigInt();
+                    break;
+                case /* optional string pattern */ 3:
+                    message.pattern = reader.string();
+                    break;
+                case /* optional int64 count */ 4:
+                    message.count = reader.int64().toBigInt();
+                    break;
+                case /* devvit.plugin.redis.TransactionId transaction_id */ 5:
+                    message.transactionId = TransactionId.internalBinaryRead(reader, reader.uint32(), options, message.transactionId);
+                    break;
+                case /* optional devvit.plugin.redis.RedisKeyScope scope */ 100:
+                    message.scope = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ZScanRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string key = 1; */
+        if (message.key !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.key);
+        /* uint64 cursor = 2; */
+        if (message.cursor !== 0n)
+            writer.tag(2, WireType.Varint).uint64(message.cursor);
+        /* optional string pattern = 3; */
+        if (message.pattern !== undefined)
+            writer.tag(3, WireType.LengthDelimited).string(message.pattern);
+        /* optional int64 count = 4; */
+        if (message.count !== undefined)
+            writer.tag(4, WireType.Varint).int64(message.count);
+        /* devvit.plugin.redis.TransactionId transaction_id = 5; */
+        if (message.transactionId)
+            TransactionId.internalBinaryWrite(message.transactionId, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* optional devvit.plugin.redis.RedisKeyScope scope = 100; */
+        if (message.scope !== undefined)
+            writer.tag(100, WireType.Varint).int32(message.scope);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.ZScanRequest
+ */
+export const ZScanRequest = new ZScanRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ZScanResponse$Type extends MessageType<ZScanResponse> {
+    constructor() {
+        super("devvit.plugin.redis.ZScanResponse", [
+            { no: 1, name: "cursor", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "members", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => ZMember }
+        ]);
+    }
+    create(value?: PartialMessage<ZScanResponse>): ZScanResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.cursor = 0n;
+        message.members = [];
+        if (value !== undefined)
+            reflectionMergePartial<ZScanResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ZScanResponse): ZScanResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* uint64 cursor */ 1:
+                    message.cursor = reader.uint64().toBigInt();
+                    break;
+                case /* repeated devvit.plugin.redis.ZMember members */ 2:
+                    message.members.push(ZMember.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ZScanResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* uint64 cursor = 1; */
+        if (message.cursor !== 0n)
+            writer.tag(1, WireType.Varint).uint64(message.cursor);
+        /* repeated devvit.plugin.redis.ZMember members = 2; */
+        for (let i = 0; i < message.members.length; i++)
+            ZMember.internalBinaryWrite(message.members[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.ZScanResponse
+ */
+export const ZScanResponse = new ZScanResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ZMembers$Type extends MessageType<ZMembers> {
+    constructor() {
+        super("devvit.plugin.redis.ZMembers", [
+            { no: 1, name: "members", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => ZMember }
+        ]);
+    }
+    create(value?: PartialMessage<ZMembers>): ZMembers {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.members = [];
+        if (value !== undefined)
+            reflectionMergePartial<ZMembers>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ZMembers): ZMembers {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated devvit.plugin.redis.ZMember members */ 1:
+                    message.members.push(ZMember.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ZMembers, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated devvit.plugin.redis.ZMember members = 1; */
+        for (let i = 0; i < message.members.length; i++)
+            ZMember.internalBinaryWrite(message.members[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.ZMembers
+ */
+export const ZMembers = new ZMembers$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ZMember$Type extends MessageType<ZMember> {
+    constructor() {
+        super("devvit.plugin.redis.ZMember", [
+            { no: 1, name: "score", kind: "scalar", T: 1 /*ScalarType.DOUBLE*/ },
+            { no: 2, name: "member", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<ZMember>): ZMember {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.score = 0;
+        message.member = "";
+        if (value !== undefined)
+            reflectionMergePartial<ZMember>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ZMember): ZMember {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* double score */ 1:
+                    message.score = reader.double();
+                    break;
+                case /* string member */ 2:
+                    message.member = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ZMember, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* double score = 1; */
+        if (message.score !== 0)
+            writer.tag(1, WireType.Bit64).double(message.score);
+        /* string member = 2; */
+        if (message.member !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.member);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.ZMember
+ */
+export const ZMember = new ZMember$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TransactionId$Type extends MessageType<TransactionId> {
+    constructor() {
+        super("devvit.plugin.redis.TransactionId", [
+            { no: 1, name: "id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<TransactionId>): TransactionId {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.id = "";
+        if (value !== undefined)
+            reflectionMergePartial<TransactionId>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TransactionId): TransactionId {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string id */ 1:
+                    message.id = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: TransactionId, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string id = 1; */
+        if (message.id !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.id);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.TransactionId
+ */
+export const TransactionId = new TransactionId$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class WatchRequest$Type extends MessageType<WatchRequest> {
+    constructor() {
+        super("devvit.plugin.redis.WatchRequest", [
+            { no: 1, name: "transaction_id", kind: "message", T: () => TransactionId },
+            { no: 2, name: "keys", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<WatchRequest>): WatchRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.keys = [];
+        if (value !== undefined)
+            reflectionMergePartial<WatchRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: WatchRequest): WatchRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* devvit.plugin.redis.TransactionId transaction_id */ 1:
+                    message.transactionId = TransactionId.internalBinaryRead(reader, reader.uint32(), options, message.transactionId);
+                    break;
+                case /* repeated string keys */ 2:
+                    message.keys.push(reader.string());
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: WatchRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* devvit.plugin.redis.TransactionId transaction_id = 1; */
+        if (message.transactionId)
+            TransactionId.internalBinaryWrite(message.transactionId, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* repeated string keys = 2; */
+        for (let i = 0; i < message.keys.length; i++)
+            writer.tag(2, WireType.LengthDelimited).string(message.keys[i]);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.redis.WatchRequest
+ */
+export const WatchRequest = new WatchRequest$Type();
+/**
+ * @generated ServiceType for protobuf service devvit.plugin.redis.RedisAPI
+ */
+export const RedisAPI = new ServiceType("devvit.plugin.redis.RedisAPI", [
+    { name: "Get", options: {}, I: KeyRequest, O: StringValue },
+    { name: "Set", options: {}, I: SetRequest, O: StringValue },
+    { name: "Del", options: {}, I: KeysRequest, O: Int64Value },
+    { name: "Type", options: {}, I: KeyRequest, O: StringValue },
+    { name: "IncrBy", options: {}, I: IncrByRequest, O: Int64Value },
+    { name: "HSet", options: {}, I: HSetRequest, O: Int64Value },
+    { name: "HGet", options: {}, I: HGetRequest, O: StringValue },
+    { name: "HGetAll", options: {}, I: KeyRequest, O: RedisFieldValues },
+    { name: "HDel", options: {}, I: HDelRequest, O: Int64Value },
+    { name: "HScan", options: {}, I: HScanRequest, O: HScanResponse },
+    { name: "HKeys", options: {}, I: KeyRequest, O: KeysResponse },
+    { name: "HIncrBy", options: {}, I: HIncrByRequest, O: Int64Value },
+    { name: "HLen", options: {}, I: KeyRequest, O: Int64Value },
+    { name: "Multi", options: {}, I: TransactionId, O: Empty },
+    { name: "Exec", options: {}, I: TransactionId, O: TransactionResponses },
+    { name: "Discard", options: {}, I: TransactionId, O: Empty },
+    { name: "Watch", options: {}, I: WatchRequest, O: TransactionId },
+    { name: "Unwatch", options: {}, I: TransactionId, O: Empty },
+    { name: "GetRange", options: {}, I: KeyRangeRequest, O: StringValue },
+    { name: "SetRange", options: {}, I: SetRangeRequest, O: Int64Value },
+    { name: "Strlen", options: {}, I: KeyRequest, O: Int64Value },
+    { name: "MGet", options: {}, I: KeysRequest, O: RedisValues },
+    { name: "MSet", options: {}, I: KeyValuesRequest, O: Empty },
+    { name: "Expire", options: {}, I: ExpireRequest, O: Empty },
+    { name: "ExpireTime", options: {}, I: KeyRequest, O: Int64Value },
+    { name: "ZAdd", options: {}, I: ZAddRequest, O: Int64Value },
+    { name: "ZCard", options: {}, I: KeyRequest, O: Int64Value },
+    { name: "ZRange", options: {}, I: ZRangeRequest, O: ZMembers },
+    { name: "ZRem", options: {}, I: ZRemRequest, O: Int64Value },
+    { name: "ZRemRangeByLex", options: {}, I: ZRemRangeByLexRequest, O: Int64Value },
+    { name: "ZRemRangeByRank", options: {}, I: ZRemRangeByRankRequest, O: Int64Value },
+    { name: "ZRemRangeByScore", options: {}, I: ZRemRangeByScoreRequest, O: Int64Value },
+    { name: "ZScore", options: {}, I: ZScoreRequest, O: DoubleValue },
+    { name: "ZRank", options: {}, I: ZRankRequest, O: Int64Value },
+    { name: "ZIncrBy", options: {}, I: ZIncrByRequest, O: DoubleValue },
+    { name: "ZScan", options: {}, I: ZScanRequest, O: ZScanResponse }
+]);