diff --git a/apis/docs/v1/docs.md b/apis/docs/v1/docs.md
index 22893448488..7ba2c51e232 100644
--- a/apis/docs/v1/docs.md
+++ b/apis/docs/v1/docs.md
@@ -25,6 +25,9 @@
   - [Info.Index.Count](#payload-v1-Info-Index-Count)
   - [Info.Index.Detail](#payload-v1-Info-Index-Detail)
   - [Info.Index.Detail.CountsEntry](#payload-v1-Info-Index-Detail-CountsEntry)
+  - [Info.Index.Property](#payload-v1-Info-Index-Property)
+  - [Info.Index.PropertyDetail](#payload-v1-Info-Index-PropertyDetail)
+  - [Info.Index.PropertyDetail.DetailsEntry](#payload-v1-Info-Index-PropertyDetail-DetailsEntry)
   - [Info.Index.Statistics](#payload-v1-Info-Index-Statistics)
   - [Info.Index.StatisticsDetail](#payload-v1-Info-Index-StatisticsDetail)
   - [Info.Index.StatisticsDetail.DetailsEntry](#payload-v1-Info-Index-StatisticsDetail-DetailsEntry)
@@ -320,6 +323,68 @@ Represent the index count for each Agents message.
 | key   | [string](#string)                                |       |             |
 | value | [Info.Index.Count](#payload-v1-Info-Index-Count) |       |             |
 
+<a name="payload-v1-Info-Index-Property"></a>
+
+### Info.Index.Property
+
+Represents index Property
+
+| Field                              | Type              | Label | Description |
+| ---------------------------------- | ----------------- | ----- | ----------- |
+| dimension                          | [int32](#int32)   |       |             |
+| thread_pool_size                   | [int32](#int32)   |       |             |
+| object_type                        | [int32](#int32)   |       |             |
+| distance_type                      | [int32](#int32)   |       |             |
+| index_type                         | [int32](#int32)   |       |             |
+| database_type                      | [int32](#int32)   |       |             |
+| object_alignment                   | [int32](#int32)   |       |             |
+| path_adjustment_interval           | [int32](#int32)   |       |             |
+| graph_shared_memory_size           | [int32](#int32)   |       |             |
+| tree_shared_memory_size            | [int32](#int32)   |       |             |
+| object_shared_memory_size          | [int32](#int32)   |       |             |
+| prefetch_offset                    | [int32](#int32)   |       |             |
+| prefetch_size                      | [int32](#int32)   |       |             |
+| accuracy_table                     | [string](#string) |       |             |
+| search_type                        | [string](#string) |       |             |
+| max_magnitude                      | [float](#float)   |       |             |
+| n_of_neighbors_for_insertion_order | [int32](#int32)   |       |             |
+| epsilon_for_insertion_order        | [float](#float)   |       |             |
+| refinement_object_type             | [int32](#int32)   |       |             |
+| truncation_threshold               | [int32](#int32)   |       |             |
+| edge_size_for_creation             | [int32](#int32)   |       |             |
+| edge_size_for_search               | [int32](#int32)   |       |             |
+| edge_size_limit_for_creation       | [int32](#int32)   |       |             |
+| insertion_radius_coefficient       | [double](#double) |       |             |
+| seed_size                          | [int32](#int32)   |       |             |
+| seed_type                          | [int32](#int32)   |       |             |
+| truncation_thread_pool_size        | [int32](#int32)   |       |             |
+| batch_size_for_creation            | [int32](#int32)   |       |             |
+| graph_type                         | [int32](#int32)   |       |             |
+| dynamic_edge_size_base             | [int32](#int32)   |       |             |
+| dynamic_edge_size_rate             | [int32](#int32)   |       |             |
+| build_time_limit                   | [float](#float)   |       |             |
+| outgoing_edge                      | [int32](#int32)   |       |             |
+| incoming_edge                      | [int32](#int32)   |       |             |
+
+<a name="payload-v1-Info-Index-PropertyDetail"></a>
+
+### Info.Index.PropertyDetail
+
+Represents index Properties for each Agents
+
+| Field   | Type                                                                                         | Label    | Description |
+| ------- | -------------------------------------------------------------------------------------------- | -------- | ----------- |
+| details | [Info.Index.PropertyDetail.DetailsEntry](#payload-v1-Info-Index-PropertyDetail-DetailsEntry) | repeated |             |
+
+<a name="payload-v1-Info-Index-PropertyDetail-DetailsEntry"></a>
+
+### Info.Index.PropertyDetail.DetailsEntry
+
+| Field | Type                                                   | Label | Description |
+| ----- | ------------------------------------------------------ | ----- | ----------- |
+| key   | [string](#string)                                      |       |             |
+| value | [Info.Index.Property](#payload-v1-Info-Index-Property) |       |             |
+
 <a name="payload-v1-Info-Index-Statistics"></a>
 
 ### Info.Index.Statistics
@@ -1567,6 +1632,8 @@ Represent the index manager service.
 | IndexDetail           | [.payload.v1.Empty](#payload-v1-Empty) | [.payload.v1.Info.Index.Detail](#payload-v1-Info-Index-Detail)                     | Represent the RPC to get the index information for each agents. |
 | IndexStatistics       | [.payload.v1.Empty](#payload-v1-Empty) | [.payload.v1.Info.Index.Statistics](#payload-v1-Info-Index-Statistics)             | Represent the RPC to get the index statistics.                  |
 | IndexStatisticsDetail | [.payload.v1.Empty](#payload-v1-Empty) | [.payload.v1.Info.Index.StatisticsDetail](#payload-v1-Info-Index-StatisticsDetail) | Represent the RPC to get the index statistics for each agents.  |
+| IndexProperty         | [.payload.v1.Empty](#payload-v1-Empty) | [.payload.v1.Info.Index.Property](#payload-v1-Info-Index-Property)                 | Represent the RPC to get the index property.                    |
+| IndexPropertyDetail   | [.payload.v1.Empty](#payload-v1-Empty) | [.payload.v1.Info.Index.PropertyDetail](#payload-v1-Info-Index-PropertyDetail)     | Represent the RPC to get the index properties for each agents.  |
 
 <a name="v1_vald_insert-proto"></a>
 
diff --git a/apis/grpc/v1/payload/payload.pb.go b/apis/grpc/v1/payload/payload.pb.go
index 1d034ff92ed..ec4383d849b 100644
--- a/apis/grpc/v1/payload/payload.pb.go
+++ b/apis/grpc/v1/payload/payload.pb.go
@@ -5254,6 +5254,366 @@ func (x *Info_Index_StatisticsDetail) GetDetails() map[string]*Info_Index_Statis
 	return nil
 }
 
+// Represents index Property
+type Info_Index_Property struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Dimension                     int32   `protobuf:"varint,1,opt,name=dimension,proto3"                                                              json:"dimension,omitempty"`
+	ThreadPoolSize                int32   `protobuf:"varint,2,opt,name=thread_pool_size,json=threadPoolSize,proto3"                                   json:"thread_pool_size,omitempty"`
+	ObjectType                    int32   `protobuf:"varint,3,opt,name=object_type,json=objectType,proto3"                                            json:"object_type,omitempty"`
+	DistanceType                  int32   `protobuf:"varint,4,opt,name=distance_type,json=distanceType,proto3"                                        json:"distance_type,omitempty"`
+	IndexType                     int32   `protobuf:"varint,5,opt,name=index_type,json=indexType,proto3"                                              json:"index_type,omitempty"`
+	DatabaseType                  int32   `protobuf:"varint,6,opt,name=database_type,json=databaseType,proto3"                                        json:"database_type,omitempty"`
+	ObjectAlignment               int32   `protobuf:"varint,7,opt,name=object_alignment,json=objectAlignment,proto3"                                  json:"object_alignment,omitempty"`
+	PathAdjustmentInterval        int32   `protobuf:"varint,8,opt,name=path_adjustment_interval,json=pathAdjustmentInterval,proto3"                   json:"path_adjustment_interval,omitempty"`
+	GraphSharedMemorySize         int32   `protobuf:"varint,9,opt,name=graph_shared_memory_size,json=graphSharedMemorySize,proto3"                    json:"graph_shared_memory_size,omitempty"`
+	TreeSharedMemorySize          int32   `protobuf:"varint,10,opt,name=tree_shared_memory_size,json=treeSharedMemorySize,proto3"                     json:"tree_shared_memory_size,omitempty"`
+	ObjectSharedMemorySize        int32   `protobuf:"varint,11,opt,name=object_shared_memory_size,json=objectSharedMemorySize,proto3"                 json:"object_shared_memory_size,omitempty"`
+	PrefetchOffset                int32   `protobuf:"varint,12,opt,name=prefetch_offset,json=prefetchOffset,proto3"                                   json:"prefetch_offset,omitempty"`
+	PrefetchSize                  int32   `protobuf:"varint,13,opt,name=prefetch_size,json=prefetchSize,proto3"                                       json:"prefetch_size,omitempty"`
+	AccuracyTable                 string  `protobuf:"bytes,14,opt,name=accuracy_table,json=accuracyTable,proto3"                                      json:"accuracy_table,omitempty"`
+	SearchType                    string  `protobuf:"bytes,15,opt,name=search_type,json=searchType,proto3"                                            json:"search_type,omitempty"`
+	MaxMagnitude                  float32 `protobuf:"fixed32,16,opt,name=max_magnitude,json=maxMagnitude,proto3"                                      json:"max_magnitude,omitempty"`
+	NOfNeighborsForInsertionOrder int32   `protobuf:"varint,17,opt,name=n_of_neighbors_for_insertion_order,json=nOfNeighborsForInsertionOrder,proto3" json:"n_of_neighbors_for_insertion_order,omitempty"`
+	EpsilonForInsertionOrder      float32 `protobuf:"fixed32,18,opt,name=epsilon_for_insertion_order,json=epsilonForInsertionOrder,proto3"            json:"epsilon_for_insertion_order,omitempty"`
+	RefinementObjectType          int32   `protobuf:"varint,19,opt,name=refinement_object_type,json=refinementObjectType,proto3"                      json:"refinement_object_type,omitempty"`
+	TruncationThreshold           int32   `protobuf:"varint,20,opt,name=truncation_threshold,json=truncationThreshold,proto3"                         json:"truncation_threshold,omitempty"`
+	EdgeSizeForCreation           int32   `protobuf:"varint,21,opt,name=edge_size_for_creation,json=edgeSizeForCreation,proto3"                       json:"edge_size_for_creation,omitempty"`
+	EdgeSizeForSearch             int32   `protobuf:"varint,22,opt,name=edge_size_for_search,json=edgeSizeForSearch,proto3"                           json:"edge_size_for_search,omitempty"`
+	EdgeSizeLimitForCreation      int32   `protobuf:"varint,23,opt,name=edge_size_limit_for_creation,json=edgeSizeLimitForCreation,proto3"            json:"edge_size_limit_for_creation,omitempty"`
+	InsertionRadiusCoefficient    float64 `protobuf:"fixed64,24,opt,name=insertion_radius_coefficient,json=insertionRadiusCoefficient,proto3"         json:"insertion_radius_coefficient,omitempty"`
+	SeedSize                      int32   `protobuf:"varint,25,opt,name=seed_size,json=seedSize,proto3"                                               json:"seed_size,omitempty"`
+	SeedType                      int32   `protobuf:"varint,26,opt,name=seed_type,json=seedType,proto3"                                               json:"seed_type,omitempty"`
+	TruncationThreadPoolSize      int32   `protobuf:"varint,27,opt,name=truncation_thread_pool_size,json=truncationThreadPoolSize,proto3"             json:"truncation_thread_pool_size,omitempty"`
+	BatchSizeForCreation          int32   `protobuf:"varint,28,opt,name=batch_size_for_creation,json=batchSizeForCreation,proto3"                     json:"batch_size_for_creation,omitempty"`
+	GraphType                     int32   `protobuf:"varint,29,opt,name=graph_type,json=graphType,proto3"                                             json:"graph_type,omitempty"`
+	DynamicEdgeSizeBase           int32   `protobuf:"varint,30,opt,name=dynamic_edge_size_base,json=dynamicEdgeSizeBase,proto3"                       json:"dynamic_edge_size_base,omitempty"`
+	DynamicEdgeSizeRate           int32   `protobuf:"varint,31,opt,name=dynamic_edge_size_rate,json=dynamicEdgeSizeRate,proto3"                       json:"dynamic_edge_size_rate,omitempty"`
+	BuildTimeLimit                float32 `protobuf:"fixed32,32,opt,name=build_time_limit,json=buildTimeLimit,proto3"                                 json:"build_time_limit,omitempty"`
+	OutgoingEdge                  int32   `protobuf:"varint,33,opt,name=outgoing_edge,json=outgoingEdge,proto3"                                       json:"outgoing_edge,omitempty"`
+	IncomingEdge                  int32   `protobuf:"varint,34,opt,name=incoming_edge,json=incomingEdge,proto3"                                       json:"incoming_edge,omitempty"`
+}
+
+func (x *Info_Index_Property) Reset() {
+	*x = Info_Index_Property{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_v1_payload_payload_proto_msgTypes[85]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Info_Index_Property) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Info_Index_Property) ProtoMessage() {}
+
+func (x *Info_Index_Property) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_payload_payload_proto_msgTypes[85]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Info_Index_Property.ProtoReflect.Descriptor instead.
+func (*Info_Index_Property) Descriptor() ([]byte, []int) {
+	return file_v1_payload_payload_proto_rawDescGZIP(), []int{10, 0, 5}
+}
+
+func (x *Info_Index_Property) GetDimension() int32 {
+	if x != nil {
+		return x.Dimension
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetThreadPoolSize() int32 {
+	if x != nil {
+		return x.ThreadPoolSize
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetObjectType() int32 {
+	if x != nil {
+		return x.ObjectType
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetDistanceType() int32 {
+	if x != nil {
+		return x.DistanceType
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetIndexType() int32 {
+	if x != nil {
+		return x.IndexType
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetDatabaseType() int32 {
+	if x != nil {
+		return x.DatabaseType
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetObjectAlignment() int32 {
+	if x != nil {
+		return x.ObjectAlignment
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetPathAdjustmentInterval() int32 {
+	if x != nil {
+		return x.PathAdjustmentInterval
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetGraphSharedMemorySize() int32 {
+	if x != nil {
+		return x.GraphSharedMemorySize
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetTreeSharedMemorySize() int32 {
+	if x != nil {
+		return x.TreeSharedMemorySize
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetObjectSharedMemorySize() int32 {
+	if x != nil {
+		return x.ObjectSharedMemorySize
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetPrefetchOffset() int32 {
+	if x != nil {
+		return x.PrefetchOffset
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetPrefetchSize() int32 {
+	if x != nil {
+		return x.PrefetchSize
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetAccuracyTable() string {
+	if x != nil {
+		return x.AccuracyTable
+	}
+	return ""
+}
+
+func (x *Info_Index_Property) GetSearchType() string {
+	if x != nil {
+		return x.SearchType
+	}
+	return ""
+}
+
+func (x *Info_Index_Property) GetMaxMagnitude() float32 {
+	if x != nil {
+		return x.MaxMagnitude
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetNOfNeighborsForInsertionOrder() int32 {
+	if x != nil {
+		return x.NOfNeighborsForInsertionOrder
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetEpsilonForInsertionOrder() float32 {
+	if x != nil {
+		return x.EpsilonForInsertionOrder
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetRefinementObjectType() int32 {
+	if x != nil {
+		return x.RefinementObjectType
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetTruncationThreshold() int32 {
+	if x != nil {
+		return x.TruncationThreshold
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetEdgeSizeForCreation() int32 {
+	if x != nil {
+		return x.EdgeSizeForCreation
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetEdgeSizeForSearch() int32 {
+	if x != nil {
+		return x.EdgeSizeForSearch
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetEdgeSizeLimitForCreation() int32 {
+	if x != nil {
+		return x.EdgeSizeLimitForCreation
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetInsertionRadiusCoefficient() float64 {
+	if x != nil {
+		return x.InsertionRadiusCoefficient
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetSeedSize() int32 {
+	if x != nil {
+		return x.SeedSize
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetSeedType() int32 {
+	if x != nil {
+		return x.SeedType
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetTruncationThreadPoolSize() int32 {
+	if x != nil {
+		return x.TruncationThreadPoolSize
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetBatchSizeForCreation() int32 {
+	if x != nil {
+		return x.BatchSizeForCreation
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetGraphType() int32 {
+	if x != nil {
+		return x.GraphType
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetDynamicEdgeSizeBase() int32 {
+	if x != nil {
+		return x.DynamicEdgeSizeBase
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetDynamicEdgeSizeRate() int32 {
+	if x != nil {
+		return x.DynamicEdgeSizeRate
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetBuildTimeLimit() float32 {
+	if x != nil {
+		return x.BuildTimeLimit
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetOutgoingEdge() int32 {
+	if x != nil {
+		return x.OutgoingEdge
+	}
+	return 0
+}
+
+func (x *Info_Index_Property) GetIncomingEdge() int32 {
+	if x != nil {
+		return x.IncomingEdge
+	}
+	return 0
+}
+
+// Represents index Properties for each Agents
+type Info_Index_PropertyDetail struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Details map[string]*Info_Index_Property `protobuf:"bytes,1,rep,name=details,proto3" json:"details,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+}
+
+func (x *Info_Index_PropertyDetail) Reset() {
+	*x = Info_Index_PropertyDetail{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_v1_payload_payload_proto_msgTypes[86]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Info_Index_PropertyDetail) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Info_Index_PropertyDetail) ProtoMessage() {}
+
+func (x *Info_Index_PropertyDetail) ProtoReflect() protoreflect.Message {
+	mi := &file_v1_payload_payload_proto_msgTypes[86]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Info_Index_PropertyDetail.ProtoReflect.Descriptor instead.
+func (*Info_Index_PropertyDetail) Descriptor() ([]byte, []int) {
+	return file_v1_payload_payload_proto_rawDescGZIP(), []int{10, 0, 6}
+}
+
+func (x *Info_Index_PropertyDetail) GetDetails() map[string]*Info_Index_Property {
+	if x != nil {
+		return x.Details
+	}
+	return nil
+}
+
 // The committed UUID.
 type Info_Index_UUID_Committed struct {
 	state         protoimpl.MessageState
@@ -5266,7 +5626,7 @@ type Info_Index_UUID_Committed struct {
 func (x *Info_Index_UUID_Committed) Reset() {
 	*x = Info_Index_UUID_Committed{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_v1_payload_payload_proto_msgTypes[86]
+		mi := &file_v1_payload_payload_proto_msgTypes[88]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -5279,7 +5639,7 @@ func (x *Info_Index_UUID_Committed) String() string {
 func (*Info_Index_UUID_Committed) ProtoMessage() {}
 
 func (x *Info_Index_UUID_Committed) ProtoReflect() protoreflect.Message {
-	mi := &file_v1_payload_payload_proto_msgTypes[86]
+	mi := &file_v1_payload_payload_proto_msgTypes[88]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -5314,7 +5674,7 @@ type Info_Index_UUID_Uncommitted struct {
 func (x *Info_Index_UUID_Uncommitted) Reset() {
 	*x = Info_Index_UUID_Uncommitted{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_v1_payload_payload_proto_msgTypes[87]
+		mi := &file_v1_payload_payload_proto_msgTypes[89]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -5327,7 +5687,7 @@ func (x *Info_Index_UUID_Uncommitted) String() string {
 func (*Info_Index_UUID_Uncommitted) ProtoMessage() {}
 
 func (x *Info_Index_UUID_Uncommitted) ProtoReflect() protoreflect.Message {
-	mi := &file_v1_payload_payload_proto_msgTypes[87]
+	mi := &file_v1_payload_payload_proto_msgTypes[89]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -5365,7 +5725,7 @@ type Mirror_Target struct {
 func (x *Mirror_Target) Reset() {
 	*x = Mirror_Target{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_v1_payload_payload_proto_msgTypes[91]
+		mi := &file_v1_payload_payload_proto_msgTypes[94]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -5378,7 +5738,7 @@ func (x *Mirror_Target) String() string {
 func (*Mirror_Target) ProtoMessage() {}
 
 func (x *Mirror_Target) ProtoReflect() protoreflect.Message {
-	mi := &file_v1_payload_payload_proto_msgTypes[91]
+	mi := &file_v1_payload_payload_proto_msgTypes[94]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -5421,7 +5781,7 @@ type Mirror_Targets struct {
 func (x *Mirror_Targets) Reset() {
 	*x = Mirror_Targets{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_v1_payload_payload_proto_msgTypes[92]
+		mi := &file_v1_payload_payload_proto_msgTypes[95]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -5434,7 +5794,7 @@ func (x *Mirror_Targets) String() string {
 func (*Mirror_Targets) ProtoMessage() {}
 
 func (x *Mirror_Targets) ProtoReflect() protoreflect.Message {
-	mi := &file_v1_payload_payload_proto_msgTypes[92]
+	mi := &file_v1_payload_payload_proto_msgTypes[95]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -5824,8 +6184,8 @@ var file_v1_payload_payload_proto_rawDesc = []byte{
 	0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x6e,
 	0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
 	0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x6f, 0x64,
-	0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x6f, 0x64, 0x65, 0x22, 0xd2, 0x1d,
-	0x0a, 0x04, 0x49, 0x6e, 0x66, 0x6f, 0x1a, 0x90, 0x12, 0x0a, 0x05, 0x49, 0x6e, 0x64, 0x65, 0x78,
+	0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x6f, 0x64, 0x65, 0x22, 0xc2, 0x2b,
+	0x0a, 0x04, 0x49, 0x6e, 0x66, 0x6f, 0x1a, 0x80, 0x20, 0x0a, 0x05, 0x49, 0x6e, 0x64, 0x65, 0x78,
 	0x1a, 0x75, 0x0a, 0x05, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x6f,
 	0x72, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x73, 0x74, 0x6f, 0x72, 0x65,
 	0x64, 0x12, 0x20, 0x0a, 0x0b, 0x75, 0x6e, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x64,
@@ -5970,6 +6330,117 @@ var file_v1_payload_payload_proto_rawDesc = []byte{
 	0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x70, 0x61,
 	0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x49, 0x6e,
 	0x64, 0x65, 0x78, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x52, 0x05,
+	0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0xaf, 0x0c, 0x0a, 0x08, 0x50, 0x72,
+	0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x12, 0x1c, 0x0a, 0x09, 0x64, 0x69, 0x6d, 0x65, 0x6e, 0x73,
+	0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x64, 0x69, 0x6d, 0x65, 0x6e,
+	0x73, 0x69, 0x6f, 0x6e, 0x12, 0x28, 0x0a, 0x10, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x5f, 0x70,
+	0x6f, 0x6f, 0x6c, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e,
+	0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x50, 0x6f, 0x6f, 0x6c, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x1f,
+	0x0a, 0x0b, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x05, 0x52, 0x0a, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12,
+	0x23, 0x0a, 0x0d, 0x64, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65,
+	0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x64, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65,
+	0x54, 0x79, 0x70, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x74, 0x79,
+	0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x54,
+	0x79, 0x70, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x64, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x5f,
+	0x74, 0x79, 0x70, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x64, 0x61, 0x74, 0x61,
+	0x62, 0x61, 0x73, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x6f, 0x62, 0x6a, 0x65,
+	0x63, 0x74, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x07, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x0f, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x41, 0x6c, 0x69, 0x67, 0x6e, 0x6d,
+	0x65, 0x6e, 0x74, 0x12, 0x38, 0x0a, 0x18, 0x70, 0x61, 0x74, 0x68, 0x5f, 0x61, 0x64, 0x6a, 0x75,
+	0x73, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18,
+	0x08, 0x20, 0x01, 0x28, 0x05, 0x52, 0x16, 0x70, 0x61, 0x74, 0x68, 0x41, 0x64, 0x6a, 0x75, 0x73,
+	0x74, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x12, 0x37, 0x0a,
+	0x18, 0x67, 0x72, 0x61, 0x70, 0x68, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x65, 0x64, 0x5f, 0x6d, 0x65,
+	0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x15, 0x67, 0x72, 0x61, 0x70, 0x68, 0x53, 0x68, 0x61, 0x72, 0x65, 0x64, 0x4d, 0x65, 0x6d, 0x6f,
+	0x72, 0x79, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x35, 0x0a, 0x17, 0x74, 0x72, 0x65, 0x65, 0x5f, 0x73,
+	0x68, 0x61, 0x72, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x73, 0x69, 0x7a,
+	0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x14, 0x74, 0x72, 0x65, 0x65, 0x53, 0x68, 0x61,
+	0x72, 0x65, 0x64, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x39, 0x0a,
+	0x19, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x65, 0x64, 0x5f, 0x6d,
+	0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x05,
+	0x52, 0x16, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x53, 0x68, 0x61, 0x72, 0x65, 0x64, 0x4d, 0x65,
+	0x6d, 0x6f, 0x72, 0x79, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x70, 0x72, 0x65, 0x66,
+	0x65, 0x74, 0x63, 0x68, 0x5f, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x0c, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x0e, 0x70, 0x72, 0x65, 0x66, 0x65, 0x74, 0x63, 0x68, 0x4f, 0x66, 0x66, 0x73, 0x65,
+	0x74, 0x12, 0x23, 0x0a, 0x0d, 0x70, 0x72, 0x65, 0x66, 0x65, 0x74, 0x63, 0x68, 0x5f, 0x73, 0x69,
+	0x7a, 0x65, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x70, 0x72, 0x65, 0x66, 0x65, 0x74,
+	0x63, 0x68, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x61, 0x63, 0x63, 0x75, 0x72, 0x61,
+	0x63, 0x79, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d,
+	0x61, 0x63, 0x63, 0x75, 0x72, 0x61, 0x63, 0x79, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x1f, 0x0a,
+	0x0b, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0f, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x0a, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x54, 0x79, 0x70, 0x65, 0x12, 0x23,
+	0x0a, 0x0d, 0x6d, 0x61, 0x78, 0x5f, 0x6d, 0x61, 0x67, 0x6e, 0x69, 0x74, 0x75, 0x64, 0x65, 0x18,
+	0x10, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0c, 0x6d, 0x61, 0x78, 0x4d, 0x61, 0x67, 0x6e, 0x69, 0x74,
+	0x75, 0x64, 0x65, 0x12, 0x49, 0x0a, 0x22, 0x6e, 0x5f, 0x6f, 0x66, 0x5f, 0x6e, 0x65, 0x69, 0x67,
+	0x68, 0x62, 0x6f, 0x72, 0x73, 0x5f, 0x66, 0x6f, 0x72, 0x5f, 0x69, 0x6e, 0x73, 0x65, 0x72, 0x74,
+	0x69, 0x6f, 0x6e, 0x5f, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x18, 0x11, 0x20, 0x01, 0x28, 0x05, 0x52,
+	0x1d, 0x6e, 0x4f, 0x66, 0x4e, 0x65, 0x69, 0x67, 0x68, 0x62, 0x6f, 0x72, 0x73, 0x46, 0x6f, 0x72,
+	0x49, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x69, 0x6f, 0x6e, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x12, 0x3d,
+	0x0a, 0x1b, 0x65, 0x70, 0x73, 0x69, 0x6c, 0x6f, 0x6e, 0x5f, 0x66, 0x6f, 0x72, 0x5f, 0x69, 0x6e,
+	0x73, 0x65, 0x72, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x18, 0x12, 0x20,
+	0x01, 0x28, 0x02, 0x52, 0x18, 0x65, 0x70, 0x73, 0x69, 0x6c, 0x6f, 0x6e, 0x46, 0x6f, 0x72, 0x49,
+	0x6e, 0x73, 0x65, 0x72, 0x74, 0x69, 0x6f, 0x6e, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x12, 0x34, 0x0a,
+	0x16, 0x72, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x6f, 0x62, 0x6a, 0x65,
+	0x63, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x13, 0x20, 0x01, 0x28, 0x05, 0x52, 0x14, 0x72,
+	0x65, 0x66, 0x69, 0x6e, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x54,
+	0x79, 0x70, 0x65, 0x12, 0x31, 0x0a, 0x14, 0x74, 0x72, 0x75, 0x6e, 0x63, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x5f, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x14, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x13, 0x74, 0x72, 0x75, 0x6e, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x68, 0x72,
+	0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x12, 0x33, 0x0a, 0x16, 0x65, 0x64, 0x67, 0x65, 0x5f, 0x73,
+	0x69, 0x7a, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x18, 0x15, 0x20, 0x01, 0x28, 0x05, 0x52, 0x13, 0x65, 0x64, 0x67, 0x65, 0x53, 0x69, 0x7a, 0x65,
+	0x46, 0x6f, 0x72, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2f, 0x0a, 0x14, 0x65,
+	0x64, 0x67, 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x5f, 0x73, 0x65, 0x61,
+	0x72, 0x63, 0x68, 0x18, 0x16, 0x20, 0x01, 0x28, 0x05, 0x52, 0x11, 0x65, 0x64, 0x67, 0x65, 0x53,
+	0x69, 0x7a, 0x65, 0x46, 0x6f, 0x72, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x12, 0x3e, 0x0a, 0x1c,
+	0x65, 0x64, 0x67, 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f,
+	0x66, 0x6f, 0x72, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x17, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x18, 0x65, 0x64, 0x67, 0x65, 0x53, 0x69, 0x7a, 0x65, 0x4c, 0x69, 0x6d, 0x69,
+	0x74, 0x46, 0x6f, 0x72, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x40, 0x0a, 0x1c,
+	0x69, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x61, 0x64, 0x69, 0x75, 0x73,
+	0x5f, 0x63, 0x6f, 0x65, 0x66, 0x66, 0x69, 0x63, 0x69, 0x65, 0x6e, 0x74, 0x18, 0x18, 0x20, 0x01,
+	0x28, 0x01, 0x52, 0x1a, 0x69, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x64,
+	0x69, 0x75, 0x73, 0x43, 0x6f, 0x65, 0x66, 0x66, 0x69, 0x63, 0x69, 0x65, 0x6e, 0x74, 0x12, 0x1b,
+	0x0a, 0x09, 0x73, 0x65, 0x65, 0x64, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x19, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x08, 0x73, 0x65, 0x65, 0x64, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x73,
+	0x65, 0x65, 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x1a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08,
+	0x73, 0x65, 0x65, 0x64, 0x54, 0x79, 0x70, 0x65, 0x12, 0x3d, 0x0a, 0x1b, 0x74, 0x72, 0x75, 0x6e,
+	0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x5f, 0x70, 0x6f,
+	0x6f, 0x6c, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x1b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x18, 0x74,
+	0x72, 0x75, 0x6e, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x68, 0x72, 0x65, 0x61, 0x64, 0x50,
+	0x6f, 0x6f, 0x6c, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x35, 0x0a, 0x17, 0x62, 0x61, 0x74, 0x63, 0x68,
+	0x5f, 0x73, 0x69, 0x7a, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x18, 0x1c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x14, 0x62, 0x61, 0x74, 0x63, 0x68, 0x53,
+	0x69, 0x7a, 0x65, 0x46, 0x6f, 0x72, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1d,
+	0x0a, 0x0a, 0x67, 0x72, 0x61, 0x70, 0x68, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x1d, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x09, 0x67, 0x72, 0x61, 0x70, 0x68, 0x54, 0x79, 0x70, 0x65, 0x12, 0x33, 0x0a,
+	0x16, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x5f, 0x65, 0x64, 0x67, 0x65, 0x5f, 0x73, 0x69,
+	0x7a, 0x65, 0x5f, 0x62, 0x61, 0x73, 0x65, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x05, 0x52, 0x13, 0x64,
+	0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x45, 0x64, 0x67, 0x65, 0x53, 0x69, 0x7a, 0x65, 0x42, 0x61,
+	0x73, 0x65, 0x12, 0x33, 0x0a, 0x16, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x5f, 0x65, 0x64,
+	0x67, 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x1f, 0x20, 0x01,
+	0x28, 0x05, 0x52, 0x13, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x45, 0x64, 0x67, 0x65, 0x53,
+	0x69, 0x7a, 0x65, 0x52, 0x61, 0x74, 0x65, 0x12, 0x28, 0x0a, 0x10, 0x62, 0x75, 0x69, 0x6c, 0x64,
+	0x5f, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x20, 0x20, 0x01, 0x28,
+	0x02, 0x52, 0x0e, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x4c, 0x69, 0x6d, 0x69,
+	0x74, 0x12, 0x23, 0x0a, 0x0d, 0x6f, 0x75, 0x74, 0x67, 0x6f, 0x69, 0x6e, 0x67, 0x5f, 0x65, 0x64,
+	0x67, 0x65, 0x18, 0x21, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x6f, 0x75, 0x74, 0x67, 0x6f, 0x69,
+	0x6e, 0x67, 0x45, 0x64, 0x67, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x69, 0x6e, 0x63, 0x6f, 0x6d, 0x69,
+	0x6e, 0x67, 0x5f, 0x65, 0x64, 0x67, 0x65, 0x18, 0x22, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x69,
+	0x6e, 0x63, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x45, 0x64, 0x67, 0x65, 0x1a, 0xbb, 0x01, 0x0a, 0x0e,
+	0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x12, 0x4c,
+	0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x32, 0x2e, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x66,
+	0x6f, 0x2e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79,
+	0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x2e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x45, 0x6e,
+	0x74, 0x72, 0x79, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x1a, 0x5b, 0x0a, 0x0c,
+	0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03,
+	0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x35,
+	0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e,
+	0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x66, 0x6f, 0x2e,
+	0x49, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x52, 0x05,
 	0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0xef, 0x01, 0x0a, 0x03, 0x50, 0x6f,
 	0x64, 0x12, 0x19, 0x0a, 0x08, 0x61, 0x70, 0x70, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20,
 	0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x70, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04,
@@ -6094,7 +6565,7 @@ func file_v1_payload_payload_proto_rawDescGZIP() []byte {
 
 var (
 	file_v1_payload_payload_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
-	file_v1_payload_payload_proto_msgTypes  = make([]protoimpl.MessageInfo, 93)
+	file_v1_payload_payload_proto_msgTypes  = make([]protoimpl.MessageInfo, 96)
 	file_v1_payload_payload_proto_goTypes   = []any{
 		(Search_AggregationAlgorithm)(0),    // 0: payload.v1.Search.AggregationAlgorithm
 		(Remove_Timestamp_Operator)(0),      // 1: payload.v1.Remove.Timestamp.Operator
@@ -6183,16 +6654,19 @@ var (
 		(*Info_Index_UUID)(nil),             // 84: payload.v1.Info.Index.UUID
 		(*Info_Index_Statistics)(nil),       // 85: payload.v1.Info.Index.Statistics
 		(*Info_Index_StatisticsDetail)(nil), // 86: payload.v1.Info.Index.StatisticsDetail
-		nil,                                 // 87: payload.v1.Info.Index.Detail.CountsEntry
-		(*Info_Index_UUID_Committed)(nil),   // 88: payload.v1.Info.Index.UUID.Committed
-		(*Info_Index_UUID_Uncommitted)(nil), // 89: payload.v1.Info.Index.UUID.Uncommitted
-		nil,                                 // 90: payload.v1.Info.Index.StatisticsDetail.DetailsEntry
-		nil,                                 // 91: payload.v1.Info.Labels.LabelsEntry
-		nil,                                 // 92: payload.v1.Info.Annotations.AnnotationsEntry
-		(*Mirror_Target)(nil),               // 93: payload.v1.Mirror.Target
-		(*Mirror_Targets)(nil),              // 94: payload.v1.Mirror.Targets
-		(*wrapperspb.FloatValue)(nil),       // 95: google.protobuf.FloatValue
-		(*status.Status)(nil),               // 96: google.rpc.Status
+		(*Info_Index_Property)(nil),         // 87: payload.v1.Info.Index.Property
+		(*Info_Index_PropertyDetail)(nil),   // 88: payload.v1.Info.Index.PropertyDetail
+		nil,                                 // 89: payload.v1.Info.Index.Detail.CountsEntry
+		(*Info_Index_UUID_Committed)(nil),   // 90: payload.v1.Info.Index.UUID.Committed
+		(*Info_Index_UUID_Uncommitted)(nil), // 91: payload.v1.Info.Index.UUID.Uncommitted
+		nil,                                 // 92: payload.v1.Info.Index.StatisticsDetail.DetailsEntry
+		nil,                                 // 93: payload.v1.Info.Index.PropertyDetail.DetailsEntry
+		nil,                                 // 94: payload.v1.Info.Labels.LabelsEntry
+		nil,                                 // 95: payload.v1.Info.Annotations.AnnotationsEntry
+		(*Mirror_Target)(nil),               // 96: payload.v1.Mirror.Target
+		(*Mirror_Targets)(nil),              // 97: payload.v1.Mirror.Targets
+		(*wrapperspb.FloatValue)(nil),       // 98: google.protobuf.FloatValue
+		(*status.Status)(nil),               // 99: google.rpc.Status
 	}
 )
 
@@ -6207,11 +6681,11 @@ var file_v1_payload_payload_proto_depIdxs = []int32{
 	26, // 7: payload.v1.Search.Config.ingress_filters:type_name -> payload.v1.Filter.Config
 	26, // 8: payload.v1.Search.Config.egress_filters:type_name -> payload.v1.Filter.Config
 	0,  // 9: payload.v1.Search.Config.aggregation_algorithm:type_name -> payload.v1.Search.AggregationAlgorithm
-	95, // 10: payload.v1.Search.Config.ratio:type_name -> google.protobuf.FloatValue
+	98, // 10: payload.v1.Search.Config.ratio:type_name -> google.protobuf.FloatValue
 	49, // 11: payload.v1.Search.Response.results:type_name -> payload.v1.Object.Distance
 	22, // 12: payload.v1.Search.Responses.responses:type_name -> payload.v1.Search.Response
 	22, // 13: payload.v1.Search.StreamResponse.response:type_name -> payload.v1.Search.Response
-	96, // 14: payload.v1.Search.StreamResponse.status:type_name -> google.rpc.Status
+	99, // 14: payload.v1.Search.StreamResponse.status:type_name -> google.rpc.Status
 	25, // 15: payload.v1.Filter.Config.targets:type_name -> payload.v1.Filter.Target
 	53, // 16: payload.v1.Insert.Request.vector:type_name -> payload.v1.Object.Vector
 	31, // 17: payload.v1.Insert.Request.config:type_name -> payload.v1.Insert.Config
@@ -6245,18 +6719,18 @@ var file_v1_payload_payload_proto_depIdxs = []int32{
 	51, // 45: payload.v1.Object.VectorRequest.id:type_name -> payload.v1.Object.ID
 	26, // 46: payload.v1.Object.VectorRequest.filters:type_name -> payload.v1.Filter.Config
 	49, // 47: payload.v1.Object.StreamDistance.distance:type_name -> payload.v1.Object.Distance
-	96, // 48: payload.v1.Object.StreamDistance.status:type_name -> google.rpc.Status
+	99, // 48: payload.v1.Object.StreamDistance.status:type_name -> google.rpc.Status
 	51, // 49: payload.v1.Object.TimestampRequest.id:type_name -> payload.v1.Object.ID
 	53, // 50: payload.v1.Object.Vectors.vectors:type_name -> payload.v1.Object.Vector
 	53, // 51: payload.v1.Object.StreamVector.vector:type_name -> payload.v1.Object.Vector
-	96, // 52: payload.v1.Object.StreamVector.status:type_name -> google.rpc.Status
+	99, // 52: payload.v1.Object.StreamVector.status:type_name -> google.rpc.Status
 	59, // 53: payload.v1.Object.StreamBlob.blob:type_name -> payload.v1.Object.Blob
-	96, // 54: payload.v1.Object.StreamBlob.status:type_name -> google.rpc.Status
+	99, // 54: payload.v1.Object.StreamBlob.status:type_name -> google.rpc.Status
 	61, // 55: payload.v1.Object.StreamLocation.location:type_name -> payload.v1.Object.Location
-	96, // 56: payload.v1.Object.StreamLocation.status:type_name -> google.rpc.Status
+	99, // 56: payload.v1.Object.StreamLocation.status:type_name -> google.rpc.Status
 	61, // 57: payload.v1.Object.Locations.locations:type_name -> payload.v1.Object.Location
 	53, // 58: payload.v1.Object.List.Response.vector:type_name -> payload.v1.Object.Vector
-	96, // 59: payload.v1.Object.List.Response.status:type_name -> google.rpc.Status
+	99, // 59: payload.v1.Object.List.Response.status:type_name -> google.rpc.Status
 	76, // 60: payload.v1.Info.Pod.cpu:type_name -> payload.v1.Info.CPU
 	77, // 61: payload.v1.Info.Pod.memory:type_name -> payload.v1.Info.Memory
 	71, // 62: payload.v1.Info.Pod.node:type_name -> payload.v1.Info.Node
@@ -6266,21 +6740,23 @@ var file_v1_payload_payload_proto_depIdxs = []int32{
 	73, // 66: payload.v1.Info.Service.ports:type_name -> payload.v1.Info.ServicePort
 	74, // 67: payload.v1.Info.Service.labels:type_name -> payload.v1.Info.Labels
 	75, // 68: payload.v1.Info.Service.annotations:type_name -> payload.v1.Info.Annotations
-	91, // 69: payload.v1.Info.Labels.labels:type_name -> payload.v1.Info.Labels.LabelsEntry
-	92, // 70: payload.v1.Info.Annotations.annotations:type_name -> payload.v1.Info.Annotations.AnnotationsEntry
+	94, // 69: payload.v1.Info.Labels.labels:type_name -> payload.v1.Info.Labels.LabelsEntry
+	95, // 70: payload.v1.Info.Annotations.annotations:type_name -> payload.v1.Info.Annotations.AnnotationsEntry
 	70, // 71: payload.v1.Info.Pods.pods:type_name -> payload.v1.Info.Pod
 	71, // 72: payload.v1.Info.Nodes.nodes:type_name -> payload.v1.Info.Node
 	72, // 73: payload.v1.Info.Services.services:type_name -> payload.v1.Info.Service
-	87, // 74: payload.v1.Info.Index.Detail.counts:type_name -> payload.v1.Info.Index.Detail.CountsEntry
-	90, // 75: payload.v1.Info.Index.StatisticsDetail.details:type_name -> payload.v1.Info.Index.StatisticsDetail.DetailsEntry
-	82, // 76: payload.v1.Info.Index.Detail.CountsEntry.value:type_name -> payload.v1.Info.Index.Count
-	85, // 77: payload.v1.Info.Index.StatisticsDetail.DetailsEntry.value:type_name -> payload.v1.Info.Index.Statistics
-	93, // 78: payload.v1.Mirror.Targets.targets:type_name -> payload.v1.Mirror.Target
-	79, // [79:79] is the sub-list for method output_type
-	79, // [79:79] is the sub-list for method input_type
-	79, // [79:79] is the sub-list for extension type_name
-	79, // [79:79] is the sub-list for extension extendee
-	0,  // [0:79] is the sub-list for field type_name
+	89, // 74: payload.v1.Info.Index.Detail.counts:type_name -> payload.v1.Info.Index.Detail.CountsEntry
+	92, // 75: payload.v1.Info.Index.StatisticsDetail.details:type_name -> payload.v1.Info.Index.StatisticsDetail.DetailsEntry
+	93, // 76: payload.v1.Info.Index.PropertyDetail.details:type_name -> payload.v1.Info.Index.PropertyDetail.DetailsEntry
+	82, // 77: payload.v1.Info.Index.Detail.CountsEntry.value:type_name -> payload.v1.Info.Index.Count
+	85, // 78: payload.v1.Info.Index.StatisticsDetail.DetailsEntry.value:type_name -> payload.v1.Info.Index.Statistics
+	87, // 79: payload.v1.Info.Index.PropertyDetail.DetailsEntry.value:type_name -> payload.v1.Info.Index.Property
+	96, // 80: payload.v1.Mirror.Targets.targets:type_name -> payload.v1.Mirror.Target
+	81, // [81:81] is the sub-list for method output_type
+	81, // [81:81] is the sub-list for method input_type
+	81, // [81:81] is the sub-list for extension type_name
+	81, // [81:81] is the sub-list for extension extendee
+	0,  // [0:81] is the sub-list for field type_name
 }
 
 func init() { file_v1_payload_payload_proto_init() }
@@ -7309,7 +7785,31 @@ func file_v1_payload_payload_proto_init() {
 				return nil
 			}
 		}
+		file_v1_payload_payload_proto_msgTypes[85].Exporter = func(v any, i int) any {
+			switch v := v.(*Info_Index_Property); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
 		file_v1_payload_payload_proto_msgTypes[86].Exporter = func(v any, i int) any {
+			switch v := v.(*Info_Index_PropertyDetail); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_v1_payload_payload_proto_msgTypes[88].Exporter = func(v any, i int) any {
 			switch v := v.(*Info_Index_UUID_Committed); i {
 			case 0:
 				return &v.state
@@ -7321,7 +7821,7 @@ func file_v1_payload_payload_proto_init() {
 				return nil
 			}
 		}
-		file_v1_payload_payload_proto_msgTypes[87].Exporter = func(v any, i int) any {
+		file_v1_payload_payload_proto_msgTypes[89].Exporter = func(v any, i int) any {
 			switch v := v.(*Info_Index_UUID_Uncommitted); i {
 			case 0:
 				return &v.state
@@ -7333,7 +7833,7 @@ func file_v1_payload_payload_proto_init() {
 				return nil
 			}
 		}
-		file_v1_payload_payload_proto_msgTypes[91].Exporter = func(v any, i int) any {
+		file_v1_payload_payload_proto_msgTypes[94].Exporter = func(v any, i int) any {
 			switch v := v.(*Mirror_Target); i {
 			case 0:
 				return &v.state
@@ -7345,7 +7845,7 @@ func file_v1_payload_payload_proto_init() {
 				return nil
 			}
 		}
-		file_v1_payload_payload_proto_msgTypes[92].Exporter = func(v any, i int) any {
+		file_v1_payload_payload_proto_msgTypes[95].Exporter = func(v any, i int) any {
 			switch v := v.(*Mirror_Targets); i {
 			case 0:
 				return &v.state
@@ -7388,7 +7888,7 @@ func file_v1_payload_payload_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_v1_payload_payload_proto_rawDesc,
 			NumEnums:      2,
-			NumMessages:   93,
+			NumMessages:   96,
 			NumExtensions: 0,
 			NumServices:   0,
 		},
diff --git a/apis/grpc/v1/payload/payload.pb.json.go b/apis/grpc/v1/payload/payload.pb.json.go
index 159ebc555cb..f05c39d2772 100644
--- a/apis/grpc/v1/payload/payload.pb.json.go
+++ b/apis/grpc/v1/payload/payload.pb.json.go
@@ -751,6 +751,26 @@ func (msg *Info_Index_StatisticsDetail) UnmarshalJSON(b []byte) error {
 	return protojson.UnmarshalOptions{}.Unmarshal(b, msg)
 }
 
+// MarshalJSON implements json.Marshaler
+func (msg *Info_Index_Property) MarshalJSON() ([]byte, error) {
+	return protojson.MarshalOptions{}.Marshal(msg)
+}
+
+// UnmarshalJSON implements json.Unmarshaler
+func (msg *Info_Index_Property) UnmarshalJSON(b []byte) error {
+	return protojson.UnmarshalOptions{}.Unmarshal(b, msg)
+}
+
+// MarshalJSON implements json.Marshaler
+func (msg *Info_Index_PropertyDetail) MarshalJSON() ([]byte, error) {
+	return protojson.MarshalOptions{}.Marshal(msg)
+}
+
+// UnmarshalJSON implements json.Unmarshaler
+func (msg *Info_Index_PropertyDetail) UnmarshalJSON(b []byte) error {
+	return protojson.UnmarshalOptions{}.Unmarshal(b, msg)
+}
+
 // MarshalJSON implements json.Marshaler
 func (msg *Info_Pod) MarshalJSON() ([]byte, error) {
 	return protojson.MarshalOptions{}.Marshal(msg)
diff --git a/apis/grpc/v1/payload/payload_vtproto.pb.go b/apis/grpc/v1/payload/payload_vtproto.pb.go
index b2a6c8d6544..4a9f01cb475 100644
--- a/apis/grpc/v1/payload/payload_vtproto.pb.go
+++ b/apis/grpc/v1/payload/payload_vtproto.pb.go
@@ -1633,6 +1633,79 @@ func (m *Info_Index_StatisticsDetail) CloneMessageVT() proto.Message {
 	return m.CloneVT()
 }
 
+func (m *Info_Index_Property) CloneVT() *Info_Index_Property {
+	if m == nil {
+		return (*Info_Index_Property)(nil)
+	}
+	r := new(Info_Index_Property)
+	r.Dimension = m.Dimension
+	r.ThreadPoolSize = m.ThreadPoolSize
+	r.ObjectType = m.ObjectType
+	r.DistanceType = m.DistanceType
+	r.IndexType = m.IndexType
+	r.DatabaseType = m.DatabaseType
+	r.ObjectAlignment = m.ObjectAlignment
+	r.PathAdjustmentInterval = m.PathAdjustmentInterval
+	r.GraphSharedMemorySize = m.GraphSharedMemorySize
+	r.TreeSharedMemorySize = m.TreeSharedMemorySize
+	r.ObjectSharedMemorySize = m.ObjectSharedMemorySize
+	r.PrefetchOffset = m.PrefetchOffset
+	r.PrefetchSize = m.PrefetchSize
+	r.AccuracyTable = m.AccuracyTable
+	r.SearchType = m.SearchType
+	r.MaxMagnitude = m.MaxMagnitude
+	r.NOfNeighborsForInsertionOrder = m.NOfNeighborsForInsertionOrder
+	r.EpsilonForInsertionOrder = m.EpsilonForInsertionOrder
+	r.RefinementObjectType = m.RefinementObjectType
+	r.TruncationThreshold = m.TruncationThreshold
+	r.EdgeSizeForCreation = m.EdgeSizeForCreation
+	r.EdgeSizeForSearch = m.EdgeSizeForSearch
+	r.EdgeSizeLimitForCreation = m.EdgeSizeLimitForCreation
+	r.InsertionRadiusCoefficient = m.InsertionRadiusCoefficient
+	r.SeedSize = m.SeedSize
+	r.SeedType = m.SeedType
+	r.TruncationThreadPoolSize = m.TruncationThreadPoolSize
+	r.BatchSizeForCreation = m.BatchSizeForCreation
+	r.GraphType = m.GraphType
+	r.DynamicEdgeSizeBase = m.DynamicEdgeSizeBase
+	r.DynamicEdgeSizeRate = m.DynamicEdgeSizeRate
+	r.BuildTimeLimit = m.BuildTimeLimit
+	r.OutgoingEdge = m.OutgoingEdge
+	r.IncomingEdge = m.IncomingEdge
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *Info_Index_Property) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
+func (m *Info_Index_PropertyDetail) CloneVT() *Info_Index_PropertyDetail {
+	if m == nil {
+		return (*Info_Index_PropertyDetail)(nil)
+	}
+	r := new(Info_Index_PropertyDetail)
+	if rhs := m.Details; rhs != nil {
+		tmpContainer := make(map[string]*Info_Index_Property, len(rhs))
+		for k, v := range rhs {
+			tmpContainer[k] = v.CloneVT()
+		}
+		r.Details = tmpContainer
+	}
+	if len(m.unknownFields) > 0 {
+		r.unknownFields = make([]byte, len(m.unknownFields))
+		copy(r.unknownFields, m.unknownFields)
+	}
+	return r
+}
+
+func (m *Info_Index_PropertyDetail) CloneMessageVT() proto.Message {
+	return m.CloneVT()
+}
+
 func (m *Info_Index) CloneVT() *Info_Index {
 	if m == nil {
 		return (*Info_Index)(nil)
@@ -4324,6 +4397,162 @@ func (this *Info_Index_StatisticsDetail) EqualMessageVT(thatMsg proto.Message) b
 	return this.EqualVT(that)
 }
 
+func (this *Info_Index_Property) EqualVT(that *Info_Index_Property) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if this.Dimension != that.Dimension {
+		return false
+	}
+	if this.ThreadPoolSize != that.ThreadPoolSize {
+		return false
+	}
+	if this.ObjectType != that.ObjectType {
+		return false
+	}
+	if this.DistanceType != that.DistanceType {
+		return false
+	}
+	if this.IndexType != that.IndexType {
+		return false
+	}
+	if this.DatabaseType != that.DatabaseType {
+		return false
+	}
+	if this.ObjectAlignment != that.ObjectAlignment {
+		return false
+	}
+	if this.PathAdjustmentInterval != that.PathAdjustmentInterval {
+		return false
+	}
+	if this.GraphSharedMemorySize != that.GraphSharedMemorySize {
+		return false
+	}
+	if this.TreeSharedMemorySize != that.TreeSharedMemorySize {
+		return false
+	}
+	if this.ObjectSharedMemorySize != that.ObjectSharedMemorySize {
+		return false
+	}
+	if this.PrefetchOffset != that.PrefetchOffset {
+		return false
+	}
+	if this.PrefetchSize != that.PrefetchSize {
+		return false
+	}
+	if this.AccuracyTable != that.AccuracyTable {
+		return false
+	}
+	if this.SearchType != that.SearchType {
+		return false
+	}
+	if this.MaxMagnitude != that.MaxMagnitude {
+		return false
+	}
+	if this.NOfNeighborsForInsertionOrder != that.NOfNeighborsForInsertionOrder {
+		return false
+	}
+	if this.EpsilonForInsertionOrder != that.EpsilonForInsertionOrder {
+		return false
+	}
+	if this.RefinementObjectType != that.RefinementObjectType {
+		return false
+	}
+	if this.TruncationThreshold != that.TruncationThreshold {
+		return false
+	}
+	if this.EdgeSizeForCreation != that.EdgeSizeForCreation {
+		return false
+	}
+	if this.EdgeSizeForSearch != that.EdgeSizeForSearch {
+		return false
+	}
+	if this.EdgeSizeLimitForCreation != that.EdgeSizeLimitForCreation {
+		return false
+	}
+	if this.InsertionRadiusCoefficient != that.InsertionRadiusCoefficient {
+		return false
+	}
+	if this.SeedSize != that.SeedSize {
+		return false
+	}
+	if this.SeedType != that.SeedType {
+		return false
+	}
+	if this.TruncationThreadPoolSize != that.TruncationThreadPoolSize {
+		return false
+	}
+	if this.BatchSizeForCreation != that.BatchSizeForCreation {
+		return false
+	}
+	if this.GraphType != that.GraphType {
+		return false
+	}
+	if this.DynamicEdgeSizeBase != that.DynamicEdgeSizeBase {
+		return false
+	}
+	if this.DynamicEdgeSizeRate != that.DynamicEdgeSizeRate {
+		return false
+	}
+	if this.BuildTimeLimit != that.BuildTimeLimit {
+		return false
+	}
+	if this.OutgoingEdge != that.OutgoingEdge {
+		return false
+	}
+	if this.IncomingEdge != that.IncomingEdge {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *Info_Index_Property) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*Info_Index_Property)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+
+func (this *Info_Index_PropertyDetail) EqualVT(that *Info_Index_PropertyDetail) bool {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
+		return false
+	}
+	if len(this.Details) != len(that.Details) {
+		return false
+	}
+	for i, vx := range this.Details {
+		vy, ok := that.Details[i]
+		if !ok {
+			return false
+		}
+		if p, q := vx, vy; p != q {
+			if p == nil {
+				p = &Info_Index_Property{}
+			}
+			if q == nil {
+				q = &Info_Index_Property{}
+			}
+			if !p.EqualVT(q) {
+				return false
+			}
+		}
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (this *Info_Index_PropertyDetail) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*Info_Index_PropertyDetail)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
+
 func (this *Info_Index) EqualVT(that *Info_Index) bool {
 	if this == that {
 		return true
@@ -8725,7 +8954,7 @@ func (m *Info_Index_StatisticsDetail) MarshalToSizedBufferVT(dAtA []byte) (int,
 	return len(dAtA) - i, nil
 }
 
-func (m *Info_Index) MarshalVT() (dAtA []byte, err error) {
+func (m *Info_Index_Property) MarshalVT() (dAtA []byte, err error) {
 	if m == nil {
 		return nil, nil
 	}
@@ -8738,12 +8967,12 @@ func (m *Info_Index) MarshalVT() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Info_Index) MarshalToVT(dAtA []byte) (int, error) {
+func (m *Info_Index_Property) MarshalToVT(dAtA []byte) (int, error) {
 	size := m.SizeVT()
 	return m.MarshalToSizedBufferVT(dAtA[:size])
 }
 
-func (m *Info_Index) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
+func (m *Info_Index_Property) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
 	if m == nil {
 		return 0, nil
 	}
@@ -8755,273 +8984,226 @@ func (m *Info_Index) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
 		i -= len(m.unknownFields)
 		copy(dAtA[i:], m.unknownFields)
 	}
-	return len(dAtA) - i, nil
-}
-
-func (m *Info_Pod) MarshalVT() (dAtA []byte, err error) {
-	if m == nil {
-		return nil, nil
-	}
-	size := m.SizeVT()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
-	if err != nil {
-		return nil, err
+	if m.IncomingEdge != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.IncomingEdge))
+		i--
+		dAtA[i] = 0x2
+		i--
+		dAtA[i] = 0x90
 	}
-	return dAtA[:n], nil
-}
-
-func (m *Info_Pod) MarshalToVT(dAtA []byte) (int, error) {
-	size := m.SizeVT()
-	return m.MarshalToSizedBufferVT(dAtA[:size])
-}
-
-func (m *Info_Pod) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
-	if m == nil {
-		return 0, nil
+	if m.OutgoingEdge != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.OutgoingEdge))
+		i--
+		dAtA[i] = 0x2
+		i--
+		dAtA[i] = 0x88
 	}
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.unknownFields != nil {
-		i -= len(m.unknownFields)
-		copy(dAtA[i:], m.unknownFields)
+	if m.BuildTimeLimit != 0 {
+		i -= 4
+		binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.BuildTimeLimit))))
+		i--
+		dAtA[i] = 0x2
+		i--
+		dAtA[i] = 0x85
 	}
-	if m.Node != nil {
-		size, err := m.Node.MarshalToSizedBufferVT(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
+	if m.DynamicEdgeSizeRate != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.DynamicEdgeSizeRate))
 		i--
-		dAtA[i] = 0x3a
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xf8
 	}
-	if m.Memory != nil {
-		size, err := m.Memory.MarshalToSizedBufferVT(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
+	if m.DynamicEdgeSizeBase != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.DynamicEdgeSizeBase))
 		i--
-		dAtA[i] = 0x32
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xf0
 	}
-	if m.Cpu != nil {
-		size, err := m.Cpu.MarshalToSizedBufferVT(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
+	if m.GraphType != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.GraphType))
 		i--
-		dAtA[i] = 0x2a
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xe8
 	}
-	if len(m.Ip) > 0 {
-		i -= len(m.Ip)
-		copy(dAtA[i:], m.Ip)
-		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Ip)))
+	if m.BatchSizeForCreation != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.BatchSizeForCreation))
 		i--
-		dAtA[i] = 0x22
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xe0
 	}
-	if len(m.Namespace) > 0 {
-		i -= len(m.Namespace)
-		copy(dAtA[i:], m.Namespace)
-		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Namespace)))
+	if m.TruncationThreadPoolSize != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TruncationThreadPoolSize))
 		i--
-		dAtA[i] = 0x1a
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xd8
 	}
-	if len(m.Name) > 0 {
-		i -= len(m.Name)
-		copy(dAtA[i:], m.Name)
-		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
+	if m.SeedType != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.SeedType))
 		i--
-		dAtA[i] = 0x12
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xd0
 	}
-	if len(m.AppName) > 0 {
-		i -= len(m.AppName)
-		copy(dAtA[i:], m.AppName)
-		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.AppName)))
+	if m.SeedSize != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.SeedSize))
 		i--
-		dAtA[i] = 0xa
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xc8
 	}
-	return len(dAtA) - i, nil
-}
-
-func (m *Info_Node) MarshalVT() (dAtA []byte, err error) {
-	if m == nil {
-		return nil, nil
+	if m.InsertionRadiusCoefficient != 0 {
+		i -= 8
+		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.InsertionRadiusCoefficient))))
+		i--
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xc1
 	}
-	size := m.SizeVT()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
-	if err != nil {
-		return nil, err
+	if m.EdgeSizeLimitForCreation != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.EdgeSizeLimitForCreation))
+		i--
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xb8
 	}
-	return dAtA[:n], nil
-}
-
-func (m *Info_Node) MarshalToVT(dAtA []byte) (int, error) {
-	size := m.SizeVT()
-	return m.MarshalToSizedBufferVT(dAtA[:size])
-}
-
-func (m *Info_Node) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
-	if m == nil {
-		return 0, nil
+	if m.EdgeSizeForSearch != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.EdgeSizeForSearch))
+		i--
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xb0
 	}
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.unknownFields != nil {
-		i -= len(m.unknownFields)
-		copy(dAtA[i:], m.unknownFields)
+	if m.EdgeSizeForCreation != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.EdgeSizeForCreation))
+		i--
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xa8
 	}
-	if m.Pods != nil {
-		size, err := m.Pods.MarshalToSizedBufferVT(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
+	if m.TruncationThreshold != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TruncationThreshold))
 		i--
-		dAtA[i] = 0x32
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xa0
 	}
-	if m.Memory != nil {
-		size, err := m.Memory.MarshalToSizedBufferVT(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
+	if m.RefinementObjectType != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.RefinementObjectType))
 		i--
-		dAtA[i] = 0x2a
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0x98
 	}
-	if m.Cpu != nil {
-		size, err := m.Cpu.MarshalToSizedBufferVT(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
+	if m.EpsilonForInsertionOrder != 0 {
+		i -= 4
+		binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.EpsilonForInsertionOrder))))
 		i--
-		dAtA[i] = 0x22
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0x95
 	}
-	if len(m.ExternalAddr) > 0 {
-		i -= len(m.ExternalAddr)
-		copy(dAtA[i:], m.ExternalAddr)
-		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ExternalAddr)))
+	if m.NOfNeighborsForInsertionOrder != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.NOfNeighborsForInsertionOrder))
 		i--
-		dAtA[i] = 0x1a
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0x88
 	}
-	if len(m.InternalAddr) > 0 {
-		i -= len(m.InternalAddr)
-		copy(dAtA[i:], m.InternalAddr)
-		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.InternalAddr)))
+	if m.MaxMagnitude != 0 {
+		i -= 4
+		binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.MaxMagnitude))))
 		i--
-		dAtA[i] = 0x12
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0x85
 	}
-	if len(m.Name) > 0 {
-		i -= len(m.Name)
-		copy(dAtA[i:], m.Name)
-		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
+	if len(m.SearchType) > 0 {
+		i -= len(m.SearchType)
+		copy(dAtA[i:], m.SearchType)
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SearchType)))
 		i--
-		dAtA[i] = 0xa
+		dAtA[i] = 0x7a
 	}
-	return len(dAtA) - i, nil
-}
-
-func (m *Info_Service) MarshalVT() (dAtA []byte, err error) {
-	if m == nil {
-		return nil, nil
+	if len(m.AccuracyTable) > 0 {
+		i -= len(m.AccuracyTable)
+		copy(dAtA[i:], m.AccuracyTable)
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.AccuracyTable)))
+		i--
+		dAtA[i] = 0x72
 	}
-	size := m.SizeVT()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
-	if err != nil {
-		return nil, err
+	if m.PrefetchSize != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.PrefetchSize))
+		i--
+		dAtA[i] = 0x68
 	}
-	return dAtA[:n], nil
-}
-
-func (m *Info_Service) MarshalToVT(dAtA []byte) (int, error) {
-	size := m.SizeVT()
-	return m.MarshalToSizedBufferVT(dAtA[:size])
-}
-
-func (m *Info_Service) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
-	if m == nil {
-		return 0, nil
+	if m.PrefetchOffset != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.PrefetchOffset))
+		i--
+		dAtA[i] = 0x60
 	}
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.unknownFields != nil {
-		i -= len(m.unknownFields)
-		copy(dAtA[i:], m.unknownFields)
+	if m.ObjectSharedMemorySize != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ObjectSharedMemorySize))
+		i--
+		dAtA[i] = 0x58
 	}
-	if m.Annotations != nil {
-		size, err := m.Annotations.MarshalToSizedBufferVT(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
+	if m.TreeSharedMemorySize != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TreeSharedMemorySize))
 		i--
-		dAtA[i] = 0x32
+		dAtA[i] = 0x50
 	}
-	if m.Labels != nil {
-		size, err := m.Labels.MarshalToSizedBufferVT(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
+	if m.GraphSharedMemorySize != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.GraphSharedMemorySize))
 		i--
-		dAtA[i] = 0x2a
+		dAtA[i] = 0x48
 	}
-	if len(m.Ports) > 0 {
-		for iNdEx := len(m.Ports) - 1; iNdEx >= 0; iNdEx-- {
-			size, err := m.Ports[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
-			i--
-			dAtA[i] = 0x22
-		}
+	if m.PathAdjustmentInterval != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.PathAdjustmentInterval))
+		i--
+		dAtA[i] = 0x40
 	}
-	if len(m.ClusterIps) > 0 {
-		for iNdEx := len(m.ClusterIps) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.ClusterIps[iNdEx])
-			copy(dAtA[i:], m.ClusterIps[iNdEx])
-			i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ClusterIps[iNdEx])))
-			i--
-			dAtA[i] = 0x1a
-		}
+	if m.ObjectAlignment != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ObjectAlignment))
+		i--
+		dAtA[i] = 0x38
 	}
-	if len(m.ClusterIp) > 0 {
-		i -= len(m.ClusterIp)
-		copy(dAtA[i:], m.ClusterIp)
-		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ClusterIp)))
+	if m.DatabaseType != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.DatabaseType))
 		i--
-		dAtA[i] = 0x12
+		dAtA[i] = 0x30
 	}
-	if len(m.Name) > 0 {
-		i -= len(m.Name)
-		copy(dAtA[i:], m.Name)
-		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
+	if m.IndexType != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.IndexType))
 		i--
-		dAtA[i] = 0xa
+		dAtA[i] = 0x28
+	}
+	if m.DistanceType != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.DistanceType))
+		i--
+		dAtA[i] = 0x20
+	}
+	if m.ObjectType != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ObjectType))
+		i--
+		dAtA[i] = 0x18
+	}
+	if m.ThreadPoolSize != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ThreadPoolSize))
+		i--
+		dAtA[i] = 0x10
+	}
+	if m.Dimension != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Dimension))
+		i--
+		dAtA[i] = 0x8
 	}
 	return len(dAtA) - i, nil
 }
 
-func (m *Info_ServicePort) MarshalVT() (dAtA []byte, err error) {
+func (m *Info_Index_PropertyDetail) MarshalVT() (dAtA []byte, err error) {
 	if m == nil {
 		return nil, nil
 	}
@@ -9034,12 +9216,12 @@ func (m *Info_ServicePort) MarshalVT() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Info_ServicePort) MarshalToVT(dAtA []byte) (int, error) {
+func (m *Info_Index_PropertyDetail) MarshalToVT(dAtA []byte) (int, error) {
 	size := m.SizeVT()
 	return m.MarshalToSizedBufferVT(dAtA[:size])
 }
 
-func (m *Info_ServicePort) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
+func (m *Info_Index_PropertyDetail) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
 	if m == nil {
 		return 0, nil
 	}
@@ -9051,22 +9233,32 @@ func (m *Info_ServicePort) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
 		i -= len(m.unknownFields)
 		copy(dAtA[i:], m.unknownFields)
 	}
-	if m.Port != 0 {
-		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Port))
-		i--
-		dAtA[i] = 0x10
-	}
-	if len(m.Name) > 0 {
-		i -= len(m.Name)
-		copy(dAtA[i:], m.Name)
-		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
-		i--
-		dAtA[i] = 0xa
+	if len(m.Details) > 0 {
+		for k := range m.Details {
+			v := m.Details[k]
+			baseI := i
+			size, err := v.MarshalToSizedBufferVT(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
+			i--
+			dAtA[i] = 0x12
+			i -= len(k)
+			copy(dAtA[i:], k)
+			i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))
+			i--
+			dAtA[i] = 0xa
+			i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))
+			i--
+			dAtA[i] = 0xa
+		}
 	}
 	return len(dAtA) - i, nil
 }
 
-func (m *Info_Labels) MarshalVT() (dAtA []byte, err error) {
+func (m *Info_Index) MarshalVT() (dAtA []byte, err error) {
 	if m == nil {
 		return nil, nil
 	}
@@ -9079,12 +9271,12 @@ func (m *Info_Labels) MarshalVT() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Info_Labels) MarshalToVT(dAtA []byte) (int, error) {
+func (m *Info_Index) MarshalToVT(dAtA []byte) (int, error) {
 	size := m.SizeVT()
 	return m.MarshalToSizedBufferVT(dAtA[:size])
 }
 
-func (m *Info_Labels) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
+func (m *Info_Index) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
 	if m == nil {
 		return 0, nil
 	}
@@ -9096,29 +9288,10 @@ func (m *Info_Labels) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
 		i -= len(m.unknownFields)
 		copy(dAtA[i:], m.unknownFields)
 	}
-	if len(m.Labels) > 0 {
-		for k := range m.Labels {
-			v := m.Labels[k]
-			baseI := i
-			i -= len(v)
-			copy(dAtA[i:], v)
-			i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v)))
-			i--
-			dAtA[i] = 0x12
-			i -= len(k)
-			copy(dAtA[i:], k)
-			i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))
-			i--
-			dAtA[i] = 0xa
-			i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))
-			i--
-			dAtA[i] = 0xa
-		}
-	}
 	return len(dAtA) - i, nil
 }
 
-func (m *Info_Annotations) MarshalVT() (dAtA []byte, err error) {
+func (m *Info_Pod) MarshalVT() (dAtA []byte, err error) {
 	if m == nil {
 		return nil, nil
 	}
@@ -9131,12 +9304,12 @@ func (m *Info_Annotations) MarshalVT() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Info_Annotations) MarshalToVT(dAtA []byte) (int, error) {
+func (m *Info_Pod) MarshalToVT(dAtA []byte) (int, error) {
 	size := m.SizeVT()
 	return m.MarshalToSizedBufferVT(dAtA[:size])
 }
 
-func (m *Info_Annotations) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
+func (m *Info_Pod) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
 	if m == nil {
 		return 0, nil
 	}
@@ -9148,29 +9321,68 @@ func (m *Info_Annotations) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
 		i -= len(m.unknownFields)
 		copy(dAtA[i:], m.unknownFields)
 	}
-	if len(m.Annotations) > 0 {
-		for k := range m.Annotations {
-			v := m.Annotations[k]
-			baseI := i
-			i -= len(v)
-			copy(dAtA[i:], v)
-			i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v)))
-			i--
-			dAtA[i] = 0x12
-			i -= len(k)
-			copy(dAtA[i:], k)
-			i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))
-			i--
-			dAtA[i] = 0xa
-			i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))
-			i--
-			dAtA[i] = 0xa
+	if m.Node != nil {
+		size, err := m.Node.MarshalToSizedBufferVT(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0x3a
+	}
+	if m.Memory != nil {
+		size, err := m.Memory.MarshalToSizedBufferVT(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0x32
+	}
+	if m.Cpu != nil {
+		size, err := m.Cpu.MarshalToSizedBufferVT(dAtA[:i])
+		if err != nil {
+			return 0, err
 		}
+		i -= size
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0x2a
+	}
+	if len(m.Ip) > 0 {
+		i -= len(m.Ip)
+		copy(dAtA[i:], m.Ip)
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Ip)))
+		i--
+		dAtA[i] = 0x22
+	}
+	if len(m.Namespace) > 0 {
+		i -= len(m.Namespace)
+		copy(dAtA[i:], m.Namespace)
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Namespace)))
+		i--
+		dAtA[i] = 0x1a
+	}
+	if len(m.Name) > 0 {
+		i -= len(m.Name)
+		copy(dAtA[i:], m.Name)
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.AppName) > 0 {
+		i -= len(m.AppName)
+		copy(dAtA[i:], m.AppName)
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.AppName)))
+		i--
+		dAtA[i] = 0xa
 	}
 	return len(dAtA) - i, nil
 }
 
-func (m *Info_CPU) MarshalVT() (dAtA []byte, err error) {
+func (m *Info_Node) MarshalVT() (dAtA []byte, err error) {
 	if m == nil {
 		return nil, nil
 	}
@@ -9183,12 +9395,12 @@ func (m *Info_CPU) MarshalVT() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Info_CPU) MarshalToVT(dAtA []byte) (int, error) {
+func (m *Info_Node) MarshalToVT(dAtA []byte) (int, error) {
 	size := m.SizeVT()
 	return m.MarshalToSizedBufferVT(dAtA[:size])
 }
 
-func (m *Info_CPU) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
+func (m *Info_Node) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
 	if m == nil {
 		return 0, nil
 	}
@@ -9200,28 +9412,61 @@ func (m *Info_CPU) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
 		i -= len(m.unknownFields)
 		copy(dAtA[i:], m.unknownFields)
 	}
-	if m.Usage != 0 {
-		i -= 8
-		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Usage))))
+	if m.Pods != nil {
+		size, err := m.Pods.MarshalToSizedBufferVT(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
 		i--
-		dAtA[i] = 0x19
+		dAtA[i] = 0x32
 	}
-	if m.Request != 0 {
-		i -= 8
-		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Request))))
+	if m.Memory != nil {
+		size, err := m.Memory.MarshalToSizedBufferVT(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
 		i--
-		dAtA[i] = 0x11
+		dAtA[i] = 0x2a
 	}
-	if m.Limit != 0 {
-		i -= 8
-		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Limit))))
+	if m.Cpu != nil {
+		size, err := m.Cpu.MarshalToSizedBufferVT(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
 		i--
-		dAtA[i] = 0x9
+		dAtA[i] = 0x22
+	}
+	if len(m.ExternalAddr) > 0 {
+		i -= len(m.ExternalAddr)
+		copy(dAtA[i:], m.ExternalAddr)
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ExternalAddr)))
+		i--
+		dAtA[i] = 0x1a
+	}
+	if len(m.InternalAddr) > 0 {
+		i -= len(m.InternalAddr)
+		copy(dAtA[i:], m.InternalAddr)
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.InternalAddr)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Name) > 0 {
+		i -= len(m.Name)
+		copy(dAtA[i:], m.Name)
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
+		i--
+		dAtA[i] = 0xa
 	}
 	return len(dAtA) - i, nil
 }
 
-func (m *Info_Memory) MarshalVT() (dAtA []byte, err error) {
+func (m *Info_Service) MarshalVT() (dAtA []byte, err error) {
 	if m == nil {
 		return nil, nil
 	}
@@ -9234,12 +9479,12 @@ func (m *Info_Memory) MarshalVT() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Info_Memory) MarshalToVT(dAtA []byte) (int, error) {
+func (m *Info_Service) MarshalToVT(dAtA []byte) (int, error) {
 	size := m.SizeVT()
 	return m.MarshalToSizedBufferVT(dAtA[:size])
 }
 
-func (m *Info_Memory) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
+func (m *Info_Service) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
 	if m == nil {
 		return 0, nil
 	}
@@ -9251,28 +9496,65 @@ func (m *Info_Memory) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
 		i -= len(m.unknownFields)
 		copy(dAtA[i:], m.unknownFields)
 	}
-	if m.Usage != 0 {
-		i -= 8
-		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Usage))))
+	if m.Annotations != nil {
+		size, err := m.Annotations.MarshalToSizedBufferVT(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
 		i--
-		dAtA[i] = 0x19
+		dAtA[i] = 0x32
 	}
-	if m.Request != 0 {
-		i -= 8
-		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Request))))
+	if m.Labels != nil {
+		size, err := m.Labels.MarshalToSizedBufferVT(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
 		i--
-		dAtA[i] = 0x11
+		dAtA[i] = 0x2a
 	}
-	if m.Limit != 0 {
-		i -= 8
-		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Limit))))
+	if len(m.Ports) > 0 {
+		for iNdEx := len(m.Ports) - 1; iNdEx >= 0; iNdEx-- {
+			size, err := m.Ports[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
+			i--
+			dAtA[i] = 0x22
+		}
+	}
+	if len(m.ClusterIps) > 0 {
+		for iNdEx := len(m.ClusterIps) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.ClusterIps[iNdEx])
+			copy(dAtA[i:], m.ClusterIps[iNdEx])
+			i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ClusterIps[iNdEx])))
+			i--
+			dAtA[i] = 0x1a
+		}
+	}
+	if len(m.ClusterIp) > 0 {
+		i -= len(m.ClusterIp)
+		copy(dAtA[i:], m.ClusterIp)
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ClusterIp)))
 		i--
-		dAtA[i] = 0x9
+		dAtA[i] = 0x12
+	}
+	if len(m.Name) > 0 {
+		i -= len(m.Name)
+		copy(dAtA[i:], m.Name)
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
+		i--
+		dAtA[i] = 0xa
 	}
 	return len(dAtA) - i, nil
 }
 
-func (m *Info_Pods) MarshalVT() (dAtA []byte, err error) {
+func (m *Info_ServicePort) MarshalVT() (dAtA []byte, err error) {
 	if m == nil {
 		return nil, nil
 	}
@@ -9285,12 +9567,12 @@ func (m *Info_Pods) MarshalVT() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Info_Pods) MarshalToVT(dAtA []byte) (int, error) {
+func (m *Info_ServicePort) MarshalToVT(dAtA []byte) (int, error) {
 	size := m.SizeVT()
 	return m.MarshalToSizedBufferVT(dAtA[:size])
 }
 
-func (m *Info_Pods) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
+func (m *Info_ServicePort) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
 	if m == nil {
 		return 0, nil
 	}
@@ -9302,22 +9584,22 @@ func (m *Info_Pods) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
 		i -= len(m.unknownFields)
 		copy(dAtA[i:], m.unknownFields)
 	}
-	if len(m.Pods) > 0 {
-		for iNdEx := len(m.Pods) - 1; iNdEx >= 0; iNdEx-- {
-			size, err := m.Pods[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
-			i--
-			dAtA[i] = 0xa
-		}
+	if m.Port != 0 {
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Port))
+		i--
+		dAtA[i] = 0x10
+	}
+	if len(m.Name) > 0 {
+		i -= len(m.Name)
+		copy(dAtA[i:], m.Name)
+		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
+		i--
+		dAtA[i] = 0xa
 	}
 	return len(dAtA) - i, nil
 }
 
-func (m *Info_Nodes) MarshalVT() (dAtA []byte, err error) {
+func (m *Info_Labels) MarshalVT() (dAtA []byte, err error) {
 	if m == nil {
 		return nil, nil
 	}
@@ -9330,12 +9612,12 @@ func (m *Info_Nodes) MarshalVT() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Info_Nodes) MarshalToVT(dAtA []byte) (int, error) {
+func (m *Info_Labels) MarshalToVT(dAtA []byte) (int, error) {
 	size := m.SizeVT()
 	return m.MarshalToSizedBufferVT(dAtA[:size])
 }
 
-func (m *Info_Nodes) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
+func (m *Info_Labels) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
 	if m == nil {
 		return 0, nil
 	}
@@ -9347,18 +9629,269 @@ func (m *Info_Nodes) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
 		i -= len(m.unknownFields)
 		copy(dAtA[i:], m.unknownFields)
 	}
-	if len(m.Nodes) > 0 {
-		for iNdEx := len(m.Nodes) - 1; iNdEx >= 0; iNdEx-- {
-			size, err := m.Nodes[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
+	if len(m.Labels) > 0 {
+		for k := range m.Labels {
+			v := m.Labels[k]
+			baseI := i
+			i -= len(v)
+			copy(dAtA[i:], v)
+			i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v)))
+			i--
+			dAtA[i] = 0x12
+			i -= len(k)
+			copy(dAtA[i:], k)
+			i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))
 			i--
 			dAtA[i] = 0xa
-		}
-	}
+			i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *Info_Annotations) MarshalVT() (dAtA []byte, err error) {
+	if m == nil {
+		return nil, nil
+	}
+	size := m.SizeVT()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Info_Annotations) MarshalToVT(dAtA []byte) (int, error) {
+	size := m.SizeVT()
+	return m.MarshalToSizedBufferVT(dAtA[:size])
+}
+
+func (m *Info_Annotations) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
+	if m == nil {
+		return 0, nil
+	}
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.unknownFields != nil {
+		i -= len(m.unknownFields)
+		copy(dAtA[i:], m.unknownFields)
+	}
+	if len(m.Annotations) > 0 {
+		for k := range m.Annotations {
+			v := m.Annotations[k]
+			baseI := i
+			i -= len(v)
+			copy(dAtA[i:], v)
+			i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v)))
+			i--
+			dAtA[i] = 0x12
+			i -= len(k)
+			copy(dAtA[i:], k)
+			i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))
+			i--
+			dAtA[i] = 0xa
+			i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *Info_CPU) MarshalVT() (dAtA []byte, err error) {
+	if m == nil {
+		return nil, nil
+	}
+	size := m.SizeVT()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Info_CPU) MarshalToVT(dAtA []byte) (int, error) {
+	size := m.SizeVT()
+	return m.MarshalToSizedBufferVT(dAtA[:size])
+}
+
+func (m *Info_CPU) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
+	if m == nil {
+		return 0, nil
+	}
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.unknownFields != nil {
+		i -= len(m.unknownFields)
+		copy(dAtA[i:], m.unknownFields)
+	}
+	if m.Usage != 0 {
+		i -= 8
+		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Usage))))
+		i--
+		dAtA[i] = 0x19
+	}
+	if m.Request != 0 {
+		i -= 8
+		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Request))))
+		i--
+		dAtA[i] = 0x11
+	}
+	if m.Limit != 0 {
+		i -= 8
+		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Limit))))
+		i--
+		dAtA[i] = 0x9
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *Info_Memory) MarshalVT() (dAtA []byte, err error) {
+	if m == nil {
+		return nil, nil
+	}
+	size := m.SizeVT()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Info_Memory) MarshalToVT(dAtA []byte) (int, error) {
+	size := m.SizeVT()
+	return m.MarshalToSizedBufferVT(dAtA[:size])
+}
+
+func (m *Info_Memory) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
+	if m == nil {
+		return 0, nil
+	}
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.unknownFields != nil {
+		i -= len(m.unknownFields)
+		copy(dAtA[i:], m.unknownFields)
+	}
+	if m.Usage != 0 {
+		i -= 8
+		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Usage))))
+		i--
+		dAtA[i] = 0x19
+	}
+	if m.Request != 0 {
+		i -= 8
+		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Request))))
+		i--
+		dAtA[i] = 0x11
+	}
+	if m.Limit != 0 {
+		i -= 8
+		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Limit))))
+		i--
+		dAtA[i] = 0x9
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *Info_Pods) MarshalVT() (dAtA []byte, err error) {
+	if m == nil {
+		return nil, nil
+	}
+	size := m.SizeVT()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Info_Pods) MarshalToVT(dAtA []byte) (int, error) {
+	size := m.SizeVT()
+	return m.MarshalToSizedBufferVT(dAtA[:size])
+}
+
+func (m *Info_Pods) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
+	if m == nil {
+		return 0, nil
+	}
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.unknownFields != nil {
+		i -= len(m.unknownFields)
+		copy(dAtA[i:], m.unknownFields)
+	}
+	if len(m.Pods) > 0 {
+		for iNdEx := len(m.Pods) - 1; iNdEx >= 0; iNdEx-- {
+			size, err := m.Pods[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *Info_Nodes) MarshalVT() (dAtA []byte, err error) {
+	if m == nil {
+		return nil, nil
+	}
+	size := m.SizeVT()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Info_Nodes) MarshalToVT(dAtA []byte) (int, error) {
+	size := m.SizeVT()
+	return m.MarshalToSizedBufferVT(dAtA[:size])
+}
+
+func (m *Info_Nodes) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
+	if m == nil {
+		return 0, nil
+	}
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.unknownFields != nil {
+		i -= len(m.unknownFields)
+		copy(dAtA[i:], m.unknownFields)
+	}
+	if len(m.Nodes) > 0 {
+		for iNdEx := len(m.Nodes) - 1; iNdEx >= 0; iNdEx-- {
+			size, err := m.Nodes[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
+			i--
+			dAtA[i] = 0xa
+		}
+	}
 	return len(dAtA) - i, nil
 }
 
@@ -11099,18 +11632,155 @@ func (m *Info_Index_StatisticsDetail) SizeVT() (n int) {
 	return n
 }
 
-func (m *Info_Index) SizeVT() (n int) {
+func (m *Info_Index_Property) SizeVT() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	n += len(m.unknownFields)
-	return n
-}
-
-func (m *Info_Pod) SizeVT() (n int) {
-	if m == nil {
+	if m.Dimension != 0 {
+		n += 1 + protohelpers.SizeOfVarint(uint64(m.Dimension))
+	}
+	if m.ThreadPoolSize != 0 {
+		n += 1 + protohelpers.SizeOfVarint(uint64(m.ThreadPoolSize))
+	}
+	if m.ObjectType != 0 {
+		n += 1 + protohelpers.SizeOfVarint(uint64(m.ObjectType))
+	}
+	if m.DistanceType != 0 {
+		n += 1 + protohelpers.SizeOfVarint(uint64(m.DistanceType))
+	}
+	if m.IndexType != 0 {
+		n += 1 + protohelpers.SizeOfVarint(uint64(m.IndexType))
+	}
+	if m.DatabaseType != 0 {
+		n += 1 + protohelpers.SizeOfVarint(uint64(m.DatabaseType))
+	}
+	if m.ObjectAlignment != 0 {
+		n += 1 + protohelpers.SizeOfVarint(uint64(m.ObjectAlignment))
+	}
+	if m.PathAdjustmentInterval != 0 {
+		n += 1 + protohelpers.SizeOfVarint(uint64(m.PathAdjustmentInterval))
+	}
+	if m.GraphSharedMemorySize != 0 {
+		n += 1 + protohelpers.SizeOfVarint(uint64(m.GraphSharedMemorySize))
+	}
+	if m.TreeSharedMemorySize != 0 {
+		n += 1 + protohelpers.SizeOfVarint(uint64(m.TreeSharedMemorySize))
+	}
+	if m.ObjectSharedMemorySize != 0 {
+		n += 1 + protohelpers.SizeOfVarint(uint64(m.ObjectSharedMemorySize))
+	}
+	if m.PrefetchOffset != 0 {
+		n += 1 + protohelpers.SizeOfVarint(uint64(m.PrefetchOffset))
+	}
+	if m.PrefetchSize != 0 {
+		n += 1 + protohelpers.SizeOfVarint(uint64(m.PrefetchSize))
+	}
+	l = len(m.AccuracyTable)
+	if l > 0 {
+		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
+	}
+	l = len(m.SearchType)
+	if l > 0 {
+		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
+	}
+	if m.MaxMagnitude != 0 {
+		n += 6
+	}
+	if m.NOfNeighborsForInsertionOrder != 0 {
+		n += 2 + protohelpers.SizeOfVarint(uint64(m.NOfNeighborsForInsertionOrder))
+	}
+	if m.EpsilonForInsertionOrder != 0 {
+		n += 6
+	}
+	if m.RefinementObjectType != 0 {
+		n += 2 + protohelpers.SizeOfVarint(uint64(m.RefinementObjectType))
+	}
+	if m.TruncationThreshold != 0 {
+		n += 2 + protohelpers.SizeOfVarint(uint64(m.TruncationThreshold))
+	}
+	if m.EdgeSizeForCreation != 0 {
+		n += 2 + protohelpers.SizeOfVarint(uint64(m.EdgeSizeForCreation))
+	}
+	if m.EdgeSizeForSearch != 0 {
+		n += 2 + protohelpers.SizeOfVarint(uint64(m.EdgeSizeForSearch))
+	}
+	if m.EdgeSizeLimitForCreation != 0 {
+		n += 2 + protohelpers.SizeOfVarint(uint64(m.EdgeSizeLimitForCreation))
+	}
+	if m.InsertionRadiusCoefficient != 0 {
+		n += 10
+	}
+	if m.SeedSize != 0 {
+		n += 2 + protohelpers.SizeOfVarint(uint64(m.SeedSize))
+	}
+	if m.SeedType != 0 {
+		n += 2 + protohelpers.SizeOfVarint(uint64(m.SeedType))
+	}
+	if m.TruncationThreadPoolSize != 0 {
+		n += 2 + protohelpers.SizeOfVarint(uint64(m.TruncationThreadPoolSize))
+	}
+	if m.BatchSizeForCreation != 0 {
+		n += 2 + protohelpers.SizeOfVarint(uint64(m.BatchSizeForCreation))
+	}
+	if m.GraphType != 0 {
+		n += 2 + protohelpers.SizeOfVarint(uint64(m.GraphType))
+	}
+	if m.DynamicEdgeSizeBase != 0 {
+		n += 2 + protohelpers.SizeOfVarint(uint64(m.DynamicEdgeSizeBase))
+	}
+	if m.DynamicEdgeSizeRate != 0 {
+		n += 2 + protohelpers.SizeOfVarint(uint64(m.DynamicEdgeSizeRate))
+	}
+	if m.BuildTimeLimit != 0 {
+		n += 6
+	}
+	if m.OutgoingEdge != 0 {
+		n += 2 + protohelpers.SizeOfVarint(uint64(m.OutgoingEdge))
+	}
+	if m.IncomingEdge != 0 {
+		n += 2 + protohelpers.SizeOfVarint(uint64(m.IncomingEdge))
+	}
+	n += len(m.unknownFields)
+	return n
+}
+
+func (m *Info_Index_PropertyDetail) SizeVT() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.Details) > 0 {
+		for k, v := range m.Details {
+			_ = k
+			_ = v
+			l = 0
+			if v != nil {
+				l = v.SizeVT()
+			}
+			l += 1 + protohelpers.SizeOfVarint(uint64(l))
+			mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l
+			n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize))
+		}
+	}
+	n += len(m.unknownFields)
+	return n
+}
+
+func (m *Info_Index) SizeVT() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	n += len(m.unknownFields)
+	return n
+}
+
+func (m *Info_Pod) SizeVT() (n int) {
+	if m == nil {
 		return 0
 	}
 	var l int
@@ -18581,29 +19251,936 @@ func (m *Info_Index_UUID_Committed) UnmarshalVT(dAtA []byte) error {
 				if shift >= 64 {
 					return protohelpers.ErrIntOverflow
 				}
-				if iNdEx >= l {
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return protohelpers.ErrInvalidLength
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return protohelpers.ErrInvalidLength
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Uuid = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return protohelpers.ErrInvalidLength
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+
+func (m *Info_Index_UUID_Uncommitted) UnmarshalVT(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return protohelpers.ErrIntOverflow
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Info_Index_UUID_Uncommitted: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Info_Index_UUID_Uncommitted: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Uuid", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return protohelpers.ErrInvalidLength
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return protohelpers.ErrInvalidLength
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Uuid = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return protohelpers.ErrInvalidLength
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+
+func (m *Info_Index_UUID) UnmarshalVT(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return protohelpers.ErrIntOverflow
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Info_Index_UUID: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Info_Index_UUID: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return protohelpers.ErrInvalidLength
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+
+func (m *Info_Index_Statistics) UnmarshalVT(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return protohelpers.ErrIntOverflow
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Info_Index_Statistics: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Info_Index_Statistics: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Valid", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Valid = bool(v != 0)
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MedianIndegree", wireType)
+			}
+			m.MedianIndegree = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MedianIndegree |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MedianOutdegree", wireType)
+			}
+			m.MedianOutdegree = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MedianOutdegree |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MaxNumberOfIndegree", wireType)
+			}
+			m.MaxNumberOfIndegree = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MaxNumberOfIndegree |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 5:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MaxNumberOfOutdegree", wireType)
+			}
+			m.MaxNumberOfOutdegree = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MaxNumberOfOutdegree |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 6:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MinNumberOfIndegree", wireType)
+			}
+			m.MinNumberOfIndegree = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MinNumberOfIndegree |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 7:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MinNumberOfOutdegree", wireType)
+			}
+			m.MinNumberOfOutdegree = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MinNumberOfOutdegree |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 8:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ModeIndegree", wireType)
+			}
+			m.ModeIndegree = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ModeIndegree |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 9:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ModeOutdegree", wireType)
+			}
+			m.ModeOutdegree = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ModeOutdegree |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 10:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field NodesSkippedFor10Edges", wireType)
+			}
+			m.NodesSkippedFor10Edges = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.NodesSkippedFor10Edges |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 11:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field NodesSkippedForIndegreeDistance", wireType)
+			}
+			m.NodesSkippedForIndegreeDistance = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.NodesSkippedForIndegreeDistance |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 12:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field NumberOfEdges", wireType)
+			}
+			m.NumberOfEdges = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.NumberOfEdges |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 13:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field NumberOfIndexedObjects", wireType)
+			}
+			m.NumberOfIndexedObjects = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.NumberOfIndexedObjects |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 14:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field NumberOfNodes", wireType)
+			}
+			m.NumberOfNodes = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.NumberOfNodes |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 15:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field NumberOfNodesWithoutEdges", wireType)
+			}
+			m.NumberOfNodesWithoutEdges = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.NumberOfNodesWithoutEdges |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 16:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field NumberOfNodesWithoutIndegree", wireType)
+			}
+			m.NumberOfNodesWithoutIndegree = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.NumberOfNodesWithoutIndegree |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 17:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field NumberOfObjects", wireType)
+			}
+			m.NumberOfObjects = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.NumberOfObjects |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 18:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field NumberOfRemovedObjects", wireType)
+			}
+			m.NumberOfRemovedObjects = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.NumberOfRemovedObjects |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 19:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SizeOfObjectRepository", wireType)
+			}
+			m.SizeOfObjectRepository = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.SizeOfObjectRepository |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 20:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SizeOfRefinementObjectRepository", wireType)
+			}
+			m.SizeOfRefinementObjectRepository = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.SizeOfRefinementObjectRepository |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 21:
+			if wireType != 1 {
+				return fmt.Errorf("proto: wrong wireType = %d for field VarianceOfIndegree", wireType)
+			}
+			var v uint64
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
+			m.VarianceOfIndegree = float64(math.Float64frombits(v))
+		case 22:
+			if wireType != 1 {
+				return fmt.Errorf("proto: wrong wireType = %d for field VarianceOfOutdegree", wireType)
+			}
+			var v uint64
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
+			m.VarianceOfOutdegree = float64(math.Float64frombits(v))
+		case 23:
+			if wireType != 1 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MeanEdgeLength", wireType)
+			}
+			var v uint64
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
+			m.MeanEdgeLength = float64(math.Float64frombits(v))
+		case 24:
+			if wireType != 1 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MeanEdgeLengthFor10Edges", wireType)
+			}
+			var v uint64
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
+			m.MeanEdgeLengthFor10Edges = float64(math.Float64frombits(v))
+		case 25:
+			if wireType != 1 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MeanIndegreeDistanceFor10Edges", wireType)
+			}
+			var v uint64
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
+			m.MeanIndegreeDistanceFor10Edges = float64(math.Float64frombits(v))
+		case 26:
+			if wireType != 1 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MeanNumberOfEdgesPerNode", wireType)
+			}
+			var v uint64
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
+			m.MeanNumberOfEdgesPerNode = float64(math.Float64frombits(v))
+		case 27:
+			if wireType != 1 {
+				return fmt.Errorf("proto: wrong wireType = %d for field C1Indegree", wireType)
+			}
+			var v uint64
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
+			m.C1Indegree = float64(math.Float64frombits(v))
+		case 28:
+			if wireType != 1 {
+				return fmt.Errorf("proto: wrong wireType = %d for field C5Indegree", wireType)
+			}
+			var v uint64
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
+			m.C5Indegree = float64(math.Float64frombits(v))
+		case 29:
+			if wireType != 1 {
+				return fmt.Errorf("proto: wrong wireType = %d for field C95Outdegree", wireType)
+			}
+			var v uint64
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
+			m.C95Outdegree = float64(math.Float64frombits(v))
+		case 30:
+			if wireType != 1 {
+				return fmt.Errorf("proto: wrong wireType = %d for field C99Outdegree", wireType)
+			}
+			var v uint64
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
+			m.C99Outdegree = float64(math.Float64frombits(v))
+		case 31:
+			if wireType == 0 {
+				var v int64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protohelpers.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					v |= int64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				m.IndegreeCount = append(m.IndegreeCount, v)
+			} else if wireType == 2 {
+				var packedLen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protohelpers.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					packedLen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if packedLen < 0 {
+					return protohelpers.ErrInvalidLength
+				}
+				postIndex := iNdEx + packedLen
+				if postIndex < 0 {
+					return protohelpers.ErrInvalidLength
+				}
+				if postIndex > l {
+					return io.ErrUnexpectedEOF
+				}
+				var elementCount int
+				var count int
+				for _, integer := range dAtA[iNdEx:postIndex] {
+					if integer < 128 {
+						count++
+					}
+				}
+				elementCount = count
+				if elementCount != 0 && len(m.IndegreeCount) == 0 {
+					m.IndegreeCount = make([]int64, 0, elementCount)
+				}
+				for iNdEx < postIndex {
+					var v int64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return protohelpers.ErrIntOverflow
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						v |= int64(b&0x7F) << shift
+						if b < 0x80 {
+							break
+						}
+					}
+					m.IndegreeCount = append(m.IndegreeCount, v)
+				}
+			} else {
+				return fmt.Errorf("proto: wrong wireType = %d for field IndegreeCount", wireType)
+			}
+		case 32:
+			if wireType == 0 {
+				var v uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protohelpers.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					v |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				m.OutdegreeHistogram = append(m.OutdegreeHistogram, v)
+			} else if wireType == 2 {
+				var packedLen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protohelpers.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					packedLen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if packedLen < 0 {
+					return protohelpers.ErrInvalidLength
+				}
+				postIndex := iNdEx + packedLen
+				if postIndex < 0 {
+					return protohelpers.ErrInvalidLength
+				}
+				if postIndex > l {
+					return io.ErrUnexpectedEOF
+				}
+				var elementCount int
+				var count int
+				for _, integer := range dAtA[iNdEx:postIndex] {
+					if integer < 128 {
+						count++
+					}
+				}
+				elementCount = count
+				if elementCount != 0 && len(m.OutdegreeHistogram) == 0 {
+					m.OutdegreeHistogram = make([]uint64, 0, elementCount)
+				}
+				for iNdEx < postIndex {
+					var v uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return protohelpers.ErrIntOverflow
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						v |= uint64(b&0x7F) << shift
+						if b < 0x80 {
+							break
+						}
+					}
+					m.OutdegreeHistogram = append(m.OutdegreeHistogram, v)
+				}
+			} else {
+				return fmt.Errorf("proto: wrong wireType = %d for field OutdegreeHistogram", wireType)
+			}
+		case 33:
+			if wireType == 0 {
+				var v uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protohelpers.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					v |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				m.IndegreeHistogram = append(m.IndegreeHistogram, v)
+			} else if wireType == 2 {
+				var packedLen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protohelpers.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					packedLen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if packedLen < 0 {
+					return protohelpers.ErrInvalidLength
+				}
+				postIndex := iNdEx + packedLen
+				if postIndex < 0 {
+					return protohelpers.ErrInvalidLength
+				}
+				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
+				var elementCount int
+				var count int
+				for _, integer := range dAtA[iNdEx:postIndex] {
+					if integer < 128 {
+						count++
+					}
 				}
+				elementCount = count
+				if elementCount != 0 && len(m.IndegreeHistogram) == 0 {
+					m.IndegreeHistogram = make([]uint64, 0, elementCount)
+				}
+				for iNdEx < postIndex {
+					var v uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return protohelpers.ErrIntOverflow
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						v |= uint64(b&0x7F) << shift
+						if b < 0x80 {
+							break
+						}
+					}
+					m.IndegreeHistogram = append(m.IndegreeHistogram, v)
+				}
+			} else {
+				return fmt.Errorf("proto: wrong wireType = %d for field IndegreeHistogram", wireType)
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return protohelpers.ErrInvalidLength
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return protohelpers.ErrInvalidLength
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Uuid = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
@@ -18627,7 +20204,7 @@ func (m *Info_Index_UUID_Committed) UnmarshalVT(dAtA []byte) error {
 	return nil
 }
 
-func (m *Info_Index_UUID_Uncommitted) UnmarshalVT(dAtA []byte) error {
+func (m *Info_Index_StatisticsDetail) UnmarshalVT(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -18650,17 +20227,17 @@ func (m *Info_Index_UUID_Uncommitted) UnmarshalVT(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: Info_Index_UUID_Uncommitted: wiretype end group for non-group")
+			return fmt.Errorf("proto: Info_Index_StatisticsDetail: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Info_Index_UUID_Uncommitted: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: Info_Index_StatisticsDetail: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Uuid", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Details", wireType)
 			}
-			var stringLen uint64
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return protohelpers.ErrIntOverflow
@@ -18670,76 +20247,121 @@ func (m *Info_Index_UUID_Uncommitted) UnmarshalVT(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if msglen < 0 {
 				return protohelpers.ErrInvalidLength
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return protohelpers.ErrInvalidLength
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Uuid = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return protohelpers.ErrInvalidLength
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-
-func (m *Info_Index_UUID) UnmarshalVT(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return protohelpers.ErrIntOverflow
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
+			if m.Details == nil {
+				m.Details = make(map[string]*Info_Index_Statistics)
 			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
+			var mapkey string
+			var mapvalue *Info_Index_Statistics
+			for iNdEx < postIndex {
+				entryPreIndex := iNdEx
+				var wire uint64
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return protohelpers.ErrIntOverflow
+					}
+					if iNdEx >= l {
+						return io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					wire |= uint64(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				fieldNum := int32(wire >> 3)
+				if fieldNum == 1 {
+					var stringLenmapkey uint64
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return protohelpers.ErrIntOverflow
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						stringLenmapkey |= uint64(b&0x7F) << shift
+						if b < 0x80 {
+							break
+						}
+					}
+					intStringLenmapkey := int(stringLenmapkey)
+					if intStringLenmapkey < 0 {
+						return protohelpers.ErrInvalidLength
+					}
+					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey < 0 {
+						return protohelpers.ErrInvalidLength
+					}
+					if postStringIndexmapkey > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
+					iNdEx = postStringIndexmapkey
+				} else if fieldNum == 2 {
+					var mapmsglen int
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return protohelpers.ErrIntOverflow
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						mapmsglen |= int(b&0x7F) << shift
+						if b < 0x80 {
+							break
+						}
+					}
+					if mapmsglen < 0 {
+						return protohelpers.ErrInvalidLength
+					}
+					postmsgIndex := iNdEx + mapmsglen
+					if postmsgIndex < 0 {
+						return protohelpers.ErrInvalidLength
+					}
+					if postmsgIndex > l {
+						return io.ErrUnexpectedEOF
+					}
+					mapvalue = &Info_Index_Statistics{}
+					if err := mapvalue.UnmarshalVT(dAtA[iNdEx:postmsgIndex]); err != nil {
+						return err
+					}
+					iNdEx = postmsgIndex
+				} else {
+					iNdEx = entryPreIndex
+					skippy, err := protohelpers.Skip(dAtA[iNdEx:])
+					if err != nil {
+						return err
+					}
+					if (skippy < 0) || (iNdEx+skippy) < 0 {
+						return protohelpers.ErrInvalidLength
+					}
+					if (iNdEx + skippy) > postIndex {
+						return io.ErrUnexpectedEOF
+					}
+					iNdEx += skippy
+				}
 			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: Info_Index_UUID: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Info_Index_UUID: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
+			m.Details[mapkey] = mapvalue
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
@@ -18763,7 +20385,7 @@ func (m *Info_Index_UUID) UnmarshalVT(dAtA []byte) error {
 	return nil
 }
 
-func (m *Info_Index_Statistics) UnmarshalVT(dAtA []byte) error {
+func (m *Info_Index_Property) UnmarshalVT(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -18786,17 +20408,17 @@ func (m *Info_Index_Statistics) UnmarshalVT(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: Info_Index_Statistics: wiretype end group for non-group")
+			return fmt.Errorf("proto: Info_Index_Property: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Info_Index_Statistics: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: Info_Index_Property: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Valid", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Dimension", wireType)
 			}
-			var v int
+			m.Dimension = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return protohelpers.ErrIntOverflow
@@ -18806,17 +20428,16 @@ func (m *Info_Index_Statistics) UnmarshalVT(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				m.Dimension |= int32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			m.Valid = bool(v != 0)
 		case 2:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MedianIndegree", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ThreadPoolSize", wireType)
 			}
-			m.MedianIndegree = 0
+			m.ThreadPoolSize = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return protohelpers.ErrIntOverflow
@@ -18826,16 +20447,16 @@ func (m *Info_Index_Statistics) UnmarshalVT(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.MedianIndegree |= int32(b&0x7F) << shift
+				m.ThreadPoolSize |= int32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
 		case 3:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MedianOutdegree", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ObjectType", wireType)
 			}
-			m.MedianOutdegree = 0
+			m.ObjectType = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return protohelpers.ErrIntOverflow
@@ -18845,16 +20466,16 @@ func (m *Info_Index_Statistics) UnmarshalVT(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.MedianOutdegree |= int32(b&0x7F) << shift
+				m.ObjectType |= int32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
 		case 4:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MaxNumberOfIndegree", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field DistanceType", wireType)
 			}
-			m.MaxNumberOfIndegree = 0
+			m.DistanceType = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return protohelpers.ErrIntOverflow
@@ -18864,16 +20485,16 @@ func (m *Info_Index_Statistics) UnmarshalVT(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.MaxNumberOfIndegree |= uint64(b&0x7F) << shift
+				m.DistanceType |= int32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
 		case 5:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MaxNumberOfOutdegree", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field IndexType", wireType)
 			}
-			m.MaxNumberOfOutdegree = 0
+			m.IndexType = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return protohelpers.ErrIntOverflow
@@ -18883,16 +20504,16 @@ func (m *Info_Index_Statistics) UnmarshalVT(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.MaxNumberOfOutdegree |= uint64(b&0x7F) << shift
+				m.IndexType |= int32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
 		case 6:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MinNumberOfIndegree", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field DatabaseType", wireType)
 			}
-			m.MinNumberOfIndegree = 0
+			m.DatabaseType = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return protohelpers.ErrIntOverflow
@@ -18902,16 +20523,16 @@ func (m *Info_Index_Statistics) UnmarshalVT(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.MinNumberOfIndegree |= uint64(b&0x7F) << shift
+				m.DatabaseType |= int32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
 		case 7:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MinNumberOfOutdegree", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ObjectAlignment", wireType)
 			}
-			m.MinNumberOfOutdegree = 0
+			m.ObjectAlignment = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return protohelpers.ErrIntOverflow
@@ -18921,16 +20542,16 @@ func (m *Info_Index_Statistics) UnmarshalVT(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.MinNumberOfOutdegree |= uint64(b&0x7F) << shift
+				m.ObjectAlignment |= int32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
 		case 8:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ModeIndegree", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field PathAdjustmentInterval", wireType)
 			}
-			m.ModeIndegree = 0
+			m.PathAdjustmentInterval = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return protohelpers.ErrIntOverflow
@@ -18940,16 +20561,16 @@ func (m *Info_Index_Statistics) UnmarshalVT(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.ModeIndegree |= uint64(b&0x7F) << shift
+				m.PathAdjustmentInterval |= int32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
 		case 9:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ModeOutdegree", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field GraphSharedMemorySize", wireType)
 			}
-			m.ModeOutdegree = 0
+			m.GraphSharedMemorySize = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return protohelpers.ErrIntOverflow
@@ -18959,16 +20580,16 @@ func (m *Info_Index_Statistics) UnmarshalVT(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.ModeOutdegree |= uint64(b&0x7F) << shift
+				m.GraphSharedMemorySize |= int32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
 		case 10:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field NodesSkippedFor10Edges", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field TreeSharedMemorySize", wireType)
 			}
-			m.NodesSkippedFor10Edges = 0
+			m.TreeSharedMemorySize = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return protohelpers.ErrIntOverflow
@@ -18978,16 +20599,16 @@ func (m *Info_Index_Statistics) UnmarshalVT(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.NodesSkippedFor10Edges |= uint64(b&0x7F) << shift
+				m.TreeSharedMemorySize |= int32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
 		case 11:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field NodesSkippedForIndegreeDistance", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ObjectSharedMemorySize", wireType)
 			}
-			m.NodesSkippedForIndegreeDistance = 0
+			m.ObjectSharedMemorySize = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return protohelpers.ErrIntOverflow
@@ -18997,16 +20618,16 @@ func (m *Info_Index_Statistics) UnmarshalVT(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.NodesSkippedForIndegreeDistance |= uint64(b&0x7F) << shift
+				m.ObjectSharedMemorySize |= int32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
 		case 12:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field NumberOfEdges", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field PrefetchOffset", wireType)
 			}
-			m.NumberOfEdges = 0
+			m.PrefetchOffset = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return protohelpers.ErrIntOverflow
@@ -19016,16 +20637,16 @@ func (m *Info_Index_Statistics) UnmarshalVT(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.NumberOfEdges |= uint64(b&0x7F) << shift
+				m.PrefetchOffset |= int32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
 		case 13:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field NumberOfIndexedObjects", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field PrefetchSize", wireType)
 			}
-			m.NumberOfIndexedObjects = 0
+			m.PrefetchSize = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return protohelpers.ErrIntOverflow
@@ -19035,16 +20656,16 @@ func (m *Info_Index_Statistics) UnmarshalVT(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.NumberOfIndexedObjects |= uint64(b&0x7F) << shift
+				m.PrefetchSize |= int32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
 		case 14:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field NumberOfNodes", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AccuracyTable", wireType)
 			}
-			m.NumberOfNodes = 0
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return protohelpers.ErrIntOverflow
@@ -19054,16 +20675,29 @@ func (m *Info_Index_Statistics) UnmarshalVT(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.NumberOfNodes |= uint64(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return protohelpers.ErrInvalidLength
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return protohelpers.ErrInvalidLength
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.AccuracyTable = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
 		case 15:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field NumberOfNodesWithoutEdges", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SearchType", wireType)
 			}
-			m.NumberOfNodesWithoutEdges = 0
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return protohelpers.ErrIntOverflow
@@ -19073,16 +20707,40 @@ func (m *Info_Index_Statistics) UnmarshalVT(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.NumberOfNodesWithoutEdges |= uint64(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return protohelpers.ErrInvalidLength
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return protohelpers.ErrInvalidLength
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.SearchType = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
 		case 16:
+			if wireType != 5 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MaxMagnitude", wireType)
+			}
+			var v uint32
+			if (iNdEx + 4) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
+			iNdEx += 4
+			m.MaxMagnitude = float32(math.Float32frombits(v))
+		case 17:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field NumberOfNodesWithoutIndegree", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field NOfNeighborsForInsertionOrder", wireType)
 			}
-			m.NumberOfNodesWithoutIndegree = 0
+			m.NOfNeighborsForInsertionOrder = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return protohelpers.ErrIntOverflow
@@ -19092,16 +20750,27 @@ func (m *Info_Index_Statistics) UnmarshalVT(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.NumberOfNodesWithoutIndegree |= uint64(b&0x7F) << shift
+				m.NOfNeighborsForInsertionOrder |= int32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		case 17:
+		case 18:
+			if wireType != 5 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EpsilonForInsertionOrder", wireType)
+			}
+			var v uint32
+			if (iNdEx + 4) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
+			iNdEx += 4
+			m.EpsilonForInsertionOrder = float32(math.Float32frombits(v))
+		case 19:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field NumberOfObjects", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field RefinementObjectType", wireType)
 			}
-			m.NumberOfObjects = 0
+			m.RefinementObjectType = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return protohelpers.ErrIntOverflow
@@ -19111,16 +20780,16 @@ func (m *Info_Index_Statistics) UnmarshalVT(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.NumberOfObjects |= uint64(b&0x7F) << shift
+				m.RefinementObjectType |= int32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		case 18:
+		case 20:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field NumberOfRemovedObjects", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field TruncationThreshold", wireType)
 			}
-			m.NumberOfRemovedObjects = 0
+			m.TruncationThreshold = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return protohelpers.ErrIntOverflow
@@ -19130,16 +20799,16 @@ func (m *Info_Index_Statistics) UnmarshalVT(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.NumberOfRemovedObjects |= uint64(b&0x7F) << shift
+				m.TruncationThreshold |= int32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		case 19:
+		case 21:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field SizeOfObjectRepository", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field EdgeSizeForCreation", wireType)
 			}
-			m.SizeOfObjectRepository = 0
+			m.EdgeSizeForCreation = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return protohelpers.ErrIntOverflow
@@ -19149,16 +20818,16 @@ func (m *Info_Index_Statistics) UnmarshalVT(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.SizeOfObjectRepository |= uint64(b&0x7F) << shift
+				m.EdgeSizeForCreation |= int32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		case 20:
+		case 22:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field SizeOfRefinementObjectRepository", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field EdgeSizeForSearch", wireType)
 			}
-			m.SizeOfRefinementObjectRepository = 0
+			m.EdgeSizeForSearch = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return protohelpers.ErrIntOverflow
@@ -19168,47 +20837,33 @@ func (m *Info_Index_Statistics) UnmarshalVT(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.SizeOfRefinementObjectRepository |= uint64(b&0x7F) << shift
+				m.EdgeSizeForSearch |= int32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		case 21:
-			if wireType != 1 {
-				return fmt.Errorf("proto: wrong wireType = %d for field VarianceOfIndegree", wireType)
-			}
-			var v uint64
-			if (iNdEx + 8) > l {
-				return io.ErrUnexpectedEOF
-			}
-			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
-			iNdEx += 8
-			m.VarianceOfIndegree = float64(math.Float64frombits(v))
-		case 22:
-			if wireType != 1 {
-				return fmt.Errorf("proto: wrong wireType = %d for field VarianceOfOutdegree", wireType)
-			}
-			var v uint64
-			if (iNdEx + 8) > l {
-				return io.ErrUnexpectedEOF
-			}
-			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
-			iNdEx += 8
-			m.VarianceOfOutdegree = float64(math.Float64frombits(v))
 		case 23:
-			if wireType != 1 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MeanEdgeLength", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EdgeSizeLimitForCreation", wireType)
 			}
-			var v uint64
-			if (iNdEx + 8) > l {
-				return io.ErrUnexpectedEOF
+			m.EdgeSizeLimitForCreation = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.EdgeSizeLimitForCreation |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
 			}
-			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
-			iNdEx += 8
-			m.MeanEdgeLength = float64(math.Float64frombits(v))
 		case 24:
 			if wireType != 1 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MeanEdgeLengthFor10Edges", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field InsertionRadiusCoefficient", wireType)
 			}
 			var v uint64
 			if (iNdEx + 8) > l {
@@ -19216,300 +20871,188 @@ func (m *Info_Index_Statistics) UnmarshalVT(dAtA []byte) error {
 			}
 			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
 			iNdEx += 8
-			m.MeanEdgeLengthFor10Edges = float64(math.Float64frombits(v))
+			m.InsertionRadiusCoefficient = float64(math.Float64frombits(v))
 		case 25:
-			if wireType != 1 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MeanIndegreeDistanceFor10Edges", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SeedSize", wireType)
 			}
-			var v uint64
-			if (iNdEx + 8) > l {
-				return io.ErrUnexpectedEOF
+			m.SeedSize = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.SeedSize |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
 			}
-			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
-			iNdEx += 8
-			m.MeanIndegreeDistanceFor10Edges = float64(math.Float64frombits(v))
 		case 26:
-			if wireType != 1 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MeanNumberOfEdgesPerNode", wireType)
-			}
-			var v uint64
-			if (iNdEx + 8) > l {
-				return io.ErrUnexpectedEOF
-			}
-			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
-			iNdEx += 8
-			m.MeanNumberOfEdgesPerNode = float64(math.Float64frombits(v))
-		case 27:
-			if wireType != 1 {
-				return fmt.Errorf("proto: wrong wireType = %d for field C1Indegree", wireType)
-			}
-			var v uint64
-			if (iNdEx + 8) > l {
-				return io.ErrUnexpectedEOF
-			}
-			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
-			iNdEx += 8
-			m.C1Indegree = float64(math.Float64frombits(v))
-		case 28:
-			if wireType != 1 {
-				return fmt.Errorf("proto: wrong wireType = %d for field C5Indegree", wireType)
-			}
-			var v uint64
-			if (iNdEx + 8) > l {
-				return io.ErrUnexpectedEOF
-			}
-			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
-			iNdEx += 8
-			m.C5Indegree = float64(math.Float64frombits(v))
-		case 29:
-			if wireType != 1 {
-				return fmt.Errorf("proto: wrong wireType = %d for field C95Outdegree", wireType)
-			}
-			var v uint64
-			if (iNdEx + 8) > l {
-				return io.ErrUnexpectedEOF
-			}
-			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
-			iNdEx += 8
-			m.C95Outdegree = float64(math.Float64frombits(v))
-		case 30:
-			if wireType != 1 {
-				return fmt.Errorf("proto: wrong wireType = %d for field C99Outdegree", wireType)
-			}
-			var v uint64
-			if (iNdEx + 8) > l {
-				return io.ErrUnexpectedEOF
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SeedType", wireType)
 			}
-			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
-			iNdEx += 8
-			m.C99Outdegree = float64(math.Float64frombits(v))
-		case 31:
-			if wireType == 0 {
-				var v int64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protohelpers.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					v |= int64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
+			m.SeedType = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
 				}
-				m.IndegreeCount = append(m.IndegreeCount, v)
-			} else if wireType == 2 {
-				var packedLen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protohelpers.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					packedLen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
 				}
-				if packedLen < 0 {
-					return protohelpers.ErrInvalidLength
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.SeedType |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
 				}
-				postIndex := iNdEx + packedLen
-				if postIndex < 0 {
-					return protohelpers.ErrInvalidLength
+			}
+		case 27:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field TruncationThreadPoolSize", wireType)
+			}
+			m.TruncationThreadPoolSize = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
 				}
-				if postIndex > l {
+				if iNdEx >= l {
 					return io.ErrUnexpectedEOF
 				}
-				var elementCount int
-				var count int
-				for _, integer := range dAtA[iNdEx:postIndex] {
-					if integer < 128 {
-						count++
-					}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.TruncationThreadPoolSize |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
 				}
-				elementCount = count
-				if elementCount != 0 && len(m.IndegreeCount) == 0 {
-					m.IndegreeCount = make([]int64, 0, elementCount)
+			}
+		case 28:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BatchSizeForCreation", wireType)
+			}
+			m.BatchSizeForCreation = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
 				}
-				for iNdEx < postIndex {
-					var v int64
-					for shift := uint(0); ; shift += 7 {
-						if shift >= 64 {
-							return protohelpers.ErrIntOverflow
-						}
-						if iNdEx >= l {
-							return io.ErrUnexpectedEOF
-						}
-						b := dAtA[iNdEx]
-						iNdEx++
-						v |= int64(b&0x7F) << shift
-						if b < 0x80 {
-							break
-						}
-					}
-					m.IndegreeCount = append(m.IndegreeCount, v)
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.BatchSizeForCreation |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
 				}
-			} else {
-				return fmt.Errorf("proto: wrong wireType = %d for field IndegreeCount", wireType)
 			}
-		case 32:
-			if wireType == 0 {
-				var v uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protohelpers.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					v |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
+		case 29:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field GraphType", wireType)
+			}
+			m.GraphType = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
 				}
-				m.OutdegreeHistogram = append(m.OutdegreeHistogram, v)
-			} else if wireType == 2 {
-				var packedLen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protohelpers.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					packedLen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
 				}
-				if packedLen < 0 {
-					return protohelpers.ErrInvalidLength
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.GraphType |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
 				}
-				postIndex := iNdEx + packedLen
-				if postIndex < 0 {
-					return protohelpers.ErrInvalidLength
+			}
+		case 30:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DynamicEdgeSizeBase", wireType)
+			}
+			m.DynamicEdgeSizeBase = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
 				}
-				if postIndex > l {
+				if iNdEx >= l {
 					return io.ErrUnexpectedEOF
 				}
-				var elementCount int
-				var count int
-				for _, integer := range dAtA[iNdEx:postIndex] {
-					if integer < 128 {
-						count++
-					}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.DynamicEdgeSizeBase |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
 				}
-				elementCount = count
-				if elementCount != 0 && len(m.OutdegreeHistogram) == 0 {
-					m.OutdegreeHistogram = make([]uint64, 0, elementCount)
+			}
+		case 31:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DynamicEdgeSizeRate", wireType)
+			}
+			m.DynamicEdgeSizeRate = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
 				}
-				for iNdEx < postIndex {
-					var v uint64
-					for shift := uint(0); ; shift += 7 {
-						if shift >= 64 {
-							return protohelpers.ErrIntOverflow
-						}
-						if iNdEx >= l {
-							return io.ErrUnexpectedEOF
-						}
-						b := dAtA[iNdEx]
-						iNdEx++
-						v |= uint64(b&0x7F) << shift
-						if b < 0x80 {
-							break
-						}
-					}
-					m.OutdegreeHistogram = append(m.OutdegreeHistogram, v)
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.DynamicEdgeSizeRate |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
 				}
-			} else {
-				return fmt.Errorf("proto: wrong wireType = %d for field OutdegreeHistogram", wireType)
 			}
+		case 32:
+			if wireType != 5 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BuildTimeLimit", wireType)
+			}
+			var v uint32
+			if (iNdEx + 4) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
+			iNdEx += 4
+			m.BuildTimeLimit = float32(math.Float32frombits(v))
 		case 33:
-			if wireType == 0 {
-				var v uint64
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protohelpers.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					v |= uint64(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field OutgoingEdge", wireType)
+			}
+			m.OutgoingEdge = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
 				}
-				m.IndegreeHistogram = append(m.IndegreeHistogram, v)
-			} else if wireType == 2 {
-				var packedLen int
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return protohelpers.ErrIntOverflow
-					}
-					if iNdEx >= l {
-						return io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					packedLen |= int(b&0x7F) << shift
-					if b < 0x80 {
-						break
-					}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
 				}
-				if packedLen < 0 {
-					return protohelpers.ErrInvalidLength
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.OutgoingEdge |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
 				}
-				postIndex := iNdEx + packedLen
-				if postIndex < 0 {
-					return protohelpers.ErrInvalidLength
+			}
+		case 34:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field IncomingEdge", wireType)
+			}
+			m.IncomingEdge = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
 				}
-				if postIndex > l {
+				if iNdEx >= l {
 					return io.ErrUnexpectedEOF
 				}
-				var elementCount int
-				var count int
-				for _, integer := range dAtA[iNdEx:postIndex] {
-					if integer < 128 {
-						count++
-					}
-				}
-				elementCount = count
-				if elementCount != 0 && len(m.IndegreeHistogram) == 0 {
-					m.IndegreeHistogram = make([]uint64, 0, elementCount)
-				}
-				for iNdEx < postIndex {
-					var v uint64
-					for shift := uint(0); ; shift += 7 {
-						if shift >= 64 {
-							return protohelpers.ErrIntOverflow
-						}
-						if iNdEx >= l {
-							return io.ErrUnexpectedEOF
-						}
-						b := dAtA[iNdEx]
-						iNdEx++
-						v |= uint64(b&0x7F) << shift
-						if b < 0x80 {
-							break
-						}
-					}
-					m.IndegreeHistogram = append(m.IndegreeHistogram, v)
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.IncomingEdge |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
 				}
-			} else {
-				return fmt.Errorf("proto: wrong wireType = %d for field IndegreeHistogram", wireType)
 			}
 		default:
 			iNdEx = preIndex
@@ -19534,7 +21077,7 @@ func (m *Info_Index_Statistics) UnmarshalVT(dAtA []byte) error {
 	return nil
 }
 
-func (m *Info_Index_StatisticsDetail) UnmarshalVT(dAtA []byte) error {
+func (m *Info_Index_PropertyDetail) UnmarshalVT(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -19557,10 +21100,10 @@ func (m *Info_Index_StatisticsDetail) UnmarshalVT(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: Info_Index_StatisticsDetail: wiretype end group for non-group")
+			return fmt.Errorf("proto: Info_Index_PropertyDetail: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Info_Index_StatisticsDetail: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: Info_Index_PropertyDetail: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -19593,10 +21136,10 @@ func (m *Info_Index_StatisticsDetail) UnmarshalVT(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.Details == nil {
-				m.Details = make(map[string]*Info_Index_Statistics)
+				m.Details = make(map[string]*Info_Index_Property)
 			}
 			var mapkey string
-			var mapvalue *Info_Index_Statistics
+			var mapvalue *Info_Index_Property
 			for iNdEx < postIndex {
 				entryPreIndex := iNdEx
 				var wire uint64
@@ -19670,7 +21213,7 @@ func (m *Info_Index_StatisticsDetail) UnmarshalVT(dAtA []byte) error {
 					if postmsgIndex > l {
 						return io.ErrUnexpectedEOF
 					}
-					mapvalue = &Info_Index_Statistics{}
+					mapvalue = &Info_Index_Property{}
 					if err := mapvalue.UnmarshalVT(dAtA[iNdEx:postmsgIndex]); err != nil {
 						return err
 					}
diff --git a/apis/grpc/v1/vald/index.pb.go b/apis/grpc/v1/vald/index.pb.go
index 46cef675f7c..44a723b75cf 100644
--- a/apis/grpc/v1/vald/index.pb.go
+++ b/apis/grpc/v1/vald/index.pb.go
@@ -46,7 +46,7 @@ var file_v1_vald_index_proto_rawDesc = []byte{
 	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74,
 	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x18, 0x76, 0x31,
 	0x2f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x8d, 0x03, 0x0a, 0x05, 0x49, 0x6e, 0x64, 0x65, 0x78,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0xdc, 0x04, 0x0a, 0x05, 0x49, 0x6e, 0x64, 0x65, 0x78,
 	0x12, 0x51, 0x0a, 0x09, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x11, 0x2e,
 	0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79,
 	0x1a, 0x1c, 0x2e, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e,
@@ -71,13 +71,26 @@ var file_v1_vald_index_proto_rawDesc = []byte{
 	0x64, 0x65, 0x78, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x44, 0x65,
 	0x74, 0x61, 0x69, 0x6c, 0x22, 0x20, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x12, 0x18, 0x2f, 0x69,
 	0x6e, 0x64, 0x65, 0x78, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x2f,
-	0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x42, 0x52, 0x0a, 0x1a, 0x6f, 0x72, 0x67, 0x2e, 0x76, 0x64,
-	0x61, 0x61, 0x73, 0x2e, 0x76, 0x61, 0x6c, 0x64, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e,
-	0x76, 0x61, 0x6c, 0x64, 0x42, 0x09, 0x56, 0x61, 0x6c, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x50,
-	0x01, 0x5a, 0x27, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x76, 0x64,
-	0x61, 0x61, 0x73, 0x2f, 0x76, 0x61, 0x6c, 0x64, 0x2f, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x67, 0x72,
-	0x70, 0x63, 0x2f, 0x76, 0x31, 0x2f, 0x76, 0x61, 0x6c, 0x64, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x33,
+	0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x12, 0x5c, 0x0a, 0x0d, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x50,
+	0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x12, 0x11, 0x2e, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61,
+	0x64, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x1f, 0x2e, 0x70, 0x61, 0x79,
+	0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x49, 0x6e, 0x64,
+	0x65, 0x78, 0x2e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x22, 0x17, 0x82, 0xd3, 0xe4,
+	0x93, 0x02, 0x11, 0x12, 0x0f, 0x2f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2f, 0x70, 0x72, 0x6f, 0x70,
+	0x65, 0x72, 0x74, 0x79, 0x12, 0x6f, 0x0a, 0x13, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x50, 0x72, 0x6f,
+	0x70, 0x65, 0x72, 0x74, 0x79, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x12, 0x11, 0x2e, 0x70, 0x61,
+	0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x25,
+	0x2e, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x66, 0x6f,
+	0x2e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x44,
+	0x65, 0x74, 0x61, 0x69, 0x6c, 0x22, 0x1e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x18, 0x12, 0x16, 0x2f,
+	0x69, 0x6e, 0x64, 0x65, 0x78, 0x2f, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x2f, 0x64,
+	0x65, 0x74, 0x61, 0x69, 0x6c, 0x42, 0x52, 0x0a, 0x1a, 0x6f, 0x72, 0x67, 0x2e, 0x76, 0x64, 0x61,
+	0x61, 0x73, 0x2e, 0x76, 0x61, 0x6c, 0x64, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x76,
+	0x61, 0x6c, 0x64, 0x42, 0x09, 0x56, 0x61, 0x6c, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x50, 0x01,
+	0x5a, 0x27, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x76, 0x64, 0x61,
+	0x61, 0x73, 0x2f, 0x76, 0x61, 0x6c, 0x64, 0x2f, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x67, 0x72, 0x70,
+	0x63, 0x2f, 0x76, 0x31, 0x2f, 0x76, 0x61, 0x6c, 0x64, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x33,
 }
 
 var file_v1_vald_index_proto_goTypes = []any{
@@ -86,6 +99,8 @@ var file_v1_vald_index_proto_goTypes = []any{
 	(*payload.Info_Index_Detail)(nil),           // 2: payload.v1.Info.Index.Detail
 	(*payload.Info_Index_Statistics)(nil),       // 3: payload.v1.Info.Index.Statistics
 	(*payload.Info_Index_StatisticsDetail)(nil), // 4: payload.v1.Info.Index.StatisticsDetail
+	(*payload.Info_Index_Property)(nil),         // 5: payload.v1.Info.Index.Property
+	(*payload.Info_Index_PropertyDetail)(nil),   // 6: payload.v1.Info.Index.PropertyDetail
 }
 
 var file_v1_vald_index_proto_depIdxs = []int32{
@@ -93,12 +108,16 @@ var file_v1_vald_index_proto_depIdxs = []int32{
 	0, // 1: vald.v1.Index.IndexDetail:input_type -> payload.v1.Empty
 	0, // 2: vald.v1.Index.IndexStatistics:input_type -> payload.v1.Empty
 	0, // 3: vald.v1.Index.IndexStatisticsDetail:input_type -> payload.v1.Empty
-	1, // 4: vald.v1.Index.IndexInfo:output_type -> payload.v1.Info.Index.Count
-	2, // 5: vald.v1.Index.IndexDetail:output_type -> payload.v1.Info.Index.Detail
-	3, // 6: vald.v1.Index.IndexStatistics:output_type -> payload.v1.Info.Index.Statistics
-	4, // 7: vald.v1.Index.IndexStatisticsDetail:output_type -> payload.v1.Info.Index.StatisticsDetail
-	4, // [4:8] is the sub-list for method output_type
-	0, // [0:4] is the sub-list for method input_type
+	0, // 4: vald.v1.Index.IndexProperty:input_type -> payload.v1.Empty
+	0, // 5: vald.v1.Index.IndexPropertyDetail:input_type -> payload.v1.Empty
+	1, // 6: vald.v1.Index.IndexInfo:output_type -> payload.v1.Info.Index.Count
+	2, // 7: vald.v1.Index.IndexDetail:output_type -> payload.v1.Info.Index.Detail
+	3, // 8: vald.v1.Index.IndexStatistics:output_type -> payload.v1.Info.Index.Statistics
+	4, // 9: vald.v1.Index.IndexStatisticsDetail:output_type -> payload.v1.Info.Index.StatisticsDetail
+	5, // 10: vald.v1.Index.IndexProperty:output_type -> payload.v1.Info.Index.Property
+	6, // 11: vald.v1.Index.IndexPropertyDetail:output_type -> payload.v1.Info.Index.PropertyDetail
+	6, // [6:12] is the sub-list for method output_type
+	0, // [0:6] is the sub-list for method input_type
 	0, // [0:0] is the sub-list for extension type_name
 	0, // [0:0] is the sub-list for extension extendee
 	0, // [0:0] is the sub-list for field type_name
diff --git a/apis/grpc/v1/vald/index_vtproto.pb.go b/apis/grpc/v1/vald/index_vtproto.pb.go
index cda0a74ab3c..572af108a9e 100644
--- a/apis/grpc/v1/vald/index_vtproto.pb.go
+++ b/apis/grpc/v1/vald/index_vtproto.pb.go
@@ -50,6 +50,10 @@ type IndexClient interface {
 	IndexStatistics(ctx context.Context, in *payload.Empty, opts ...grpc.CallOption) (*payload.Info_Index_Statistics, error)
 	// Represent the RPC to get the index statistics for each agents.
 	IndexStatisticsDetail(ctx context.Context, in *payload.Empty, opts ...grpc.CallOption) (*payload.Info_Index_StatisticsDetail, error)
+	// Represent the RPC to get the index property.
+	IndexProperty(ctx context.Context, in *payload.Empty, opts ...grpc.CallOption) (*payload.Info_Index_Property, error)
+	// Represent the RPC to get the index properties for each agents.
+	IndexPropertyDetail(ctx context.Context, in *payload.Empty, opts ...grpc.CallOption) (*payload.Info_Index_PropertyDetail, error)
 }
 
 type indexClient struct {
@@ -104,6 +108,28 @@ func (c *indexClient) IndexStatisticsDetail(
 	return out, nil
 }
 
+func (c *indexClient) IndexProperty(
+	ctx context.Context, in *payload.Empty, opts ...grpc.CallOption,
+) (*payload.Info_Index_Property, error) {
+	out := new(payload.Info_Index_Property)
+	err := c.cc.Invoke(ctx, "/vald.v1.Index/IndexProperty", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *indexClient) IndexPropertyDetail(
+	ctx context.Context, in *payload.Empty, opts ...grpc.CallOption,
+) (*payload.Info_Index_PropertyDetail, error) {
+	out := new(payload.Info_Index_PropertyDetail)
+	err := c.cc.Invoke(ctx, "/vald.v1.Index/IndexPropertyDetail", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // IndexServer is the server API for Index service.
 // All implementations must embed UnimplementedIndexServer
 // for forward compatibility
@@ -116,6 +142,10 @@ type IndexServer interface {
 	IndexStatistics(context.Context, *payload.Empty) (*payload.Info_Index_Statistics, error)
 	// Represent the RPC to get the index statistics for each agents.
 	IndexStatisticsDetail(context.Context, *payload.Empty) (*payload.Info_Index_StatisticsDetail, error)
+	// Represent the RPC to get the index property.
+	IndexProperty(context.Context, *payload.Empty) (*payload.Info_Index_Property, error)
+	// Represent the RPC to get the index properties for each agents.
+	IndexPropertyDetail(context.Context, *payload.Empty) (*payload.Info_Index_PropertyDetail, error)
 	mustEmbedUnimplementedIndexServer()
 }
 
@@ -145,6 +175,18 @@ func (UnimplementedIndexServer) IndexStatisticsDetail(
 ) (*payload.Info_Index_StatisticsDetail, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method IndexStatisticsDetail not implemented")
 }
+
+func (UnimplementedIndexServer) IndexProperty(
+	context.Context, *payload.Empty,
+) (*payload.Info_Index_Property, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method IndexProperty not implemented")
+}
+
+func (UnimplementedIndexServer) IndexPropertyDetail(
+	context.Context, *payload.Empty,
+) (*payload.Info_Index_PropertyDetail, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method IndexPropertyDetail not implemented")
+}
 func (UnimplementedIndexServer) mustEmbedUnimplementedIndexServer() {}
 
 // UnsafeIndexServer may be embedded to opt out of forward compatibility for this service.
@@ -238,6 +280,46 @@ func _Index_IndexStatisticsDetail_Handler(
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Index_IndexProperty_Handler(
+	srv any, ctx context.Context, dec func(any) error, interceptor grpc.UnaryServerInterceptor,
+) (any, error) {
+	in := new(payload.Empty)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(IndexServer).IndexProperty(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/vald.v1.Index/IndexProperty",
+	}
+	handler := func(ctx context.Context, req any) (any, error) {
+		return srv.(IndexServer).IndexProperty(ctx, req.(*payload.Empty))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Index_IndexPropertyDetail_Handler(
+	srv any, ctx context.Context, dec func(any) error, interceptor grpc.UnaryServerInterceptor,
+) (any, error) {
+	in := new(payload.Empty)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(IndexServer).IndexPropertyDetail(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/vald.v1.Index/IndexPropertyDetail",
+	}
+	handler := func(ctx context.Context, req any) (any, error) {
+		return srv.(IndexServer).IndexPropertyDetail(ctx, req.(*payload.Empty))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 // Index_ServiceDesc is the grpc.ServiceDesc for Index service.
 // It's only intended for direct use with grpc.RegisterService,
 // and not to be introspected or modified (even as a copy)
@@ -261,6 +343,14 @@ var Index_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "IndexStatisticsDetail",
 			Handler:    _Index_IndexStatisticsDetail_Handler,
 		},
+		{
+			MethodName: "IndexProperty",
+			Handler:    _Index_IndexProperty_Handler,
+		},
+		{
+			MethodName: "IndexPropertyDetail",
+			Handler:    _Index_IndexPropertyDetail_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "v1/vald/index.proto",
diff --git a/apis/grpc/v1/vald/vald.go b/apis/grpc/v1/vald/vald.go
index a67e7c97eff..0463c83b255 100644
--- a/apis/grpc/v1/vald/vald.go
+++ b/apis/grpc/v1/vald/vald.go
@@ -139,6 +139,8 @@ const (
 	IndexDetailRPCName           = "IndexDetail"
 	IndexStatisticsRPCName       = "IndexStatistics"
 	IndexStatisticsDetailRPCName = "IndexStatisticsDetail"
+	IndexPropertyRPCName         = "IndexProperty"
+	IndexPropertyDetailRPCName   = "IndexPropertyDetail"
 )
 
 type client struct {
diff --git a/apis/proto/v1/payload/payload.proto b/apis/proto/v1/payload/payload.proto
index 5da0fdb1865..9e2d7f3371a 100644
--- a/apis/proto/v1/payload/payload.proto
+++ b/apis/proto/v1/payload/payload.proto
@@ -595,11 +595,11 @@ message Info {
     message Property {
       int32 dimension = 1;
       int32 thread_pool_size = 2;
-      int32 object_type = 3;
-      int32 distance_type = 4;
-      int32 index_type = 5;
-      int32 database_type = 6;
-      int32 object_alignment = 7;
+      string object_type = 3;
+      string distance_type = 4;
+      string index_type = 5;
+      string database_type = 6;
+      string object_alignment = 7;
       int32 path_adjustment_interval = 8;
       int32 graph_shared_memory_size = 9;
       int32 tree_shared_memory_size = 10;
@@ -611,17 +611,17 @@ message Info {
       float max_magnitude = 16;
       int32 n_of_neighbors_for_insertion_order = 17;
       float epsilon_for_insertion_order = 18;
-      int32 refinement_object_type = 19;
+      string refinement_object_type = 19;
       int32 truncation_threshold = 20;
       int32 edge_size_for_creation = 21;
       int32 edge_size_for_search = 22;
       int32 edge_size_limit_for_creation = 23;
       double insertion_radius_coefficient = 24;
       int32 seed_size = 25;
-      int32 seed_type = 26;
+      string seed_type = 26;
       int32 truncation_thread_pool_size = 27;
       int32 batch_size_for_creation = 28;
-      int32 graph_type = 29;
+      string graph_type = 29;
       int32 dynamic_edge_size_base = 30;
       int32 dynamic_edge_size_rate = 31;
       float build_time_limit = 32;
diff --git a/apis/swagger/v1/vald/index.swagger.json b/apis/swagger/v1/vald/index.swagger.json
index 8a42e803733..a3ed5d52bbd 100644
--- a/apis/swagger/v1/vald/index.swagger.json
+++ b/apis/swagger/v1/vald/index.swagger.json
@@ -54,6 +54,48 @@
         "tags": ["Index"]
       }
     },
+    "/index/property": {
+      "get": {
+        "summary": "Represent the RPC to get the index property.",
+        "operationId": "Index_IndexProperty",
+        "responses": {
+          "200": {
+            "description": "A successful response.",
+            "schema": {
+              "$ref": "#/definitions/IndexProperty"
+            }
+          },
+          "default": {
+            "description": "An unexpected error response.",
+            "schema": {
+              "$ref": "#/definitions/rpcStatus"
+            }
+          }
+        },
+        "tags": ["Index"]
+      }
+    },
+    "/index/property/detail": {
+      "get": {
+        "summary": "Represent the RPC to get the index properties for each agents.",
+        "operationId": "Index_IndexPropertyDetail",
+        "responses": {
+          "200": {
+            "description": "A successful response.",
+            "schema": {
+              "$ref": "#/definitions/IndexPropertyDetail"
+            }
+          },
+          "default": {
+            "description": "An unexpected error response.",
+            "schema": {
+              "$ref": "#/definitions/rpcStatus"
+            }
+          }
+        },
+        "tags": ["Index"]
+      }
+    },
     "/index/statistics": {
       "get": {
         "summary": "Represent the RPC to get the index statistics.",
@@ -145,6 +187,158 @@
       },
       "description": "Represent the index count for each Agents message."
     },
+    "IndexProperty": {
+      "type": "object",
+      "properties": {
+        "dimension": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "threadPoolSize": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "objectType": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "distanceType": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "indexType": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "databaseType": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "objectAlignment": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "pathAdjustmentInterval": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "graphSharedMemorySize": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "treeSharedMemorySize": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "objectSharedMemorySize": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "prefetchOffset": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "prefetchSize": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "accuracyTable": {
+          "type": "string"
+        },
+        "searchType": {
+          "type": "string"
+        },
+        "maxMagnitude": {
+          "type": "number",
+          "format": "float"
+        },
+        "nOfNeighborsForInsertionOrder": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "epsilonForInsertionOrder": {
+          "type": "number",
+          "format": "float"
+        },
+        "refinementObjectType": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "truncationThreshold": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "edgeSizeForCreation": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "edgeSizeForSearch": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "edgeSizeLimitForCreation": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "insertionRadiusCoefficient": {
+          "type": "number",
+          "format": "double"
+        },
+        "seedSize": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "seedType": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "truncationThreadPoolSize": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "batchSizeForCreation": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "graphType": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "dynamicEdgeSizeBase": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "dynamicEdgeSizeRate": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "buildTimeLimit": {
+          "type": "number",
+          "format": "float"
+        },
+        "outgoingEdge": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "incomingEdge": {
+          "type": "integer",
+          "format": "int32"
+        }
+      },
+      "title": "Represents index Property"
+    },
+    "IndexPropertyDetail": {
+      "type": "object",
+      "properties": {
+        "details": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/definitions/IndexProperty"
+          }
+        }
+      },
+      "title": "Represents index Properties for each Agents"
+    },
     "IndexStatistics": {
       "type": "object",
       "properties": {
diff --git a/internal/client/v1/client/vald/vald.go b/internal/client/v1/client/vald/vald.go
index 00957b7b7b4..8f8ad0c5efa 100644
--- a/internal/client/v1/client/vald/vald.go
+++ b/internal/client/v1/client/vald/vald.go
@@ -828,6 +828,50 @@ func (c *client) IndexStatisticsDetail(
 	return res, nil
 }
 
+func (c *client) IndexProperty(
+	ctx context.Context, in *payload.Empty, opts ...grpc.CallOption,
+) (res *payload.Info_Index_Property, err error) {
+	ctx, span := trace.StartSpan(grpc.WrapGRPCMethod(ctx, "internal/client/"+vald.IndexPropertyRPCName), apiName+"/"+vald.IndexPropertyRPCName)
+	defer func() {
+		if span != nil {
+			span.End()
+		}
+	}()
+	_, err = c.c.RoundRobin(ctx, func(ctx context.Context,
+		conn *grpc.ClientConn,
+		copts ...grpc.CallOption,
+	) (any, error) {
+		res, err = vald.NewValdClient(conn).IndexProperty(ctx, in, append(copts, opts...)...)
+		return nil, err
+	})
+	if err != nil {
+		return nil, err
+	}
+	return res, nil
+}
+
+func (c *client) IndexPropertyDetail(
+	ctx context.Context, in *payload.Empty, opts ...grpc.CallOption,
+) (res *payload.Info_Index_PropertyDetail, err error) {
+	ctx, span := trace.StartSpan(grpc.WrapGRPCMethod(ctx, "internal/client/"+vald.IndexPropertyDetailRPCName), apiName+"/"+vald.IndexPropertyDetailRPCName)
+	defer func() {
+		if span != nil {
+			span.End()
+		}
+	}()
+	_, err = c.c.RoundRobin(ctx, func(ctx context.Context,
+		conn *grpc.ClientConn,
+		copts ...grpc.CallOption,
+	) (any, error) {
+		res, err = vald.NewValdClient(conn).IndexPropertyDetail(ctx, in, append(copts, opts...)...)
+		return nil, err
+	})
+	if err != nil {
+		return nil, err
+	}
+	return res, nil
+}
+
 func (c *client) GetTimestamp(
 	ctx context.Context, in *payload.Object_TimestampRequest, opts ...grpc.CallOption,
 ) (res *payload.Object_Timestamp, err error) {
@@ -1270,6 +1314,30 @@ func (c *singleClient) IndexStatisticsDetail(
 	return c.vc.IndexStatisticsDetail(ctx, in, opts...)
 }
 
+func (c *singleClient) IndexProperty(
+	ctx context.Context, in *payload.Empty, opts ...grpc.CallOption,
+) (res *payload.Info_Index_Property, err error) {
+	ctx, span := trace.StartSpan(grpc.WrapGRPCMethod(ctx, "internal/singleClient/"+vald.IndexPropertyRPCName), apiName+"/"+vald.IndexPropertyRPCName)
+	defer func() {
+		if span != nil {
+			span.End()
+		}
+	}()
+	return c.vc.IndexProperty(ctx, in, opts...)
+}
+
+func (c *singleClient) IndexPropertyDetail(
+	ctx context.Context, in *payload.Empty, opts ...grpc.CallOption,
+) (res *payload.Info_Index_PropertyDetail, err error) {
+	ctx, span := trace.StartSpan(grpc.WrapGRPCMethod(ctx, "internal/client/"+vald.IndexPropertyDetailRPCName), apiName+"/"+vald.IndexPropertyDetailRPCName)
+	defer func() {
+		if span != nil {
+			span.End()
+		}
+	}()
+	return c.vc.IndexPropertyDetail(ctx, in, opts...)
+}
+
 func (c *singleClient) GetTimestamp(
 	ctx context.Context, in *payload.Object_TimestampRequest, opts ...grpc.CallOption,
 ) (res *payload.Object_Timestamp, err error) {
diff --git a/internal/core/algorithm/ngt/ngt.go b/internal/core/algorithm/ngt/ngt.go
index 56aeb548d0d..0a51bce5a95 100644
--- a/internal/core/algorithm/ngt/ngt.go
+++ b/internal/core/algorithm/ngt/ngt.go
@@ -87,6 +87,9 @@ type (
 
 		GetGraphStatistics(m statisticsType) (stats *GraphStatistics, err error)
 
+		// GetProperty returns NGT Index Property.
+		GetProperty() (*Property, error)
+
 		// Close Without save index.
 		CloseWithoutSaveIndex()
 
@@ -155,6 +158,43 @@ type (
 		OutdegreeHistogram               []uint64
 		IndegreeHistogram                []uint64
 	}
+
+	Property struct {
+		Dimension                     int32
+		ThreadPoolSize                int32
+		ObjectType                    objectType
+		DistanceType                  distanceType
+		IndexType                     indexType
+		DatabaseType                  databaseType
+		ObjectAlignment               objectAlignment
+		pathAdjustmentInterval        int32
+		graphSharedMemorySize         int32
+		treeSharedMemorySize          int32
+		ObjectSharedMemorySize        int32
+		PrefetchOffset                int32
+		PrefetchSize                  int32
+		AccuracyTable                 string
+		SearchType                    string
+		MaxMagnitude                  float32
+		NOfNeighborsForInsertionOrder int32
+		EpsilonForInsersionOrder      float32
+		RefinementObjectType          objectType
+		TruncationThreshold           int32
+		EdgeSizeForCreation           int32
+		EdgeSizeForSearch             int32
+		EdgeSizeLimitForCreation      int32
+		InsertionRadiusCoefficient    float64
+		SeedSize                      string
+		SeedType                      seedType
+		TruuncationThreadPoolSize     int32
+		BatchSizeForCreation          int32
+		GraphType                     graphType
+		DynamicEdgeSizeBase           int32
+		DynamicEdgeSizeRate           int32
+		BuildTimeLimit                float32
+		OutgoingEdge                  int32
+		IncomingEdge                  int32
+	}
 )
 
 func newNGTError() (n *ngtError) {
@@ -183,6 +223,21 @@ type distanceType int
 
 type statisticsType int
 
+// IndexType is alias of index type in NGT.
+type indexType int
+
+// DatabaseType is alias of database type in NGT.
+type databaseType int
+
+// ObjectAlignment is alias of object alignment in NGT.
+type objectAlignment int
+
+// SeedType is alias of seed type in NGT.
+type seedType int
+
+// GraphType is alias of graph type in NGT.
+type graphType int
+
 const (
 	// -------------------------------------------------------------
 	// Object Type Definition
@@ -229,6 +284,50 @@ const (
 	// InnerProduct is inner product distance.
 	InnerProduct
 
+	// -------------------------------------------------------------
+	// IndexType Definition
+	// -------------------------------------------------------------
+	IndexTypeNone = iota
+	GraphAndTree
+	Graph
+
+	// -------------------------------------------------------------
+	// DatabaseType Definition
+	// -------------------------------------------------------------
+	DatabaseTypeNone = iota
+	Memory
+	MemoryMappedFile
+
+	// -------------------------------------------------------------
+	// ObjectAlignment Definition
+	// -------------------------------------------------------------
+	ObjectAlignmentNone = iota
+	ObjectAlignmentTrue
+	ObjectAlignmentFalse
+
+	// -------------------------------------------------------------
+	// SeedType Definition
+	// -------------------------------------------------------------
+	// SeedTypeNone is unknown seed type.
+	SeedTypeNone seedType = iota
+	RandomNodes
+	FixedNodes
+	FirstNode
+	AllLeafNodes
+
+	// -------------------------------------------------------------
+	// GraphType Definition
+	// -------------------------------------------------------------
+	GraphTypeNone graphType = iota
+	ANNG
+	KNNG
+	BKNNG
+	ONNG
+	IANNG
+	DNNG
+	RANNG
+	RIANNG
+
 	// -------------------------------------------------------------.
 
 	// -------------------------------------------------------------
@@ -285,6 +384,72 @@ func (d distanceType) String() string {
 	return "Unknown"
 }
 
+func (i indexType) String() string {
+	switch i {
+	case GraphAndTree:
+		return "GraphAndTree"
+	case Graph:
+		return "Graph"
+	}
+	return "Unknown"
+}
+
+func (d databaseType) String() string {
+	switch d {
+	case Memory:
+		return "Memory"
+	case MemoryMappedFile:
+		return "MemoryMappedFile"
+	}
+	return "Unknown"
+}
+
+func (o objectAlignment) String() string {
+	switch o {
+	case ObjectAlignmentTrue:
+		return "true"
+	case ObjectAlignmentFalse:
+		return "false"
+	}
+	return "Unknown"
+}
+
+func (s seedType) String() string {
+	switch s {
+	case RandomNodes:
+		return "RandomNodes"
+	case FixedNodes:
+		return "FixedNodes"
+	case FirstNode:
+		return "FirstNode"
+	case AllLeafNodes:
+		return "AllLeafNodes"
+	}
+	return "Unknown"
+}
+
+func (g graphType) String() string {
+	switch g {
+	case ANNG:
+		return "ANNG"
+	case KNNG:
+		return "KNNG"
+	case BKNNG:
+		return "BKNNG"
+	case ONNG:
+		return "ONNG"
+	case IANNG:
+		return "IANNG"
+	case DNNG:
+		return "DNNG"
+	case RANNG:
+		return "RANNG"
+	case RIANNG:
+		return "RIANNG"
+	}
+	return "Unknown"
+}
+
 // New returns NGT instance with recreating empty index file.
 func New(opts ...Option) (NGT, error) {
 	return gen(false, opts...)
@@ -979,3 +1144,9 @@ func (n *ngt) GetGraphStatistics(m statisticsType) (stats *GraphStatistics, err
 	defer C.ngt_free_graph_statistics(&cstats)
 	return fromCGraphStatistics(&cstats), nil
 }
+
+func (n *ngt) GetProperty() (prop *Property, err error) {
+	ne := n.GetErrorBuffer()
+	cprop := C.ngt_get_property_info(n.index, ne.err)
+	
+}
diff --git a/rust/libs/proto/src/filter.egress.v1.tonic.rs b/rust/libs/proto/src/filter.egress.v1.tonic.rs
index 902dc5f5d2e..3ff1dd2a6e5 100644
--- a/rust/libs/proto/src/filter.egress.v1.tonic.rs
+++ b/rust/libs/proto/src/filter.egress.v1.tonic.rs
@@ -17,8 +17,6 @@ pub mod filter_client {
     #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
     use tonic::codegen::*;
     use tonic::codegen::http::Uri;
-    /** Represent the egress filter service.
-*/
     #[derive(Debug, Clone)]
     pub struct FilterClient<T> {
         inner: tonic::client::Grpc<T>,
@@ -189,8 +187,6 @@ pub mod filter_server {
             tonic::Status,
         >;
     }
-    /** Represent the egress filter service.
-*/
     #[derive(Debug)]
     pub struct FilterServer<T: Filter> {
         inner: _Inner<T>,
diff --git a/rust/libs/proto/src/filter.ingress.v1.tonic.rs b/rust/libs/proto/src/filter.ingress.v1.tonic.rs
index f5f9efd4f29..26379388023 100644
--- a/rust/libs/proto/src/filter.ingress.v1.tonic.rs
+++ b/rust/libs/proto/src/filter.ingress.v1.tonic.rs
@@ -17,8 +17,6 @@ pub mod filter_client {
     #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
     use tonic::codegen::*;
     use tonic::codegen::http::Uri;
-    /** Represent the ingress filter service.
-*/
     #[derive(Debug, Clone)]
     pub struct FilterClient<T> {
         inner: tonic::client::Grpc<T>,
@@ -189,8 +187,6 @@ pub mod filter_server {
             tonic::Status,
         >;
     }
-    /** Represent the ingress filter service.
-*/
     #[derive(Debug)]
     pub struct FilterServer<T: Filter> {
         inner: _Inner<T>,
diff --git a/rust/libs/proto/src/payload.v1.rs b/rust/libs/proto/src/payload.v1.rs
index 40a2c08f78d..497c4277c67 100644
--- a/rust/libs/proto/src/payload.v1.rs
+++ b/rust/libs/proto/src/payload.v1.rs
@@ -956,6 +956,86 @@ pub mod info {
             #[prost(map="string, message", tag="1")]
             pub details: ::std::collections::HashMap<::prost::alloc::string::String, Statistics>,
         }
+        /// Represents index Property
+        #[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+        pub struct Property {
+            #[prost(int32, tag="1")]
+            pub dimension: i32,
+            #[prost(int32, tag="2")]
+            pub thread_pool_size: i32,
+            #[prost(int32, tag="3")]
+            pub object_type: i32,
+            #[prost(int32, tag="4")]
+            pub distance_type: i32,
+            #[prost(int32, tag="5")]
+            pub index_type: i32,
+            #[prost(int32, tag="6")]
+            pub database_type: i32,
+            #[prost(int32, tag="7")]
+            pub object_alignment: i32,
+            #[prost(int32, tag="8")]
+            pub path_adjustment_interval: i32,
+            #[prost(int32, tag="9")]
+            pub graph_shared_memory_size: i32,
+            #[prost(int32, tag="10")]
+            pub tree_shared_memory_size: i32,
+            #[prost(int32, tag="11")]
+            pub object_shared_memory_size: i32,
+            #[prost(int32, tag="12")]
+            pub prefetch_offset: i32,
+            #[prost(int32, tag="13")]
+            pub prefetch_size: i32,
+            #[prost(string, tag="14")]
+            pub accuracy_table: ::prost::alloc::string::String,
+            #[prost(string, tag="15")]
+            pub search_type: ::prost::alloc::string::String,
+            #[prost(float, tag="16")]
+            pub max_magnitude: f32,
+            #[prost(int32, tag="17")]
+            pub n_of_neighbors_for_insertion_order: i32,
+            #[prost(float, tag="18")]
+            pub epsilon_for_insertion_order: f32,
+            #[prost(int32, tag="19")]
+            pub refinement_object_type: i32,
+            #[prost(int32, tag="20")]
+            pub truncation_threshold: i32,
+            #[prost(int32, tag="21")]
+            pub edge_size_for_creation: i32,
+            #[prost(int32, tag="22")]
+            pub edge_size_for_search: i32,
+            #[prost(int32, tag="23")]
+            pub edge_size_limit_for_creation: i32,
+            #[prost(double, tag="24")]
+            pub insertion_radius_coefficient: f64,
+            #[prost(int32, tag="25")]
+            pub seed_size: i32,
+            #[prost(int32, tag="26")]
+            pub seed_type: i32,
+            #[prost(int32, tag="27")]
+            pub truncation_thread_pool_size: i32,
+            #[prost(int32, tag="28")]
+            pub batch_size_for_creation: i32,
+            #[prost(int32, tag="29")]
+            pub graph_type: i32,
+            #[prost(int32, tag="30")]
+            pub dynamic_edge_size_base: i32,
+            #[prost(int32, tag="31")]
+            pub dynamic_edge_size_rate: i32,
+            #[prost(float, tag="32")]
+            pub build_time_limit: f32,
+            #[prost(int32, tag="33")]
+            pub outgoing_edge: i32,
+            #[prost(int32, tag="34")]
+            pub incoming_edge: i32,
+        }
+        /// Represents index Properties for each Agents
+        #[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+        pub struct PropertyDetail {
+            #[prost(map="string, message", tag="1")]
+            pub details: ::std::collections::HashMap<::prost::alloc::string::String, Property>,
+        }
     }
     /// Represent the pod information message.
     #[allow(clippy::derive_partial_eq_without_eq)]
diff --git a/rust/libs/proto/src/vald.v1.tonic.rs b/rust/libs/proto/src/vald.v1.tonic.rs
index 1ff23e3b464..563b4e793af 100644
--- a/rust/libs/proto/src/vald.v1.tonic.rs
+++ b/rust/libs/proto/src/vald.v1.tonic.rs
@@ -124,8 +124,6 @@ pub mod filter_client {
                 .insert(GrpcMethod::new("vald.v1.Filter", "SearchObject"));
             self.inner.unary(req, path, codec).await
         }
-        /** A method to search multiple objects.
-*/
         pub async fn multi_search_object(
             &mut self,
             request: impl tonic::IntoRequest<
@@ -477,8 +475,6 @@ pub mod filter_server {
             tonic::Response<super::super::super::payload::v1::search::Response>,
             tonic::Status,
         >;
-        /** A method to search multiple objects.
-*/
         async fn multi_search_object(
             &self,
             request: tonic::Request<
@@ -1757,8 +1753,6 @@ pub mod index_client {
             req.extensions_mut().insert(GrpcMethod::new("vald.v1.Index", "IndexInfo"));
             self.inner.unary(req, path, codec).await
         }
-        /** Represent the RPC to get the index information for each agents.
-*/
         pub async fn index_detail(
             &mut self,
             request: impl tonic::IntoRequest<super::super::super::payload::v1::Empty>,
@@ -1839,6 +1833,62 @@ pub mod index_client {
                 .insert(GrpcMethod::new("vald.v1.Index", "IndexStatisticsDetail"));
             self.inner.unary(req, path, codec).await
         }
+        /** Represent the RPC to get the index property.
+*/
+        pub async fn index_property(
+            &mut self,
+            request: impl tonic::IntoRequest<super::super::super::payload::v1::Empty>,
+        ) -> std::result::Result<
+            tonic::Response<super::super::super::payload::v1::info::index::Property>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::new(
+                        tonic::Code::Unknown,
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/vald.v1.Index/IndexProperty",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("vald.v1.Index", "IndexProperty"));
+            self.inner.unary(req, path, codec).await
+        }
+        /** Represent the RPC to get the index properties for each agents.
+*/
+        pub async fn index_property_detail(
+            &mut self,
+            request: impl tonic::IntoRequest<super::super::super::payload::v1::Empty>,
+        ) -> std::result::Result<
+            tonic::Response<
+                super::super::super::payload::v1::info::index::PropertyDetail,
+            >,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::new(
+                        tonic::Code::Unknown,
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/vald.v1.Index/IndexPropertyDetail",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("vald.v1.Index", "IndexPropertyDetail"));
+            self.inner.unary(req, path, codec).await
+        }
     }
 }
 /// Generated server implementations.
@@ -1855,8 +1905,6 @@ pub mod index_server {
             tonic::Response<super::super::super::payload::v1::info::index::Count>,
             tonic::Status,
         >;
-        /** Represent the RPC to get the index information for each agents.
-*/
         async fn index_detail(
             &self,
             request: tonic::Request<super::super::super::payload::v1::Empty>,
@@ -1884,6 +1932,26 @@ pub mod index_server {
             >,
             tonic::Status,
         >;
+        /** Represent the RPC to get the index property.
+*/
+        async fn index_property(
+            &self,
+            request: tonic::Request<super::super::super::payload::v1::Empty>,
+        ) -> std::result::Result<
+            tonic::Response<super::super::super::payload::v1::info::index::Property>,
+            tonic::Status,
+        >;
+        /** Represent the RPC to get the index properties for each agents.
+*/
+        async fn index_property_detail(
+            &self,
+            request: tonic::Request<super::super::super::payload::v1::Empty>,
+        ) -> std::result::Result<
+            tonic::Response<
+                super::super::super::payload::v1::info::index::PropertyDetail,
+            >,
+            tonic::Status,
+        >;
     }
     #[derive(Debug)]
     pub struct IndexServer<T: Index> {
@@ -2160,6 +2228,104 @@ pub mod index_server {
                     };
                     Box::pin(fut)
                 }
+                "/vald.v1.Index/IndexProperty" => {
+                    #[allow(non_camel_case_types)]
+                    struct IndexPropertySvc<T: Index>(pub Arc<T>);
+                    impl<
+                        T: Index,
+                    > tonic::server::UnaryService<
+                        super::super::super::payload::v1::Empty,
+                    > for IndexPropertySvc<T> {
+                        type Response = super::super::super::payload::v1::info::index::Property;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<
+                                super::super::super::payload::v1::Empty,
+                            >,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as Index>::index_property(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let inner = inner.0;
+                        let method = IndexPropertySvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/vald.v1.Index/IndexPropertyDetail" => {
+                    #[allow(non_camel_case_types)]
+                    struct IndexPropertyDetailSvc<T: Index>(pub Arc<T>);
+                    impl<
+                        T: Index,
+                    > tonic::server::UnaryService<
+                        super::super::super::payload::v1::Empty,
+                    > for IndexPropertyDetailSvc<T> {
+                        type Response = super::super::super::payload::v1::info::index::PropertyDetail;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<
+                                super::super::super::payload::v1::Empty,
+                            >,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as Index>::index_property_detail(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let inner = inner.0;
+                        let method = IndexPropertyDetailSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
                 _ => {
                     Box::pin(async move {
                         Ok(
@@ -4051,8 +4217,6 @@ pub mod search_client {
             req.extensions_mut().insert(GrpcMethod::new("vald.v1.Search", "Search"));
             self.inner.unary(req, path, codec).await
         }
-        /** A method to search indexed vectors by ID.
-*/
         pub async fn search_by_id(
             &mut self,
             request: impl tonic::IntoRequest<
@@ -4403,8 +4567,6 @@ pub mod search_server {
             tonic::Response<super::super::super::payload::v1::search::Response>,
             tonic::Status,
         >;
-        /** A method to search indexed vectors by ID.
-*/
         async fn search_by_id(
             &self,
             request: tonic::Request<super::super::super::payload::v1::search::IdRequest>,