@0xobelisk/grpc-client 1.2.0-pre.68

package/dist/index.mjs

@@ -0,0 +1,1682 @@
+// src/proto/dubhe_grpc.ts
+import { ServiceType } from "@protobuf-ts/runtime-rpc";
+import { WireType as WireType2 } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler as UnknownFieldHandler2 } from "@protobuf-ts/runtime";
+import { reflectionMergePartial as reflectionMergePartial2 } from "@protobuf-ts/runtime";
+import { MessageType as MessageType2 } from "@protobuf-ts/runtime";
+
+// src/proto/google/protobuf/struct.ts
+import { WireType } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { isJsonObject } from "@protobuf-ts/runtime";
+import { typeofJsonValue } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+var NullValue = /* @__PURE__ */ ((NullValue2) => {
+  NullValue2[NullValue2["NULL_VALUE"] = 0] = "NULL_VALUE";
+  return NullValue2;
+})(NullValue || {});
+var Struct$Type = class extends MessageType {
+  constructor() {
+    super("google.protobuf.Struct", [
+      {
+        no: 1,
+        name: "fields",
+        kind: "map",
+        K: 9,
+        V: { kind: "message", T: () => Value }
+      }
+    ]);
+  }
+  /**
+   * Encode `Struct` to JSON object.
+   */
+  internalJsonWrite(message, options) {
+    let json = {};
+    for (let [k, v] of Object.entries(message.fields)) {
+      json[k] = Value.toJson(v);
+    }
+    return json;
+  }
+  /**
+   * Decode `Struct` from JSON object.
+   */
+  internalJsonRead(json, options, target) {
+    if (!isJsonObject(json))
+      throw new globalThis.Error(
+        "Unable to parse message " + this.typeName + " from JSON " + typeofJsonValue(json) + "."
+      );
+    if (!target)
+      target = this.create();
+    for (let [k, v] of globalThis.Object.entries(json)) {
+      target.fields[k] = Value.fromJson(v);
+    }
+    return target;
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.fields = {};
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* map<string, google.protobuf.Value> fields */
+        1:
+          this.binaryReadMap1(message.fields, 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;
+  }
+  binaryReadMap1(map, reader, options) {
+    let len = reader.uint32(), end = reader.pos + len, key, val;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          key = reader.string();
+          break;
+        case 2:
+          val = Value.internalBinaryRead(reader, reader.uint32(), options);
+          break;
+        default:
+          throw new globalThis.Error("unknown map entry field for google.protobuf.Struct.fields");
+      }
+    }
+    map[key ?? ""] = val ?? Value.create();
+  }
+  internalBinaryWrite(message, writer, options) {
+    for (let k of globalThis.Object.keys(message.fields)) {
+      writer.tag(1, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k);
+      writer.tag(2, WireType.LengthDelimited).fork();
+      Value.internalBinaryWrite(message.fields[k], writer, options);
+      writer.join().join();
+    }
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var Struct = new Struct$Type();
+var Value$Type = class extends MessageType {
+  constructor() {
+    super("google.protobuf.Value", [
+      {
+        no: 1,
+        name: "null_value",
+        kind: "enum",
+        oneof: "kind",
+        T: () => ["google.protobuf.NullValue", NullValue]
+      },
+      {
+        no: 2,
+        name: "number_value",
+        kind: "scalar",
+        oneof: "kind",
+        T: 1
+        /*ScalarType.DOUBLE*/
+      },
+      {
+        no: 3,
+        name: "string_value",
+        kind: "scalar",
+        oneof: "kind",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 4,
+        name: "bool_value",
+        kind: "scalar",
+        oneof: "kind",
+        T: 8
+        /*ScalarType.BOOL*/
+      },
+      { no: 5, name: "struct_value", kind: "message", oneof: "kind", T: () => Struct },
+      { no: 6, name: "list_value", kind: "message", oneof: "kind", T: () => ListValue }
+    ]);
+  }
+  /**
+   * Encode `Value` to JSON value.
+   */
+  internalJsonWrite(message, options) {
+    if (message.kind.oneofKind === void 0)
+      throw new globalThis.Error();
+    switch (message.kind.oneofKind) {
+      case void 0:
+        throw new globalThis.Error();
+      case "boolValue":
+        return message.kind.boolValue;
+      case "nullValue":
+        return null;
+      case "numberValue":
+        let numberValue = message.kind.numberValue;
+        if (typeof numberValue == "number" && !Number.isFinite(numberValue))
+          throw new globalThis.Error();
+        return numberValue;
+      case "stringValue":
+        return message.kind.stringValue;
+      case "listValue":
+        let listValueField = this.fields.find((f) => f.no === 6);
+        if (listValueField?.kind !== "message")
+          throw new globalThis.Error();
+        return listValueField.T().toJson(message.kind.listValue);
+      case "structValue":
+        let structValueField = this.fields.find((f) => f.no === 5);
+        if (structValueField?.kind !== "message")
+          throw new globalThis.Error();
+        return structValueField.T().toJson(message.kind.structValue);
+    }
+  }
+  /**
+   * Decode `Value` from JSON value.
+   */
+  internalJsonRead(json, options, target) {
+    if (!target)
+      target = this.create();
+    switch (typeof json) {
+      case "number":
+        target.kind = { oneofKind: "numberValue", numberValue: json };
+        break;
+      case "string":
+        target.kind = { oneofKind: "stringValue", stringValue: json };
+        break;
+      case "boolean":
+        target.kind = { oneofKind: "boolValue", boolValue: json };
+        break;
+      case "object":
+        if (json === null) {
+          target.kind = { oneofKind: "nullValue", nullValue: 0 /* NULL_VALUE */ };
+        } else if (globalThis.Array.isArray(json)) {
+          target.kind = { oneofKind: "listValue", listValue: ListValue.fromJson(json) };
+        } else {
+          target.kind = { oneofKind: "structValue", structValue: Struct.fromJson(json) };
+        }
+        break;
+      default:
+        throw new globalThis.Error(
+          "Unable to parse " + this.typeName + " from JSON " + typeofJsonValue(json)
+        );
+    }
+    return target;
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.kind = { oneofKind: void 0 };
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* google.protobuf.NullValue null_value */
+        1:
+          message.kind = {
+            oneofKind: "nullValue",
+            nullValue: reader.int32()
+          };
+          break;
+        case /* double number_value */
+        2:
+          message.kind = {
+            oneofKind: "numberValue",
+            numberValue: reader.double()
+          };
+          break;
+        case /* string string_value */
+        3:
+          message.kind = {
+            oneofKind: "stringValue",
+            stringValue: reader.string()
+          };
+          break;
+        case /* bool bool_value */
+        4:
+          message.kind = {
+            oneofKind: "boolValue",
+            boolValue: reader.bool()
+          };
+          break;
+        case /* google.protobuf.Struct struct_value */
+        5:
+          message.kind = {
+            oneofKind: "structValue",
+            structValue: Struct.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options,
+              message.kind.structValue
+            )
+          };
+          break;
+        case /* google.protobuf.ListValue list_value */
+        6:
+          message.kind = {
+            oneofKind: "listValue",
+            listValue: ListValue.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options,
+              message.kind.listValue
+            )
+          };
+          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, writer, options) {
+    if (message.kind.oneofKind === "nullValue")
+      writer.tag(1, WireType.Varint).int32(message.kind.nullValue);
+    if (message.kind.oneofKind === "numberValue")
+      writer.tag(2, WireType.Bit64).double(message.kind.numberValue);
+    if (message.kind.oneofKind === "stringValue")
+      writer.tag(3, WireType.LengthDelimited).string(message.kind.stringValue);
+    if (message.kind.oneofKind === "boolValue")
+      writer.tag(4, WireType.Varint).bool(message.kind.boolValue);
+    if (message.kind.oneofKind === "structValue")
+      Struct.internalBinaryWrite(
+        message.kind.structValue,
+        writer.tag(5, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.kind.oneofKind === "listValue")
+      ListValue.internalBinaryWrite(
+        message.kind.listValue,
+        writer.tag(6, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var Value = new Value$Type();
+var ListValue$Type = class extends MessageType {
+  constructor() {
+    super("google.protobuf.ListValue", [
+      { no: 1, name: "values", kind: "message", repeat: 2, T: () => Value }
+    ]);
+  }
+  /**
+   * Encode `ListValue` to JSON array.
+   */
+  internalJsonWrite(message, options) {
+    return message.values.map((v) => Value.toJson(v));
+  }
+  /**
+   * Decode `ListValue` from JSON array.
+   */
+  internalJsonRead(json, options, target) {
+    if (!globalThis.Array.isArray(json))
+      throw new globalThis.Error(
+        "Unable to parse " + this.typeName + " from JSON " + typeofJsonValue(json)
+      );
+    if (!target)
+      target = this.create();
+    let values = json.map((v) => Value.fromJson(v));
+    target.values.push(...values);
+    return target;
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.values = [];
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* repeated google.protobuf.Value values */
+        1:
+          message.values.push(Value.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, writer, options) {
+    for (let i = 0; i < message.values.length; i++)
+      Value.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;
+  }
+};
+var ListValue = new ListValue$Type();
+
+// src/proto/dubhe_grpc.ts
+var FilterOperator = /* @__PURE__ */ ((FilterOperator2) => {
+  FilterOperator2[FilterOperator2["EQUALS"] = 0] = "EQUALS";
+  FilterOperator2[FilterOperator2["NOT_EQUALS"] = 1] = "NOT_EQUALS";
+  FilterOperator2[FilterOperator2["GREATER_THAN"] = 2] = "GREATER_THAN";
+  FilterOperator2[FilterOperator2["GREATER_THAN_EQUAL"] = 3] = "GREATER_THAN_EQUAL";
+  FilterOperator2[FilterOperator2["LESS_THAN"] = 4] = "LESS_THAN";
+  FilterOperator2[FilterOperator2["LESS_THAN_EQUAL"] = 5] = "LESS_THAN_EQUAL";
+  FilterOperator2[FilterOperator2["LIKE"] = 6] = "LIKE";
+  FilterOperator2[FilterOperator2["NOT_LIKE"] = 7] = "NOT_LIKE";
+  FilterOperator2[FilterOperator2["IN"] = 8] = "IN";
+  FilterOperator2[FilterOperator2["NOT_IN"] = 9] = "NOT_IN";
+  FilterOperator2[FilterOperator2["IS_NULL"] = 10] = "IS_NULL";
+  FilterOperator2[FilterOperator2["IS_NOT_NULL"] = 11] = "IS_NOT_NULL";
+  FilterOperator2[FilterOperator2["BETWEEN"] = 12] = "BETWEEN";
+  FilterOperator2[FilterOperator2["NOT_BETWEEN"] = 13] = "NOT_BETWEEN";
+  return FilterOperator2;
+})(FilterOperator || {});
+var SortDirection = /* @__PURE__ */ ((SortDirection2) => {
+  SortDirection2[SortDirection2["ASCENDING"] = 0] = "ASCENDING";
+  SortDirection2[SortDirection2["DESCENDING"] = 1] = "DESCENDING";
+  return SortDirection2;
+})(SortDirection || {});
+var QueryRequest$Type = class extends MessageType2 {
+  constructor() {
+    super("dubhe_grpc.QueryRequest", [
+      {
+        no: 1,
+        name: "table_name",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "select_fields",
+        kind: "scalar",
+        repeat: 2,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "filters",
+        kind: "message",
+        repeat: 2,
+        T: () => FilterCondition
+      },
+      {
+        no: 4,
+        name: "sorts",
+        kind: "message",
+        repeat: 2,
+        T: () => SortSpecification
+      },
+      { no: 5, name: "pagination", kind: "message", T: () => PaginationRequest },
+      {
+        no: 6,
+        name: "include_total_count",
+        kind: "scalar",
+        T: 8
+        /*ScalarType.BOOL*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.tableName = "";
+    message.selectFields = [];
+    message.filters = [];
+    message.sorts = [];
+    message.includeTotalCount = false;
+    if (value !== void 0)
+      reflectionMergePartial2(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string table_name */
+        1:
+          message.tableName = reader.string();
+          break;
+        case /* repeated string select_fields */
+        2:
+          message.selectFields.push(reader.string());
+          break;
+        case /* repeated dubhe_grpc.FilterCondition filters */
+        3:
+          message.filters.push(
+            FilterCondition.internalBinaryRead(reader, reader.uint32(), options)
+          );
+          break;
+        case /* repeated dubhe_grpc.SortSpecification sorts */
+        4:
+          message.sorts.push(
+            SortSpecification.internalBinaryRead(reader, reader.uint32(), options)
+          );
+          break;
+        case /* optional dubhe_grpc.PaginationRequest pagination */
+        5:
+          message.pagination = PaginationRequest.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.pagination
+          );
+          break;
+        case /* bool include_total_count */
+        6:
+          message.includeTotalCount = reader.bool();
+          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 ? UnknownFieldHandler2.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.tableName !== "")
+      writer.tag(1, WireType2.LengthDelimited).string(message.tableName);
+    for (let i = 0; i < message.selectFields.length; i++)
+      writer.tag(2, WireType2.LengthDelimited).string(message.selectFields[i]);
+    for (let i = 0; i < message.filters.length; i++)
+      FilterCondition.internalBinaryWrite(
+        message.filters[i],
+        writer.tag(3, WireType2.LengthDelimited).fork(),
+        options
+      ).join();
+    for (let i = 0; i < message.sorts.length; i++)
+      SortSpecification.internalBinaryWrite(
+        message.sorts[i],
+        writer.tag(4, WireType2.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.pagination)
+      PaginationRequest.internalBinaryWrite(
+        message.pagination,
+        writer.tag(5, WireType2.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.includeTotalCount !== false)
+      writer.tag(6, WireType2.Varint).bool(message.includeTotalCount);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler2.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var QueryRequest = new QueryRequest$Type();
+var FilterCondition$Type = class extends MessageType2 {
+  constructor() {
+    super("dubhe_grpc.FilterCondition", [
+      {
+        no: 1,
+        name: "field_name",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "operator",
+        kind: "enum",
+        T: () => ["dubhe_grpc.FilterOperator", FilterOperator]
+      },
+      { no: 3, name: "value", kind: "message", T: () => FilterValue }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.fieldName = "";
+    message.operator = 0;
+    if (value !== void 0)
+      reflectionMergePartial2(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string field_name */
+        1:
+          message.fieldName = reader.string();
+          break;
+        case /* dubhe_grpc.FilterOperator operator */
+        2:
+          message.operator = reader.int32();
+          break;
+        case /* dubhe_grpc.FilterValue value */
+        3:
+          message.value = FilterValue.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.value
+          );
+          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 ? UnknownFieldHandler2.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.fieldName !== "")
+      writer.tag(1, WireType2.LengthDelimited).string(message.fieldName);
+    if (message.operator !== 0)
+      writer.tag(2, WireType2.Varint).int32(message.operator);
+    if (message.value)
+      FilterValue.internalBinaryWrite(
+        message.value,
+        writer.tag(3, WireType2.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler2.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var FilterCondition = new FilterCondition$Type();
+var FilterValue$Type = class extends MessageType2 {
+  constructor() {
+    super("dubhe_grpc.FilterValue", [
+      {
+        no: 1,
+        name: "string_value",
+        kind: "scalar",
+        oneof: "value",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "int_value",
+        kind: "scalar",
+        oneof: "value",
+        T: 3,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 3,
+        name: "float_value",
+        kind: "scalar",
+        oneof: "value",
+        T: 1
+        /*ScalarType.DOUBLE*/
+      },
+      {
+        no: 4,
+        name: "bool_value",
+        kind: "scalar",
+        oneof: "value",
+        T: 8
+        /*ScalarType.BOOL*/
+      },
+      { no: 5, name: "string_list", kind: "message", oneof: "value", T: () => StringList },
+      { no: 6, name: "int_list", kind: "message", oneof: "value", T: () => IntList },
+      { no: 7, name: "range", kind: "message", oneof: "value", T: () => ValueRange },
+      {
+        no: 8,
+        name: "null_value",
+        kind: "scalar",
+        oneof: "value",
+        T: 8
+        /*ScalarType.BOOL*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.value = { oneofKind: void 0 };
+    if (value !== void 0)
+      reflectionMergePartial2(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string string_value */
+        1:
+          message.value = {
+            oneofKind: "stringValue",
+            stringValue: reader.string()
+          };
+          break;
+        case /* int64 int_value */
+        2:
+          message.value = {
+            oneofKind: "intValue",
+            intValue: reader.int64().toBigInt()
+          };
+          break;
+        case /* double float_value */
+        3:
+          message.value = {
+            oneofKind: "floatValue",
+            floatValue: reader.double()
+          };
+          break;
+        case /* bool bool_value */
+        4:
+          message.value = {
+            oneofKind: "boolValue",
+            boolValue: reader.bool()
+          };
+          break;
+        case /* dubhe_grpc.StringList string_list */
+        5:
+          message.value = {
+            oneofKind: "stringList",
+            stringList: StringList.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options,
+              message.value.stringList
+            )
+          };
+          break;
+        case /* dubhe_grpc.IntList int_list */
+        6:
+          message.value = {
+            oneofKind: "intList",
+            intList: IntList.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options,
+              message.value.intList
+            )
+          };
+          break;
+        case /* dubhe_grpc.ValueRange range */
+        7:
+          message.value = {
+            oneofKind: "range",
+            range: ValueRange.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options,
+              message.value.range
+            )
+          };
+          break;
+        case /* bool null_value */
+        8:
+          message.value = {
+            oneofKind: "nullValue",
+            nullValue: reader.bool()
+          };
+          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 ? UnknownFieldHandler2.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.value.oneofKind === "stringValue")
+      writer.tag(1, WireType2.LengthDelimited).string(message.value.stringValue);
+    if (message.value.oneofKind === "intValue")
+      writer.tag(2, WireType2.Varint).int64(message.value.intValue);
+    if (message.value.oneofKind === "floatValue")
+      writer.tag(3, WireType2.Bit64).double(message.value.floatValue);
+    if (message.value.oneofKind === "boolValue")
+      writer.tag(4, WireType2.Varint).bool(message.value.boolValue);
+    if (message.value.oneofKind === "stringList")
+      StringList.internalBinaryWrite(
+        message.value.stringList,
+        writer.tag(5, WireType2.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.value.oneofKind === "intList")
+      IntList.internalBinaryWrite(
+        message.value.intList,
+        writer.tag(6, WireType2.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.value.oneofKind === "range")
+      ValueRange.internalBinaryWrite(
+        message.value.range,
+        writer.tag(7, WireType2.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.value.oneofKind === "nullValue")
+      writer.tag(8, WireType2.Varint).bool(message.value.nullValue);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler2.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var FilterValue = new FilterValue$Type();
+var StringList$Type = class extends MessageType2 {
+  constructor() {
+    super("dubhe_grpc.StringList", [
+      {
+        no: 1,
+        name: "values",
+        kind: "scalar",
+        repeat: 2,
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.values = [];
+    if (value !== void 0)
+      reflectionMergePartial2(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* repeated string values */
+        1:
+          message.values.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 ? UnknownFieldHandler2.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    for (let i = 0; i < message.values.length; i++)
+      writer.tag(1, WireType2.LengthDelimited).string(message.values[i]);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler2.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var StringList = new StringList$Type();
+var IntList$Type = class extends MessageType2 {
+  constructor() {
+    super("dubhe_grpc.IntList", [
+      {
+        no: 1,
+        name: "values",
+        kind: "scalar",
+        repeat: 1,
+        T: 3,
+        L: 0
+        /*LongType.BIGINT*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.values = [];
+    if (value !== void 0)
+      reflectionMergePartial2(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* repeated int64 values */
+        1:
+          if (wireType === WireType2.LengthDelimited)
+            for (let e = reader.int32() + reader.pos; reader.pos < e; )
+              message.values.push(reader.int64().toBigInt());
+          else
+            message.values.push(reader.int64().toBigInt());
+          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 ? UnknownFieldHandler2.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.values.length) {
+      writer.tag(1, WireType2.LengthDelimited).fork();
+      for (let i = 0; i < message.values.length; i++)
+        writer.int64(message.values[i]);
+      writer.join();
+    }
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler2.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var IntList = new IntList$Type();
+var ValueRange$Type = class extends MessageType2 {
+  constructor() {
+    super("dubhe_grpc.ValueRange", [
+      {
+        no: 1,
+        name: "string_start",
+        kind: "scalar",
+        oneof: "start",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "int_start",
+        kind: "scalar",
+        oneof: "start",
+        T: 3,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 3,
+        name: "float_start",
+        kind: "scalar",
+        oneof: "start",
+        T: 1
+        /*ScalarType.DOUBLE*/
+      },
+      {
+        no: 4,
+        name: "string_end",
+        kind: "scalar",
+        oneof: "end",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 5,
+        name: "int_end",
+        kind: "scalar",
+        oneof: "end",
+        T: 3,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 6,
+        name: "float_end",
+        kind: "scalar",
+        oneof: "end",
+        T: 1
+        /*ScalarType.DOUBLE*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.start = { oneofKind: void 0 };
+    message.end = { oneofKind: void 0 };
+    if (value !== void 0)
+      reflectionMergePartial2(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string string_start */
+        1:
+          message.start = {
+            oneofKind: "stringStart",
+            stringStart: reader.string()
+          };
+          break;
+        case /* int64 int_start */
+        2:
+          message.start = {
+            oneofKind: "intStart",
+            intStart: reader.int64().toBigInt()
+          };
+          break;
+        case /* double float_start */
+        3:
+          message.start = {
+            oneofKind: "floatStart",
+            floatStart: reader.double()
+          };
+          break;
+        case /* string string_end */
+        4:
+          message.end = {
+            oneofKind: "stringEnd",
+            stringEnd: reader.string()
+          };
+          break;
+        case /* int64 int_end */
+        5:
+          message.end = {
+            oneofKind: "intEnd",
+            intEnd: reader.int64().toBigInt()
+          };
+          break;
+        case /* double float_end */
+        6:
+          message.end = {
+            oneofKind: "floatEnd",
+            floatEnd: reader.double()
+          };
+          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 ? UnknownFieldHandler2.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.start.oneofKind === "stringStart")
+      writer.tag(1, WireType2.LengthDelimited).string(message.start.stringStart);
+    if (message.start.oneofKind === "intStart")
+      writer.tag(2, WireType2.Varint).int64(message.start.intStart);
+    if (message.start.oneofKind === "floatStart")
+      writer.tag(3, WireType2.Bit64).double(message.start.floatStart);
+    if (message.end.oneofKind === "stringEnd")
+      writer.tag(4, WireType2.LengthDelimited).string(message.end.stringEnd);
+    if (message.end.oneofKind === "intEnd")
+      writer.tag(5, WireType2.Varint).int64(message.end.intEnd);
+    if (message.end.oneofKind === "floatEnd")
+      writer.tag(6, WireType2.Bit64).double(message.end.floatEnd);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler2.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var ValueRange = new ValueRange$Type();
+var SortSpecification$Type = class extends MessageType2 {
+  constructor() {
+    super("dubhe_grpc.SortSpecification", [
+      {
+        no: 1,
+        name: "field_name",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "direction",
+        kind: "enum",
+        T: () => ["dubhe_grpc.SortDirection", SortDirection]
+      },
+      {
+        no: 3,
+        name: "priority",
+        kind: "scalar",
+        opt: true,
+        T: 5
+        /*ScalarType.INT32*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.fieldName = "";
+    message.direction = 0;
+    if (value !== void 0)
+      reflectionMergePartial2(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string field_name */
+        1:
+          message.fieldName = reader.string();
+          break;
+        case /* dubhe_grpc.SortDirection direction */
+        2:
+          message.direction = reader.int32();
+          break;
+        case /* optional int32 priority */
+        3:
+          message.priority = 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 ? UnknownFieldHandler2.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.fieldName !== "")
+      writer.tag(1, WireType2.LengthDelimited).string(message.fieldName);
+    if (message.direction !== 0)
+      writer.tag(2, WireType2.Varint).int32(message.direction);
+    if (message.priority !== void 0)
+      writer.tag(3, WireType2.Varint).int32(message.priority);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler2.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var SortSpecification = new SortSpecification$Type();
+var PaginationRequest$Type = class extends MessageType2 {
+  constructor() {
+    super("dubhe_grpc.PaginationRequest", [
+      {
+        no: 1,
+        name: "page",
+        kind: "scalar",
+        T: 5
+        /*ScalarType.INT32*/
+      },
+      {
+        no: 2,
+        name: "page_size",
+        kind: "scalar",
+        T: 5
+        /*ScalarType.INT32*/
+      },
+      {
+        no: 3,
+        name: "offset",
+        kind: "scalar",
+        opt: true,
+        T: 5
+        /*ScalarType.INT32*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.page = 0;
+    message.pageSize = 0;
+    if (value !== void 0)
+      reflectionMergePartial2(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* int32 page */
+        1:
+          message.page = reader.int32();
+          break;
+        case /* int32 page_size */
+        2:
+          message.pageSize = reader.int32();
+          break;
+        case /* optional int32 offset */
+        3:
+          message.offset = 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 ? UnknownFieldHandler2.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.page !== 0)
+      writer.tag(1, WireType2.Varint).int32(message.page);
+    if (message.pageSize !== 0)
+      writer.tag(2, WireType2.Varint).int32(message.pageSize);
+    if (message.offset !== void 0)
+      writer.tag(3, WireType2.Varint).int32(message.offset);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler2.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var PaginationRequest = new PaginationRequest$Type();
+var QueryResponse$Type = class extends MessageType2 {
+  constructor() {
+    super("dubhe_grpc.QueryResponse", [
+      { no: 1, name: "rows", kind: "message", repeat: 2, T: () => Struct },
+      { no: 2, name: "pagination", kind: "message", T: () => PaginationResponse }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.rows = [];
+    if (value !== void 0)
+      reflectionMergePartial2(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* repeated google.protobuf.Struct rows */
+        1:
+          message.rows.push(Struct.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        case /* optional dubhe_grpc.PaginationResponse pagination */
+        2:
+          message.pagination = PaginationResponse.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.pagination
+          );
+          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 ? UnknownFieldHandler2.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    for (let i = 0; i < message.rows.length; i++)
+      Struct.internalBinaryWrite(
+        message.rows[i],
+        writer.tag(1, WireType2.LengthDelimited).fork(),
+        options
+      ).join();
+    if (message.pagination)
+      PaginationResponse.internalBinaryWrite(
+        message.pagination,
+        writer.tag(2, WireType2.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler2.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var QueryResponse = new QueryResponse$Type();
+var PaginationResponse$Type = class extends MessageType2 {
+  constructor() {
+    super("dubhe_grpc.PaginationResponse", [
+      {
+        no: 1,
+        name: "current_page",
+        kind: "scalar",
+        T: 5
+        /*ScalarType.INT32*/
+      },
+      {
+        no: 2,
+        name: "page_size",
+        kind: "scalar",
+        T: 5
+        /*ScalarType.INT32*/
+      },
+      {
+        no: 3,
+        name: "total_items",
+        kind: "scalar",
+        T: 3,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 4,
+        name: "total_pages",
+        kind: "scalar",
+        T: 5
+        /*ScalarType.INT32*/
+      },
+      {
+        no: 5,
+        name: "has_next_page",
+        kind: "scalar",
+        T: 8
+        /*ScalarType.BOOL*/
+      },
+      {
+        no: 6,
+        name: "has_previous_page",
+        kind: "scalar",
+        T: 8
+        /*ScalarType.BOOL*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.currentPage = 0;
+    message.pageSize = 0;
+    message.totalItems = 0n;
+    message.totalPages = 0;
+    message.hasNextPage = false;
+    message.hasPreviousPage = false;
+    if (value !== void 0)
+      reflectionMergePartial2(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* int32 current_page */
+        1:
+          message.currentPage = reader.int32();
+          break;
+        case /* int32 page_size */
+        2:
+          message.pageSize = reader.int32();
+          break;
+        case /* int64 total_items */
+        3:
+          message.totalItems = reader.int64().toBigInt();
+          break;
+        case /* int32 total_pages */
+        4:
+          message.totalPages = reader.int32();
+          break;
+        case /* bool has_next_page */
+        5:
+          message.hasNextPage = reader.bool();
+          break;
+        case /* bool has_previous_page */
+        6:
+          message.hasPreviousPage = reader.bool();
+          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 ? UnknownFieldHandler2.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.currentPage !== 0)
+      writer.tag(1, WireType2.Varint).int32(message.currentPage);
+    if (message.pageSize !== 0)
+      writer.tag(2, WireType2.Varint).int32(message.pageSize);
+    if (message.totalItems !== 0n)
+      writer.tag(3, WireType2.Varint).int64(message.totalItems);
+    if (message.totalPages !== 0)
+      writer.tag(4, WireType2.Varint).int32(message.totalPages);
+    if (message.hasNextPage !== false)
+      writer.tag(5, WireType2.Varint).bool(message.hasNextPage);
+    if (message.hasPreviousPage !== false)
+      writer.tag(6, WireType2.Varint).bool(message.hasPreviousPage);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler2.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var PaginationResponse = new PaginationResponse$Type();
+var SubscribeRequest$Type = class extends MessageType2 {
+  constructor() {
+    super("dubhe_grpc.SubscribeRequest", [
+      {
+        no: 1,
+        name: "table_ids",
+        kind: "scalar",
+        repeat: 2,
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.tableIds = [];
+    if (value !== void 0)
+      reflectionMergePartial2(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* repeated string table_ids */
+        1:
+          message.tableIds.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 ? UnknownFieldHandler2.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    for (let i = 0; i < message.tableIds.length; i++)
+      writer.tag(1, WireType2.LengthDelimited).string(message.tableIds[i]);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler2.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var SubscribeRequest = new SubscribeRequest$Type();
+var TableChange$Type = class extends MessageType2 {
+  constructor() {
+    super("dubhe_grpc.TableChange", [
+      {
+        no: 1,
+        name: "table_id",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 2, name: "data", kind: "message", T: () => Struct }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.tableId = "";
+    if (value !== void 0)
+      reflectionMergePartial2(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string table_id */
+        1:
+          message.tableId = reader.string();
+          break;
+        case /* google.protobuf.Struct data */
+        2:
+          message.data = Struct.internalBinaryRead(reader, reader.uint32(), options, message.data);
+          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 ? UnknownFieldHandler2.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.tableId !== "")
+      writer.tag(1, WireType2.LengthDelimited).string(message.tableId);
+    if (message.data)
+      Struct.internalBinaryWrite(
+        message.data,
+        writer.tag(2, WireType2.LengthDelimited).fork(),
+        options
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler2.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var TableChange = new TableChange$Type();
+var DubheGrpc = new ServiceType("dubhe_grpc.DubheGrpc", [
+  { name: "QueryTable", options: {}, I: QueryRequest, O: QueryResponse },
+  {
+    name: "SubscribeTable",
+    serverStreaming: true,
+    options: {},
+    I: SubscribeRequest,
+    O: TableChange
+  }
+]);
+
+// src/proto/dubhe_grpc.client.ts
+import { stackIntercept } from "@protobuf-ts/runtime-rpc";
+var DubheGrpcClient = class {
+  constructor(_transport) {
+    this._transport = _transport;
+    this.typeName = DubheGrpc.typeName;
+    this.methods = DubheGrpc.methods;
+    this.options = DubheGrpc.options;
+  }
+  /**
+   * Query data from a specific table with filters, sorting, and pagination
+   *
+   * @generated from protobuf rpc: QueryTable
+   */
+  queryTable(input, options) {
+    const method = this.methods[0], opt = this._transport.mergeOptions(options);
+    return stackIntercept(
+      "unary",
+      this._transport,
+      method,
+      opt,
+      input
+    );
+  }
+  /**
+   * Subscribe to table updates
+   *
+   * @generated from protobuf rpc: SubscribeTable
+   */
+  subscribeTable(input, options) {
+    const method = this.methods[1], opt = this._transport.mergeOptions(options);
+    return stackIntercept(
+      "serverStreaming",
+      this._transport,
+      method,
+      opt,
+      input
+    );
+  }
+};
+
+// src/client.ts
+import { GrpcWebFetchTransport } from "@protobuf-ts/grpcweb-transport";
+var DubheGrpcClient2 = class {
+  constructor(options) {
+    this.dubheGrpcClient = new DubheGrpcClient(new GrpcWebFetchTransport(options));
+  }
+};
+export {
+  DubheGrpcClient2 as DubheGrpcClient,
+  FilterOperator,
+  DubheGrpcClient as ProtoDubheGrpcClient,
+  SortDirection
+};
+//# sourceMappingURL=index.mjs.map