@514labs/moose-proto 0.6.510 → 0.6.511

package/dist/infrastructure_map.mjs

@@ -712,6 +712,24 @@ var SchemaRegistry_Encoding = /* @__PURE__ */ ((SchemaRegistry_Encoding2) => {
   SchemaRegistry_Encoding2[SchemaRegistry_Encoding2["PROTOBUF"] = 2] = "PROTOBUF";
   return SchemaRegistry_Encoding2;
 })(SchemaRegistry_Encoding || {});
+var DictionaryLayout_Type = /* @__PURE__ */ ((DictionaryLayout_Type2) => {
+  DictionaryLayout_Type2[DictionaryLayout_Type2["FLAT"] = 0] = "FLAT";
+  DictionaryLayout_Type2[DictionaryLayout_Type2["HASHED"] = 1] = "HASHED";
+  DictionaryLayout_Type2[DictionaryLayout_Type2["SPARSE_HASHED"] = 2] = "SPARSE_HASHED";
+  DictionaryLayout_Type2[DictionaryLayout_Type2["HASHED_ARRAY"] = 3] = "HASHED_ARRAY";
+  DictionaryLayout_Type2[DictionaryLayout_Type2["RANGE_HASHED"] = 4] = "RANGE_HASHED";
+  DictionaryLayout_Type2[DictionaryLayout_Type2["CACHE"] = 5] = "CACHE";
+  DictionaryLayout_Type2[DictionaryLayout_Type2["SSD_CACHE"] = 6] = "SSD_CACHE";
+  DictionaryLayout_Type2[DictionaryLayout_Type2["DIRECT"] = 7] = "DIRECT";
+  DictionaryLayout_Type2[DictionaryLayout_Type2["IP_TRIE"] = 8] = "IP_TRIE";
+  DictionaryLayout_Type2[DictionaryLayout_Type2["COMPLEX_KEY_HASHED"] = 9] = "COMPLEX_KEY_HASHED";
+  DictionaryLayout_Type2[DictionaryLayout_Type2["COMPLEX_KEY_SPARSE_HASHED"] = 10] = "COMPLEX_KEY_SPARSE_HASHED";
+  DictionaryLayout_Type2[DictionaryLayout_Type2["COMPLEX_KEY_HASHED_ARRAY"] = 11] = "COMPLEX_KEY_HASHED_ARRAY";
+  DictionaryLayout_Type2[DictionaryLayout_Type2["COMPLEX_KEY_CACHE"] = 12] = "COMPLEX_KEY_CACHE";
+  DictionaryLayout_Type2[DictionaryLayout_Type2["COMPLEX_KEY_SSD_CACHE"] = 13] = "COMPLEX_KEY_SSD_CACHE";
+  DictionaryLayout_Type2[DictionaryLayout_Type2["COMPLEX_KEY_DIRECT"] = 14] = "COMPLEX_KEY_DIRECT";
+  return DictionaryLayout_Type2;
+})(DictionaryLayout_Type || {});
 var EndpointIngestionFormat = /* @__PURE__ */ ((EndpointIngestionFormat2) => {
   EndpointIngestionFormat2[EndpointIngestionFormat2["JSON"] = 0] = "JSON";
   EndpointIngestionFormat2[EndpointIngestionFormat2["JSON_ARRAY"] = 1] = "JSON_ARRAY";
@@ -811,7 +829,8 @@ var InfrastructureMap$Type = class extends MessageType3 {
       { no: 16, name: "materialized_views", kind: "map", K: 9, V: { kind: "message", T: () => MaterializedView } },
       { no: 17, name: "views", kind: "map", K: 9, V: { kind: "message", T: () => View } },
       { no: 18, name: "workflows", kind: "map", K: 9, V: { kind: "message", T: () => Workflow } },
-      { no: 20, name: "select_row_policies", kind: "map", K: 9, V: { kind: "message", T: () => SelectRowPolicy } }
+      { no: 20, name: "select_row_policies", kind: "map", K: 9, V: { kind: "message", T: () => SelectRowPolicy } },
+      { no: 21, name: "olap_dictionaries", kind: "map", K: 9, V: { kind: "message", T: () => OlapDictionary } }
     ]);
   }
   create(value) {
@@ -833,6 +852,7 @@ var InfrastructureMap$Type = class extends MessageType3 {
     message.views = {};
     message.workflows = {};
     message.selectRowPolicies = {};
+    message.olapDictionaries = {};
     if (value !== void 0)
       reflectionMergePartial3(this, message, value);
     return message;
@@ -910,6 +930,10 @@ var InfrastructureMap$Type = class extends MessageType3 {
         20:
           this.binaryReadMap20(message.selectRowPolicies, reader, options);
           break;
+        case /* map<string, moose.proto.OlapDictionary> olap_dictionaries */
+        21:
+          this.binaryReadMap21(message.olapDictionaries, reader, options);
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -1176,6 +1200,23 @@ var InfrastructureMap$Type = class extends MessageType3 {
     }
     map[key ?? ""] = val ?? SelectRowPolicy.create();
   }
+  binaryReadMap21(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 = OlapDictionary.internalBinaryRead(reader, reader.uint32(), options);
+          break;
+        default:
+          throw new globalThis.Error("unknown map entry field for moose.proto.InfrastructureMap.olap_dictionaries");
+      }
+    }
+    map[key ?? ""] = val ?? OlapDictionary.create();
+  }
   internalBinaryWrite(message, writer, options) {
     for (let k of globalThis.Object.keys(message.topics)) {
       writer.tag(1, WireType3.LengthDelimited).fork().tag(1, WireType3.LengthDelimited).string(k);
@@ -1271,6 +1312,12 @@ var InfrastructureMap$Type = class extends MessageType3 {
       SelectRowPolicy.internalBinaryWrite(message.selectRowPolicies[k], writer, options);
       writer.join().join();
     }
+    for (let k of globalThis.Object.keys(message.olapDictionaries)) {
+      writer.tag(21, WireType3.LengthDelimited).fork().tag(1, WireType3.LengthDelimited).string(k);
+      writer.tag(2, WireType3.LengthDelimited).fork();
+      OlapDictionary.internalBinaryWrite(message.olapDictionaries[k], writer, options);
+      writer.join().join();
+    }
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? UnknownFieldHandler3.onWrite : u)(this.typeName, message, writer);
@@ -4908,6 +4955,14 @@ var InfrastructureSignature$Type = class extends MessageType3 {
         oneof: "signature",
         T: 9
         /*ScalarType.STRING*/
+      },
+      {
+        no: 10,
+        name: "olap_dictionary_id",
+        kind: "scalar",
+        oneof: "signature",
+        T: 9
+        /*ScalarType.STRING*/
       }
     ]);
   }
@@ -4986,6 +5041,13 @@ var InfrastructureSignature$Type = class extends MessageType3 {
             selectRowPolicyId: reader.string()
           };
           break;
+        case /* string olap_dictionary_id */
+        10:
+          message.signature = {
+            oneofKind: "olapDictionaryId",
+            olapDictionaryId: reader.string()
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -5016,6 +5078,8 @@ var InfrastructureSignature$Type = class extends MessageType3 {
       writer.tag(8, WireType3.LengthDelimited).string(message.signature.viewId);
     if (message.signature.oneofKind === "selectRowPolicyId")
       writer.tag(9, WireType3.LengthDelimited).string(message.signature.selectRowPolicyId);
+    if (message.signature.oneofKind === "olapDictionaryId")
+      writer.tag(10, WireType3.LengthDelimited).string(message.signature.olapDictionaryId);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? UnknownFieldHandler3.onWrite : u)(this.typeName, message, writer);
@@ -5364,6 +5428,1998 @@ var SelectRowPolicy$Type = class extends MessageType3 {
   }
 };
 var SelectRowPolicy = new SelectRowPolicy$Type();
+var DictionaryColumn$Type = class extends MessageType3 {
+  constructor() {
+    super("moose.proto.DictionaryColumn", [
+      {
+        no: 1,
+        name: "name",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "type_string",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "default_value",
+        kind: "scalar",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 4,
+        name: "expression",
+        kind: "scalar",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 5,
+        name: "is_injective",
+        kind: "scalar",
+        opt: true,
+        T: 8
+        /*ScalarType.BOOL*/
+      },
+      {
+        no: 6,
+        name: "is_hierarchical",
+        kind: "scalar",
+        opt: true,
+        T: 8
+        /*ScalarType.BOOL*/
+      },
+      {
+        no: 7,
+        name: "is_object_id",
+        kind: "scalar",
+        opt: true,
+        T: 8
+        /*ScalarType.BOOL*/
+      },
+      {
+        no: 8,
+        name: "comment",
+        kind: "scalar",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.name = "";
+    message.typeString = "";
+    if (value !== void 0)
+      reflectionMergePartial3(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 name */
+        1:
+          message.name = reader.string();
+          break;
+        case /* string type_string */
+        2:
+          message.typeString = reader.string();
+          break;
+        case /* optional string default_value */
+        3:
+          message.defaultValue = reader.string();
+          break;
+        case /* optional string expression */
+        4:
+          message.expression = reader.string();
+          break;
+        case /* optional bool is_injective */
+        5:
+          message.isInjective = reader.bool();
+          break;
+        case /* optional bool is_hierarchical */
+        6:
+          message.isHierarchical = reader.bool();
+          break;
+        case /* optional bool is_object_id */
+        7:
+          message.isObjectId = reader.bool();
+          break;
+        case /* optional string comment */
+        8:
+          message.comment = 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 ? UnknownFieldHandler3.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.name !== "")
+      writer.tag(1, WireType3.LengthDelimited).string(message.name);
+    if (message.typeString !== "")
+      writer.tag(2, WireType3.LengthDelimited).string(message.typeString);
+    if (message.defaultValue !== void 0)
+      writer.tag(3, WireType3.LengthDelimited).string(message.defaultValue);
+    if (message.expression !== void 0)
+      writer.tag(4, WireType3.LengthDelimited).string(message.expression);
+    if (message.isInjective !== void 0)
+      writer.tag(5, WireType3.Varint).bool(message.isInjective);
+    if (message.isHierarchical !== void 0)
+      writer.tag(6, WireType3.Varint).bool(message.isHierarchical);
+    if (message.isObjectId !== void 0)
+      writer.tag(7, WireType3.Varint).bool(message.isObjectId);
+    if (message.comment !== void 0)
+      writer.tag(8, WireType3.LengthDelimited).string(message.comment);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler3.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var DictionaryColumn = new DictionaryColumn$Type();
+var DictionaryTableSource$Type = class extends MessageType3 {
+  constructor() {
+    super("moose.proto.DictionaryTableSource", [
+      {
+        no: 1,
+        name: "table",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "database",
+        kind: "scalar",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "where_clause",
+        kind: "scalar",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 4,
+        name: "invalidate_query",
+        kind: "scalar",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.table = "";
+    if (value !== void 0)
+      reflectionMergePartial3(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 */
+        1:
+          message.table = reader.string();
+          break;
+        case /* optional string database */
+        2:
+          message.database = reader.string();
+          break;
+        case /* optional string where_clause */
+        3:
+          message.whereClause = reader.string();
+          break;
+        case /* optional string invalidate_query */
+        4:
+          message.invalidateQuery = 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 ? UnknownFieldHandler3.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.table !== "")
+      writer.tag(1, WireType3.LengthDelimited).string(message.table);
+    if (message.database !== void 0)
+      writer.tag(2, WireType3.LengthDelimited).string(message.database);
+    if (message.whereClause !== void 0)
+      writer.tag(3, WireType3.LengthDelimited).string(message.whereClause);
+    if (message.invalidateQuery !== void 0)
+      writer.tag(4, WireType3.LengthDelimited).string(message.invalidateQuery);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler3.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var DictionaryTableSource = new DictionaryTableSource$Type();
+var DictionaryQuerySource$Type = class extends MessageType3 {
+  constructor() {
+    super("moose.proto.DictionaryQuerySource", [
+      {
+        no: 1,
+        name: "query",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "invalidate_query",
+        kind: "scalar",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.query = "";
+    if (value !== void 0)
+      reflectionMergePartial3(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 query */
+        1:
+          message.query = reader.string();
+          break;
+        case /* optional string invalidate_query */
+        2:
+          message.invalidateQuery = 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 ? UnknownFieldHandler3.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.query !== "")
+      writer.tag(1, WireType3.LengthDelimited).string(message.query);
+    if (message.invalidateQuery !== void 0)
+      writer.tag(2, WireType3.LengthDelimited).string(message.invalidateQuery);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler3.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var DictionaryQuerySource = new DictionaryQuerySource$Type();
+var DictionaryLayout$Type = class extends MessageType3 {
+  constructor() {
+    super("moose.proto.DictionaryLayout", [
+      { no: 1, name: "type", kind: "enum", T: () => ["moose.proto.DictionaryLayout.Type", DictionaryLayout_Type] },
+      {
+        no: 2,
+        name: "initial_array_size",
+        kind: "scalar",
+        opt: true,
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 3,
+        name: "max_load_factor",
+        kind: "scalar",
+        opt: true,
+        T: 1
+        /*ScalarType.DOUBLE*/
+      },
+      {
+        no: 4,
+        name: "shards",
+        kind: "scalar",
+        opt: true,
+        T: 13
+        /*ScalarType.UINT32*/
+      },
+      {
+        no: 5,
+        name: "size_in_cells",
+        kind: "scalar",
+        opt: true,
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 6,
+        name: "max_threads_for_updates",
+        kind: "scalar",
+        opt: true,
+        T: 13
+        /*ScalarType.UINT32*/
+      },
+      {
+        no: 7,
+        name: "ssd_path",
+        kind: "scalar",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 8,
+        name: "block_size",
+        kind: "scalar",
+        opt: true,
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 9,
+        name: "file_size",
+        kind: "scalar",
+        opt: true,
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 10,
+        name: "read_buffer_size",
+        kind: "scalar",
+        opt: true,
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 11,
+        name: "write_buffer_size",
+        kind: "scalar",
+        opt: true,
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 12,
+        name: "max_stored_keys",
+        kind: "scalar",
+        opt: true,
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 13,
+        name: "access_to_key_from_attributes",
+        kind: "scalar",
+        opt: true,
+        T: 8
+        /*ScalarType.BOOL*/
+      },
+      {
+        no: 14,
+        name: "range_lookup_strategy",
+        kind: "scalar",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.type = 0;
+    if (value !== void 0)
+      reflectionMergePartial3(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 /* moose.proto.DictionaryLayout.Type type */
+        1:
+          message.type = reader.int32();
+          break;
+        case /* optional uint64 initial_array_size */
+        2:
+          message.initialArraySize = reader.uint64().toBigInt();
+          break;
+        case /* optional double max_load_factor */
+        3:
+          message.maxLoadFactor = reader.double();
+          break;
+        case /* optional uint32 shards */
+        4:
+          message.shards = reader.uint32();
+          break;
+        case /* optional uint64 size_in_cells */
+        5:
+          message.sizeInCells = reader.uint64().toBigInt();
+          break;
+        case /* optional uint32 max_threads_for_updates */
+        6:
+          message.maxThreadsForUpdates = reader.uint32();
+          break;
+        case /* optional string ssd_path */
+        7:
+          message.ssdPath = reader.string();
+          break;
+        case /* optional uint64 block_size */
+        8:
+          message.blockSize = reader.uint64().toBigInt();
+          break;
+        case /* optional uint64 file_size */
+        9:
+          message.fileSize = reader.uint64().toBigInt();
+          break;
+        case /* optional uint64 read_buffer_size */
+        10:
+          message.readBufferSize = reader.uint64().toBigInt();
+          break;
+        case /* optional uint64 write_buffer_size */
+        11:
+          message.writeBufferSize = reader.uint64().toBigInt();
+          break;
+        case /* optional uint64 max_stored_keys */
+        12:
+          message.maxStoredKeys = reader.uint64().toBigInt();
+          break;
+        case /* optional bool access_to_key_from_attributes */
+        13:
+          message.accessToKeyFromAttributes = reader.bool();
+          break;
+        case /* optional string range_lookup_strategy */
+        14:
+          message.rangeLookupStrategy = 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 ? UnknownFieldHandler3.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.type !== 0)
+      writer.tag(1, WireType3.Varint).int32(message.type);
+    if (message.initialArraySize !== void 0)
+      writer.tag(2, WireType3.Varint).uint64(message.initialArraySize);
+    if (message.maxLoadFactor !== void 0)
+      writer.tag(3, WireType3.Bit64).double(message.maxLoadFactor);
+    if (message.shards !== void 0)
+      writer.tag(4, WireType3.Varint).uint32(message.shards);
+    if (message.sizeInCells !== void 0)
+      writer.tag(5, WireType3.Varint).uint64(message.sizeInCells);
+    if (message.maxThreadsForUpdates !== void 0)
+      writer.tag(6, WireType3.Varint).uint32(message.maxThreadsForUpdates);
+    if (message.ssdPath !== void 0)
+      writer.tag(7, WireType3.LengthDelimited).string(message.ssdPath);
+    if (message.blockSize !== void 0)
+      writer.tag(8, WireType3.Varint).uint64(message.blockSize);
+    if (message.fileSize !== void 0)
+      writer.tag(9, WireType3.Varint).uint64(message.fileSize);
+    if (message.readBufferSize !== void 0)
+      writer.tag(10, WireType3.Varint).uint64(message.readBufferSize);
+    if (message.writeBufferSize !== void 0)
+      writer.tag(11, WireType3.Varint).uint64(message.writeBufferSize);
+    if (message.maxStoredKeys !== void 0)
+      writer.tag(12, WireType3.Varint).uint64(message.maxStoredKeys);
+    if (message.accessToKeyFromAttributes !== void 0)
+      writer.tag(13, WireType3.Varint).bool(message.accessToKeyFromAttributes);
+    if (message.rangeLookupStrategy !== void 0)
+      writer.tag(14, WireType3.LengthDelimited).string(message.rangeLookupStrategy);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler3.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var DictionaryLayout = new DictionaryLayout$Type();
+var DictionaryRangeLifetime$Type = class extends MessageType3 {
+  constructor() {
+    super("moose.proto.DictionaryRangeLifetime", [
+      {
+        no: 1,
+        name: "min",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 2,
+        name: "max",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.min = 0n;
+    message.max = 0n;
+    if (value !== void 0)
+      reflectionMergePartial3(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 /* uint64 min */
+        1:
+          message.min = reader.uint64().toBigInt();
+          break;
+        case /* uint64 max */
+        2:
+          message.max = reader.uint64().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 ? UnknownFieldHandler3.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.min !== 0n)
+      writer.tag(1, WireType3.Varint).uint64(message.min);
+    if (message.max !== 0n)
+      writer.tag(2, WireType3.Varint).uint64(message.max);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler3.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var DictionaryRangeLifetime = new DictionaryRangeLifetime$Type();
+var DictionaryLifetime$Type = class extends MessageType3 {
+  constructor() {
+    super("moose.proto.DictionaryLifetime", [
+      {
+        no: 1,
+        name: "static_lifetime",
+        kind: "scalar",
+        oneof: "t",
+        T: 8
+        /*ScalarType.BOOL*/
+      },
+      {
+        no: 2,
+        name: "single",
+        kind: "scalar",
+        oneof: "t",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      { no: 3, name: "range", kind: "message", oneof: "t", T: () => DictionaryRangeLifetime }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.t = { oneofKind: void 0 };
+    if (value !== void 0)
+      reflectionMergePartial3(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 /* bool static_lifetime */
+        1:
+          message.t = {
+            oneofKind: "staticLifetime",
+            staticLifetime: reader.bool()
+          };
+          break;
+        case /* uint64 single */
+        2:
+          message.t = {
+            oneofKind: "single",
+            single: reader.uint64().toBigInt()
+          };
+          break;
+        case /* moose.proto.DictionaryRangeLifetime range */
+        3:
+          message.t = {
+            oneofKind: "range",
+            range: DictionaryRangeLifetime.internalBinaryRead(reader, reader.uint32(), options, message.t.range)
+          };
+          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 ? UnknownFieldHandler3.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.t.oneofKind === "staticLifetime")
+      writer.tag(1, WireType3.Varint).bool(message.t.staticLifetime);
+    if (message.t.oneofKind === "single")
+      writer.tag(2, WireType3.Varint).uint64(message.t.single);
+    if (message.t.oneofKind === "range")
+      DictionaryRangeLifetime.internalBinaryWrite(message.t.range, writer.tag(3, WireType3.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler3.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var DictionaryLifetime = new DictionaryLifetime$Type();
+var DictionaryHttpSource$Type = class extends MessageType3 {
+  constructor() {
+    super("moose.proto.DictionaryHttpSource", [
+      {
+        no: 1,
+        name: "url",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "format",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "method",
+        kind: "scalar",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 4,
+        name: "where_clause",
+        kind: "scalar",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.url = "";
+    message.format = "";
+    if (value !== void 0)
+      reflectionMergePartial3(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 url */
+        1:
+          message.url = reader.string();
+          break;
+        case /* string format */
+        2:
+          message.format = reader.string();
+          break;
+        case /* optional string method */
+        3:
+          message.method = reader.string();
+          break;
+        case /* optional string where_clause */
+        4:
+          message.whereClause = 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 ? UnknownFieldHandler3.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.url !== "")
+      writer.tag(1, WireType3.LengthDelimited).string(message.url);
+    if (message.format !== "")
+      writer.tag(2, WireType3.LengthDelimited).string(message.format);
+    if (message.method !== void 0)
+      writer.tag(3, WireType3.LengthDelimited).string(message.method);
+    if (message.whereClause !== void 0)
+      writer.tag(4, WireType3.LengthDelimited).string(message.whereClause);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler3.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var DictionaryHttpSource = new DictionaryHttpSource$Type();
+var DictionaryClickHouseSource$Type = class extends MessageType3 {
+  constructor() {
+    super("moose.proto.DictionaryClickHouseSource", [
+      {
+        no: 1,
+        name: "host",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "port",
+        kind: "scalar",
+        T: 13
+        /*ScalarType.UINT32*/
+      },
+      {
+        no: 3,
+        name: "user",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 4,
+        name: "password",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 5,
+        name: "db",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 6,
+        name: "table",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 7,
+        name: "query",
+        kind: "scalar",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 8,
+        name: "where_clause",
+        kind: "scalar",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 9,
+        name: "invalidate_query",
+        kind: "scalar",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.host = "";
+    message.port = 0;
+    message.user = "";
+    message.password = "";
+    message.db = "";
+    message.table = "";
+    if (value !== void 0)
+      reflectionMergePartial3(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 host */
+        1:
+          message.host = reader.string();
+          break;
+        case /* uint32 port */
+        2:
+          message.port = reader.uint32();
+          break;
+        case /* string user */
+        3:
+          message.user = reader.string();
+          break;
+        case /* string password */
+        4:
+          message.password = reader.string();
+          break;
+        case /* string db */
+        5:
+          message.db = reader.string();
+          break;
+        case /* string table */
+        6:
+          message.table = reader.string();
+          break;
+        case /* optional string query */
+        7:
+          message.query = reader.string();
+          break;
+        case /* optional string where_clause */
+        8:
+          message.whereClause = reader.string();
+          break;
+        case /* optional string invalidate_query */
+        9:
+          message.invalidateQuery = 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 ? UnknownFieldHandler3.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.host !== "")
+      writer.tag(1, WireType3.LengthDelimited).string(message.host);
+    if (message.port !== 0)
+      writer.tag(2, WireType3.Varint).uint32(message.port);
+    if (message.user !== "")
+      writer.tag(3, WireType3.LengthDelimited).string(message.user);
+    if (message.password !== "")
+      writer.tag(4, WireType3.LengthDelimited).string(message.password);
+    if (message.db !== "")
+      writer.tag(5, WireType3.LengthDelimited).string(message.db);
+    if (message.table !== "")
+      writer.tag(6, WireType3.LengthDelimited).string(message.table);
+    if (message.query !== void 0)
+      writer.tag(7, WireType3.LengthDelimited).string(message.query);
+    if (message.whereClause !== void 0)
+      writer.tag(8, WireType3.LengthDelimited).string(message.whereClause);
+    if (message.invalidateQuery !== void 0)
+      writer.tag(9, WireType3.LengthDelimited).string(message.invalidateQuery);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler3.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var DictionaryClickHouseSource = new DictionaryClickHouseSource$Type();
+var DictionaryMysqlSource$Type = class extends MessageType3 {
+  constructor() {
+    super("moose.proto.DictionaryMysqlSource", [
+      {
+        no: 1,
+        name: "host",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "port",
+        kind: "scalar",
+        T: 13
+        /*ScalarType.UINT32*/
+      },
+      {
+        no: 3,
+        name: "user",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 4,
+        name: "password",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 5,
+        name: "db",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 6,
+        name: "table",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 7,
+        name: "query",
+        kind: "scalar",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 8,
+        name: "where_clause",
+        kind: "scalar",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 9,
+        name: "invalidate_query",
+        kind: "scalar",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.host = "";
+    message.port = 0;
+    message.user = "";
+    message.password = "";
+    message.db = "";
+    message.table = "";
+    if (value !== void 0)
+      reflectionMergePartial3(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 host */
+        1:
+          message.host = reader.string();
+          break;
+        case /* uint32 port */
+        2:
+          message.port = reader.uint32();
+          break;
+        case /* string user */
+        3:
+          message.user = reader.string();
+          break;
+        case /* string password */
+        4:
+          message.password = reader.string();
+          break;
+        case /* string db */
+        5:
+          message.db = reader.string();
+          break;
+        case /* string table */
+        6:
+          message.table = reader.string();
+          break;
+        case /* optional string query */
+        7:
+          message.query = reader.string();
+          break;
+        case /* optional string where_clause */
+        8:
+          message.whereClause = reader.string();
+          break;
+        case /* optional string invalidate_query */
+        9:
+          message.invalidateQuery = 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 ? UnknownFieldHandler3.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.host !== "")
+      writer.tag(1, WireType3.LengthDelimited).string(message.host);
+    if (message.port !== 0)
+      writer.tag(2, WireType3.Varint).uint32(message.port);
+    if (message.user !== "")
+      writer.tag(3, WireType3.LengthDelimited).string(message.user);
+    if (message.password !== "")
+      writer.tag(4, WireType3.LengthDelimited).string(message.password);
+    if (message.db !== "")
+      writer.tag(5, WireType3.LengthDelimited).string(message.db);
+    if (message.table !== "")
+      writer.tag(6, WireType3.LengthDelimited).string(message.table);
+    if (message.query !== void 0)
+      writer.tag(7, WireType3.LengthDelimited).string(message.query);
+    if (message.whereClause !== void 0)
+      writer.tag(8, WireType3.LengthDelimited).string(message.whereClause);
+    if (message.invalidateQuery !== void 0)
+      writer.tag(9, WireType3.LengthDelimited).string(message.invalidateQuery);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler3.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var DictionaryMysqlSource = new DictionaryMysqlSource$Type();
+var DictionaryPostgresqlSource$Type = class extends MessageType3 {
+  constructor() {
+    super("moose.proto.DictionaryPostgresqlSource", [
+      {
+        no: 1,
+        name: "host",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "port",
+        kind: "scalar",
+        T: 13
+        /*ScalarType.UINT32*/
+      },
+      {
+        no: 3,
+        name: "user",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 4,
+        name: "password",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 5,
+        name: "db",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 6,
+        name: "table",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 7,
+        name: "query",
+        kind: "scalar",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 8,
+        name: "where_clause",
+        kind: "scalar",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 9,
+        name: "invalidate_query",
+        kind: "scalar",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.host = "";
+    message.port = 0;
+    message.user = "";
+    message.password = "";
+    message.db = "";
+    message.table = "";
+    if (value !== void 0)
+      reflectionMergePartial3(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 host */
+        1:
+          message.host = reader.string();
+          break;
+        case /* uint32 port */
+        2:
+          message.port = reader.uint32();
+          break;
+        case /* string user */
+        3:
+          message.user = reader.string();
+          break;
+        case /* string password */
+        4:
+          message.password = reader.string();
+          break;
+        case /* string db */
+        5:
+          message.db = reader.string();
+          break;
+        case /* string table */
+        6:
+          message.table = reader.string();
+          break;
+        case /* optional string query */
+        7:
+          message.query = reader.string();
+          break;
+        case /* optional string where_clause */
+        8:
+          message.whereClause = reader.string();
+          break;
+        case /* optional string invalidate_query */
+        9:
+          message.invalidateQuery = 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 ? UnknownFieldHandler3.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.host !== "")
+      writer.tag(1, WireType3.LengthDelimited).string(message.host);
+    if (message.port !== 0)
+      writer.tag(2, WireType3.Varint).uint32(message.port);
+    if (message.user !== "")
+      writer.tag(3, WireType3.LengthDelimited).string(message.user);
+    if (message.password !== "")
+      writer.tag(4, WireType3.LengthDelimited).string(message.password);
+    if (message.db !== "")
+      writer.tag(5, WireType3.LengthDelimited).string(message.db);
+    if (message.table !== "")
+      writer.tag(6, WireType3.LengthDelimited).string(message.table);
+    if (message.query !== void 0)
+      writer.tag(7, WireType3.LengthDelimited).string(message.query);
+    if (message.whereClause !== void 0)
+      writer.tag(8, WireType3.LengthDelimited).string(message.whereClause);
+    if (message.invalidateQuery !== void 0)
+      writer.tag(9, WireType3.LengthDelimited).string(message.invalidateQuery);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler3.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var DictionaryPostgresqlSource = new DictionaryPostgresqlSource$Type();
+var DictionaryRedisSource$Type = class extends MessageType3 {
+  constructor() {
+    super("moose.proto.DictionaryRedisSource", [
+      {
+        no: 1,
+        name: "host",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "port",
+        kind: "scalar",
+        T: 13
+        /*ScalarType.UINT32*/
+      },
+      {
+        no: 3,
+        name: "password",
+        kind: "scalar",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 4,
+        name: "db_index",
+        kind: "scalar",
+        opt: true,
+        T: 13
+        /*ScalarType.UINT32*/
+      },
+      {
+        no: 5,
+        name: "storage_type",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.host = "";
+    message.port = 0;
+    message.storageType = "";
+    if (value !== void 0)
+      reflectionMergePartial3(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 host */
+        1:
+          message.host = reader.string();
+          break;
+        case /* uint32 port */
+        2:
+          message.port = reader.uint32();
+          break;
+        case /* optional string password */
+        3:
+          message.password = reader.string();
+          break;
+        case /* optional uint32 db_index */
+        4:
+          message.dbIndex = reader.uint32();
+          break;
+        case /* string storage_type */
+        5:
+          message.storageType = 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 ? UnknownFieldHandler3.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.host !== "")
+      writer.tag(1, WireType3.LengthDelimited).string(message.host);
+    if (message.port !== 0)
+      writer.tag(2, WireType3.Varint).uint32(message.port);
+    if (message.password !== void 0)
+      writer.tag(3, WireType3.LengthDelimited).string(message.password);
+    if (message.dbIndex !== void 0)
+      writer.tag(4, WireType3.Varint).uint32(message.dbIndex);
+    if (message.storageType !== "")
+      writer.tag(5, WireType3.LengthDelimited).string(message.storageType);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler3.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var DictionaryRedisSource = new DictionaryRedisSource$Type();
+var DictionaryMongoDbSource$Type = class extends MessageType3 {
+  constructor() {
+    super("moose.proto.DictionaryMongoDbSource", [
+      {
+        no: 1,
+        name: "host",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "port",
+        kind: "scalar",
+        T: 13
+        /*ScalarType.UINT32*/
+      },
+      {
+        no: 3,
+        name: "user",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 4,
+        name: "password",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 5,
+        name: "db",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 6,
+        name: "collection",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.host = "";
+    message.port = 0;
+    message.user = "";
+    message.password = "";
+    message.db = "";
+    message.collection = "";
+    if (value !== void 0)
+      reflectionMergePartial3(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 host */
+        1:
+          message.host = reader.string();
+          break;
+        case /* uint32 port */
+        2:
+          message.port = reader.uint32();
+          break;
+        case /* string user */
+        3:
+          message.user = reader.string();
+          break;
+        case /* string password */
+        4:
+          message.password = reader.string();
+          break;
+        case /* string db */
+        5:
+          message.db = reader.string();
+          break;
+        case /* string collection */
+        6:
+          message.collection = 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 ? UnknownFieldHandler3.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.host !== "")
+      writer.tag(1, WireType3.LengthDelimited).string(message.host);
+    if (message.port !== 0)
+      writer.tag(2, WireType3.Varint).uint32(message.port);
+    if (message.user !== "")
+      writer.tag(3, WireType3.LengthDelimited).string(message.user);
+    if (message.password !== "")
+      writer.tag(4, WireType3.LengthDelimited).string(message.password);
+    if (message.db !== "")
+      writer.tag(5, WireType3.LengthDelimited).string(message.db);
+    if (message.collection !== "")
+      writer.tag(6, WireType3.LengthDelimited).string(message.collection);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler3.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var DictionaryMongoDbSource = new DictionaryMongoDbSource$Type();
+var DictionaryExecutableSource$Type = class extends MessageType3 {
+  constructor() {
+    super("moose.proto.DictionaryExecutableSource", [
+      {
+        no: 1,
+        name: "command",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "format",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "implicit_key",
+        kind: "scalar",
+        opt: true,
+        T: 8
+        /*ScalarType.BOOL*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.command = "";
+    message.format = "";
+    if (value !== void 0)
+      reflectionMergePartial3(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 command */
+        1:
+          message.command = reader.string();
+          break;
+        case /* string format */
+        2:
+          message.format = reader.string();
+          break;
+        case /* optional bool implicit_key */
+        3:
+          message.implicitKey = 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 ? UnknownFieldHandler3.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.command !== "")
+      writer.tag(1, WireType3.LengthDelimited).string(message.command);
+    if (message.format !== "")
+      writer.tag(2, WireType3.LengthDelimited).string(message.format);
+    if (message.implicitKey !== void 0)
+      writer.tag(3, WireType3.Varint).bool(message.implicitKey);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler3.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var DictionaryExecutableSource = new DictionaryExecutableSource$Type();
+var DictionaryS3Source$Type = class extends MessageType3 {
+  constructor() {
+    super("moose.proto.DictionaryS3Source", [
+      {
+        no: 1,
+        name: "url",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "format",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "access_key_id",
+        kind: "scalar",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 4,
+        name: "secret_access_key",
+        kind: "scalar",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.url = "";
+    message.format = "";
+    if (value !== void 0)
+      reflectionMergePartial3(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 url */
+        1:
+          message.url = reader.string();
+          break;
+        case /* string format */
+        2:
+          message.format = reader.string();
+          break;
+        case /* optional string access_key_id */
+        3:
+          message.accessKeyId = reader.string();
+          break;
+        case /* optional string secret_access_key */
+        4:
+          message.secretAccessKey = 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 ? UnknownFieldHandler3.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.url !== "")
+      writer.tag(1, WireType3.LengthDelimited).string(message.url);
+    if (message.format !== "")
+      writer.tag(2, WireType3.LengthDelimited).string(message.format);
+    if (message.accessKeyId !== void 0)
+      writer.tag(3, WireType3.LengthDelimited).string(message.accessKeyId);
+    if (message.secretAccessKey !== void 0)
+      writer.tag(4, WireType3.LengthDelimited).string(message.secretAccessKey);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler3.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var DictionaryS3Source = new DictionaryS3Source$Type();
+var DictionaryExternalSource$Type = class extends MessageType3 {
+  constructor() {
+    super("moose.proto.DictionaryExternalSource", [
+      { no: 1, name: "http", kind: "message", oneof: "t", T: () => DictionaryHttpSource },
+      { no: 2, name: "clickhouse", kind: "message", oneof: "t", T: () => DictionaryClickHouseSource },
+      { no: 3, name: "mysql", kind: "message", oneof: "t", T: () => DictionaryMysqlSource },
+      { no: 4, name: "postgresql", kind: "message", oneof: "t", T: () => DictionaryPostgresqlSource },
+      { no: 5, name: "redis", kind: "message", oneof: "t", T: () => DictionaryRedisSource },
+      { no: 6, name: "mongodb", kind: "message", oneof: "t", T: () => DictionaryMongoDbSource },
+      { no: 7, name: "executable", kind: "message", oneof: "t", T: () => DictionaryExecutableSource },
+      { no: 8, name: "s3", kind: "message", oneof: "t", T: () => DictionaryS3Source }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.t = { oneofKind: void 0 };
+    if (value !== void 0)
+      reflectionMergePartial3(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 /* moose.proto.DictionaryHttpSource http */
+        1:
+          message.t = {
+            oneofKind: "http",
+            http: DictionaryHttpSource.internalBinaryRead(reader, reader.uint32(), options, message.t.http)
+          };
+          break;
+        case /* moose.proto.DictionaryClickHouseSource clickhouse */
+        2:
+          message.t = {
+            oneofKind: "clickhouse",
+            clickhouse: DictionaryClickHouseSource.internalBinaryRead(reader, reader.uint32(), options, message.t.clickhouse)
+          };
+          break;
+        case /* moose.proto.DictionaryMysqlSource mysql */
+        3:
+          message.t = {
+            oneofKind: "mysql",
+            mysql: DictionaryMysqlSource.internalBinaryRead(reader, reader.uint32(), options, message.t.mysql)
+          };
+          break;
+        case /* moose.proto.DictionaryPostgresqlSource postgresql */
+        4:
+          message.t = {
+            oneofKind: "postgresql",
+            postgresql: DictionaryPostgresqlSource.internalBinaryRead(reader, reader.uint32(), options, message.t.postgresql)
+          };
+          break;
+        case /* moose.proto.DictionaryRedisSource redis */
+        5:
+          message.t = {
+            oneofKind: "redis",
+            redis: DictionaryRedisSource.internalBinaryRead(reader, reader.uint32(), options, message.t.redis)
+          };
+          break;
+        case /* moose.proto.DictionaryMongoDbSource mongodb */
+        6:
+          message.t = {
+            oneofKind: "mongodb",
+            mongodb: DictionaryMongoDbSource.internalBinaryRead(reader, reader.uint32(), options, message.t.mongodb)
+          };
+          break;
+        case /* moose.proto.DictionaryExecutableSource executable */
+        7:
+          message.t = {
+            oneofKind: "executable",
+            executable: DictionaryExecutableSource.internalBinaryRead(reader, reader.uint32(), options, message.t.executable)
+          };
+          break;
+        case /* moose.proto.DictionaryS3Source s3 */
+        8:
+          message.t = {
+            oneofKind: "s3",
+            s3: DictionaryS3Source.internalBinaryRead(reader, reader.uint32(), options, message.t.s3)
+          };
+          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 ? UnknownFieldHandler3.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.t.oneofKind === "http")
+      DictionaryHttpSource.internalBinaryWrite(message.t.http, writer.tag(1, WireType3.LengthDelimited).fork(), options).join();
+    if (message.t.oneofKind === "clickhouse")
+      DictionaryClickHouseSource.internalBinaryWrite(message.t.clickhouse, writer.tag(2, WireType3.LengthDelimited).fork(), options).join();
+    if (message.t.oneofKind === "mysql")
+      DictionaryMysqlSource.internalBinaryWrite(message.t.mysql, writer.tag(3, WireType3.LengthDelimited).fork(), options).join();
+    if (message.t.oneofKind === "postgresql")
+      DictionaryPostgresqlSource.internalBinaryWrite(message.t.postgresql, writer.tag(4, WireType3.LengthDelimited).fork(), options).join();
+    if (message.t.oneofKind === "redis")
+      DictionaryRedisSource.internalBinaryWrite(message.t.redis, writer.tag(5, WireType3.LengthDelimited).fork(), options).join();
+    if (message.t.oneofKind === "mongodb")
+      DictionaryMongoDbSource.internalBinaryWrite(message.t.mongodb, writer.tag(6, WireType3.LengthDelimited).fork(), options).join();
+    if (message.t.oneofKind === "executable")
+      DictionaryExecutableSource.internalBinaryWrite(message.t.executable, writer.tag(7, WireType3.LengthDelimited).fork(), options).join();
+    if (message.t.oneofKind === "s3")
+      DictionaryS3Source.internalBinaryWrite(message.t.s3, writer.tag(8, WireType3.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler3.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var DictionaryExternalSource = new DictionaryExternalSource$Type();
+var OlapDictionary$Type = class extends MessageType3 {
+  constructor() {
+    super("moose.proto.OlapDictionary", [
+      {
+        no: 1,
+        name: "name",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "database",
+        kind: "scalar",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "cluster_name",
+        kind: "scalar",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 4, name: "table_source", kind: "message", oneof: "source", T: () => DictionaryTableSource },
+      { no: 5, name: "query_source", kind: "message", oneof: "source", T: () => DictionaryQuerySource },
+      { no: 6, name: "external_source", kind: "message", oneof: "source", T: () => DictionaryExternalSource },
+      {
+        no: 7,
+        name: "primary_key",
+        kind: "scalar",
+        repeat: 2,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 8, name: "columns", kind: "message", repeat: 2, T: () => DictionaryColumn },
+      { no: 9, name: "layout", kind: "message", T: () => DictionaryLayout },
+      { no: 10, name: "lifetime", kind: "message", T: () => DictionaryLifetime },
+      {
+        no: 11,
+        name: "invalidate_query",
+        kind: "scalar",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 12, name: "settings", kind: "map", K: 9, V: {
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      } },
+      {
+        no: 13,
+        name: "comment",
+        kind: "scalar",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 14, name: "life_cycle", kind: "enum", T: () => ["moose.proto.LifeCycle", LifeCycle] },
+      { no: 15, name: "metadata", kind: "message", T: () => Metadata },
+      {
+        no: 16,
+        name: "version",
+        kind: "scalar",
+        opt: true,
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.name = "";
+    message.source = { oneofKind: void 0 };
+    message.primaryKey = [];
+    message.columns = [];
+    message.settings = {};
+    message.lifeCycle = 0;
+    if (value !== void 0)
+      reflectionMergePartial3(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 name */
+        1:
+          message.name = reader.string();
+          break;
+        case /* optional string database */
+        2:
+          message.database = reader.string();
+          break;
+        case /* optional string cluster_name */
+        3:
+          message.clusterName = reader.string();
+          break;
+        case /* moose.proto.DictionaryTableSource table_source */
+        4:
+          message.source = {
+            oneofKind: "tableSource",
+            tableSource: DictionaryTableSource.internalBinaryRead(reader, reader.uint32(), options, message.source.tableSource)
+          };
+          break;
+        case /* moose.proto.DictionaryQuerySource query_source */
+        5:
+          message.source = {
+            oneofKind: "querySource",
+            querySource: DictionaryQuerySource.internalBinaryRead(reader, reader.uint32(), options, message.source.querySource)
+          };
+          break;
+        case /* moose.proto.DictionaryExternalSource external_source */
+        6:
+          message.source = {
+            oneofKind: "externalSource",
+            externalSource: DictionaryExternalSource.internalBinaryRead(reader, reader.uint32(), options, message.source.externalSource)
+          };
+          break;
+        case /* repeated string primary_key */
+        7:
+          message.primaryKey.push(reader.string());
+          break;
+        case /* repeated moose.proto.DictionaryColumn columns */
+        8:
+          message.columns.push(DictionaryColumn.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        case /* moose.proto.DictionaryLayout layout */
+        9:
+          message.layout = DictionaryLayout.internalBinaryRead(reader, reader.uint32(), options, message.layout);
+          break;
+        case /* moose.proto.DictionaryLifetime lifetime */
+        10:
+          message.lifetime = DictionaryLifetime.internalBinaryRead(reader, reader.uint32(), options, message.lifetime);
+          break;
+        case /* optional string invalidate_query */
+        11:
+          message.invalidateQuery = reader.string();
+          break;
+        case /* map<string, string> settings */
+        12:
+          this.binaryReadMap12(message.settings, reader, options);
+          break;
+        case /* optional string comment */
+        13:
+          message.comment = reader.string();
+          break;
+        case /* moose.proto.LifeCycle life_cycle */
+        14:
+          message.lifeCycle = reader.int32();
+          break;
+        case /* optional moose.proto.Metadata metadata */
+        15:
+          message.metadata = Metadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata);
+          break;
+        case /* optional string version */
+        16:
+          message.version = 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 ? UnknownFieldHandler3.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  binaryReadMap12(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 = reader.string();
+          break;
+        default:
+          throw new globalThis.Error("unknown map entry field for moose.proto.OlapDictionary.settings");
+      }
+    }
+    map[key ?? ""] = val ?? "";
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.name !== "")
+      writer.tag(1, WireType3.LengthDelimited).string(message.name);
+    if (message.database !== void 0)
+      writer.tag(2, WireType3.LengthDelimited).string(message.database);
+    if (message.clusterName !== void 0)
+      writer.tag(3, WireType3.LengthDelimited).string(message.clusterName);
+    if (message.source.oneofKind === "tableSource")
+      DictionaryTableSource.internalBinaryWrite(message.source.tableSource, writer.tag(4, WireType3.LengthDelimited).fork(), options).join();
+    if (message.source.oneofKind === "querySource")
+      DictionaryQuerySource.internalBinaryWrite(message.source.querySource, writer.tag(5, WireType3.LengthDelimited).fork(), options).join();
+    if (message.source.oneofKind === "externalSource")
+      DictionaryExternalSource.internalBinaryWrite(message.source.externalSource, writer.tag(6, WireType3.LengthDelimited).fork(), options).join();
+    for (let i = 0; i < message.primaryKey.length; i++)
+      writer.tag(7, WireType3.LengthDelimited).string(message.primaryKey[i]);
+    for (let i = 0; i < message.columns.length; i++)
+      DictionaryColumn.internalBinaryWrite(message.columns[i], writer.tag(8, WireType3.LengthDelimited).fork(), options).join();
+    if (message.layout)
+      DictionaryLayout.internalBinaryWrite(message.layout, writer.tag(9, WireType3.LengthDelimited).fork(), options).join();
+    if (message.lifetime)
+      DictionaryLifetime.internalBinaryWrite(message.lifetime, writer.tag(10, WireType3.LengthDelimited).fork(), options).join();
+    if (message.invalidateQuery !== void 0)
+      writer.tag(11, WireType3.LengthDelimited).string(message.invalidateQuery);
+    for (let k of globalThis.Object.keys(message.settings))
+      writer.tag(12, WireType3.LengthDelimited).fork().tag(1, WireType3.LengthDelimited).string(k).tag(2, WireType3.LengthDelimited).string(message.settings[k]).join();
+    if (message.comment !== void 0)
+      writer.tag(13, WireType3.LengthDelimited).string(message.comment);
+    if (message.lifeCycle !== 0)
+      writer.tag(14, WireType3.Varint).int32(message.lifeCycle);
+    if (message.metadata)
+      Metadata.internalBinaryWrite(message.metadata, writer.tag(15, WireType3.LengthDelimited).fork(), options).join();
+    if (message.version !== void 0)
+      writer.tag(16, WireType3.LengthDelimited).string(message.version);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler3.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var OlapDictionary = new OlapDictionary$Type();
 export {
   ApiEndpoint,
   Column,
@@ -5372,6 +7428,22 @@ export {
   DataEnum,
   DateType,
   Decimal,
+  DictionaryClickHouseSource,
+  DictionaryColumn,
+  DictionaryExecutableSource,
+  DictionaryExternalSource,
+  DictionaryHttpSource,
+  DictionaryLayout,
+  DictionaryLayout_Type,
+  DictionaryLifetime,
+  DictionaryMongoDbSource,
+  DictionaryMysqlSource,
+  DictionaryPostgresqlSource,
+  DictionaryQuerySource,
+  DictionaryRangeLifetime,
+  DictionaryRedisSource,
+  DictionaryS3Source,
+  DictionaryTableSource,
   Dmv1View,
   EgressDetails,
   EndpointIngestionFormat,
@@ -5392,6 +7464,7 @@ export {
   Metadata,
   Method,
   Nested,
+  OlapDictionary,
   OrchestrationWorker,
   OrderBy,
   OrderByFields,