hyperspace-sdk-ts 3.1.6 → 3.1.7

package/dist/proto/proto/hyperspace_grpc_pb.js

@@ -0,0 +1,1107 @@
+// GENERATED CODE -- DO NOT EDIT!
+
+'use strict';
+var grpc = require('@grpc/grpc-js');
+var hyperspace_pb = require('./hyperspace_pb.js');
+
+function serialize_hyperspace_BatchInsertRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.BatchInsertRequest)) {
+    throw new Error('Expected argument of type hyperspace.BatchInsertRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_BatchInsertRequest(buffer_arg) {
+  return hyperspace_pb.BatchInsertRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_BatchSearchRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.BatchSearchRequest)) {
+    throw new Error('Expected argument of type hyperspace.BatchSearchRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_BatchSearchRequest(buffer_arg) {
+  return hyperspace_pb.BatchSearchRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_BatchSearchResponse(arg) {
+  if (!(arg instanceof hyperspace_pb.BatchSearchResponse)) {
+    throw new Error('Expected argument of type hyperspace.BatchSearchResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_BatchSearchResponse(buffer_arg) {
+  return hyperspace_pb.BatchSearchResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_CollectionStatsRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.CollectionStatsRequest)) {
+    throw new Error('Expected argument of type hyperspace.CollectionStatsRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_CollectionStatsRequest(buffer_arg) {
+  return hyperspace_pb.CollectionStatsRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_CollectionStatsResponse(arg) {
+  if (!(arg instanceof hyperspace_pb.CollectionStatsResponse)) {
+    throw new Error('Expected argument of type hyperspace.CollectionStatsResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_CollectionStatsResponse(buffer_arg) {
+  return hyperspace_pb.CollectionStatsResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_ConfigUpdate(arg) {
+  if (!(arg instanceof hyperspace_pb.ConfigUpdate)) {
+    throw new Error('Expected argument of type hyperspace.ConfigUpdate');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_ConfigUpdate(buffer_arg) {
+  return hyperspace_pb.ConfigUpdate.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_CountRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.CountRequest)) {
+    throw new Error('Expected argument of type hyperspace.CountRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_CountRequest(buffer_arg) {
+  return hyperspace_pb.CountRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_CountResponse(arg) {
+  if (!(arg instanceof hyperspace_pb.CountResponse)) {
+    throw new Error('Expected argument of type hyperspace.CountResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_CountResponse(buffer_arg) {
+  return hyperspace_pb.CountResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_CreateCollectionRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.CreateCollectionRequest)) {
+    throw new Error('Expected argument of type hyperspace.CreateCollectionRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_CreateCollectionRequest(buffer_arg) {
+  return hyperspace_pb.CreateCollectionRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_DeleteCollectionRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.DeleteCollectionRequest)) {
+    throw new Error('Expected argument of type hyperspace.DeleteCollectionRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_DeleteCollectionRequest(buffer_arg) {
+  return hyperspace_pb.DeleteCollectionRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_DeleteRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.DeleteRequest)) {
+    throw new Error('Expected argument of type hyperspace.DeleteRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_DeleteRequest(buffer_arg) {
+  return hyperspace_pb.DeleteRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_DeleteResponse(arg) {
+  if (!(arg instanceof hyperspace_pb.DeleteResponse)) {
+    throw new Error('Expected argument of type hyperspace.DeleteResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_DeleteResponse(buffer_arg) {
+  return hyperspace_pb.DeleteResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_DigestRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.DigestRequest)) {
+    throw new Error('Expected argument of type hyperspace.DigestRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_DigestRequest(buffer_arg) {
+  return hyperspace_pb.DigestRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_DigestResponse(arg) {
+  if (!(arg instanceof hyperspace_pb.DigestResponse)) {
+    throw new Error('Expected argument of type hyperspace.DigestResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_DigestResponse(buffer_arg) {
+  return hyperspace_pb.DigestResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_Empty(arg) {
+  if (!(arg instanceof hyperspace_pb.Empty)) {
+    throw new Error('Expected argument of type hyperspace.Empty');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_Empty(buffer_arg) {
+  return hyperspace_pb.Empty.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_EventMessage(arg) {
+  if (!(arg instanceof hyperspace_pb.EventMessage)) {
+    throw new Error('Expected argument of type hyperspace.EventMessage');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_EventMessage(buffer_arg) {
+  return hyperspace_pb.EventMessage.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_EventSubscriptionRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.EventSubscriptionRequest)) {
+    throw new Error('Expected argument of type hyperspace.EventSubscriptionRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_EventSubscriptionRequest(buffer_arg) {
+  return hyperspace_pb.EventSubscriptionRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_FindSemanticClustersRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.FindSemanticClustersRequest)) {
+    throw new Error('Expected argument of type hyperspace.FindSemanticClustersRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_FindSemanticClustersRequest(buffer_arg) {
+  return hyperspace_pb.FindSemanticClustersRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_FindSemanticClustersResponse(arg) {
+  if (!(arg instanceof hyperspace_pb.FindSemanticClustersResponse)) {
+    throw new Error('Expected argument of type hyperspace.FindSemanticClustersResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_FindSemanticClustersResponse(buffer_arg) {
+  return hyperspace_pb.FindSemanticClustersResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_FreezeCollectionRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.FreezeCollectionRequest)) {
+    throw new Error('Expected argument of type hyperspace.FreezeCollectionRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_FreezeCollectionRequest(buffer_arg) {
+  return hyperspace_pb.FreezeCollectionRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_GetConceptParentsRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.GetConceptParentsRequest)) {
+    throw new Error('Expected argument of type hyperspace.GetConceptParentsRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_GetConceptParentsRequest(buffer_arg) {
+  return hyperspace_pb.GetConceptParentsRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_GetConceptParentsResponse(arg) {
+  if (!(arg instanceof hyperspace_pb.GetConceptParentsResponse)) {
+    throw new Error('Expected argument of type hyperspace.GetConceptParentsResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_GetConceptParentsResponse(buffer_arg) {
+  return hyperspace_pb.GetConceptParentsResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_GetNeighborsRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.GetNeighborsRequest)) {
+    throw new Error('Expected argument of type hyperspace.GetNeighborsRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_GetNeighborsRequest(buffer_arg) {
+  return hyperspace_pb.GetNeighborsRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_GetNeighborsResponse(arg) {
+  if (!(arg instanceof hyperspace_pb.GetNeighborsResponse)) {
+    throw new Error('Expected argument of type hyperspace.GetNeighborsResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_GetNeighborsResponse(buffer_arg) {
+  return hyperspace_pb.GetNeighborsResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_GetNodeRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.GetNodeRequest)) {
+    throw new Error('Expected argument of type hyperspace.GetNodeRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_GetNodeRequest(buffer_arg) {
+  return hyperspace_pb.GetNodeRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_GetPointsRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.GetPointsRequest)) {
+    throw new Error('Expected argument of type hyperspace.GetPointsRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_GetPointsRequest(buffer_arg) {
+  return hyperspace_pb.GetPointsRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_GetPointsResponse(arg) {
+  if (!(arg instanceof hyperspace_pb.GetPointsResponse)) {
+    throw new Error('Expected argument of type hyperspace.GetPointsResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_GetPointsResponse(buffer_arg) {
+  return hyperspace_pb.GetPointsResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_GetSubsumptionTreeRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.GetSubsumptionTreeRequest)) {
+    throw new Error('Expected argument of type hyperspace.GetSubsumptionTreeRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_GetSubsumptionTreeRequest(buffer_arg) {
+  return hyperspace_pb.GetSubsumptionTreeRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_GetSubsumptionTreeResponse(arg) {
+  if (!(arg instanceof hyperspace_pb.GetSubsumptionTreeResponse)) {
+    throw new Error('Expected argument of type hyperspace.GetSubsumptionTreeResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_GetSubsumptionTreeResponse(buffer_arg) {
+  return hyperspace_pb.GetSubsumptionTreeResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_GraphNode(arg) {
+  if (!(arg instanceof hyperspace_pb.GraphNode)) {
+    throw new Error('Expected argument of type hyperspace.GraphNode');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_GraphNode(buffer_arg) {
+  return hyperspace_pb.GraphNode.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_HealthCheckResponse(arg) {
+  if (!(arg instanceof hyperspace_pb.HealthCheckResponse)) {
+    throw new Error('Expected argument of type hyperspace.HealthCheckResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_HealthCheckResponse(buffer_arg) {
+  return hyperspace_pb.HealthCheckResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_InsertRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.InsertRequest)) {
+    throw new Error('Expected argument of type hyperspace.InsertRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_InsertRequest(buffer_arg) {
+  return hyperspace_pb.InsertRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_InsertResponse(arg) {
+  if (!(arg instanceof hyperspace_pb.InsertResponse)) {
+    throw new Error('Expected argument of type hyperspace.InsertResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_InsertResponse(buffer_arg) {
+  return hyperspace_pb.InsertResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_InsertTextRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.InsertTextRequest)) {
+    throw new Error('Expected argument of type hyperspace.InsertTextRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_InsertTextRequest(buffer_arg) {
+  return hyperspace_pb.InsertTextRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_ListCollectionsResponse(arg) {
+  if (!(arg instanceof hyperspace_pb.ListCollectionsResponse)) {
+    throw new Error('Expected argument of type hyperspace.ListCollectionsResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_ListCollectionsResponse(buffer_arg) {
+  return hyperspace_pb.ListCollectionsResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_MonitorRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.MonitorRequest)) {
+    throw new Error('Expected argument of type hyperspace.MonitorRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_MonitorRequest(buffer_arg) {
+  return hyperspace_pb.MonitorRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_RebuildIndexRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.RebuildIndexRequest)) {
+    throw new Error('Expected argument of type hyperspace.RebuildIndexRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_RebuildIndexRequest(buffer_arg) {
+  return hyperspace_pb.RebuildIndexRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_ReconsolidationRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.ReconsolidationRequest)) {
+    throw new Error('Expected argument of type hyperspace.ReconsolidationRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_ReconsolidationRequest(buffer_arg) {
+  return hyperspace_pb.ReconsolidationRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_ReplicationLog(arg) {
+  if (!(arg instanceof hyperspace_pb.ReplicationLog)) {
+    throw new Error('Expected argument of type hyperspace.ReplicationLog');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_ReplicationLog(buffer_arg) {
+  return hyperspace_pb.ReplicationLog.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_ReplicationRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.ReplicationRequest)) {
+    throw new Error('Expected argument of type hyperspace.ReplicationRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_ReplicationRequest(buffer_arg) {
+  return hyperspace_pb.ReplicationRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_ScrollRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.ScrollRequest)) {
+    throw new Error('Expected argument of type hyperspace.ScrollRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_ScrollRequest(buffer_arg) {
+  return hyperspace_pb.ScrollRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_ScrollResponse(arg) {
+  if (!(arg instanceof hyperspace_pb.ScrollResponse)) {
+    throw new Error('Expected argument of type hyperspace.ScrollResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_ScrollResponse(buffer_arg) {
+  return hyperspace_pb.ScrollResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_SearchMultiCollectionRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.SearchMultiCollectionRequest)) {
+    throw new Error('Expected argument of type hyperspace.SearchMultiCollectionRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_SearchMultiCollectionRequest(buffer_arg) {
+  return hyperspace_pb.SearchMultiCollectionRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_SearchMultiCollectionResponse(arg) {
+  if (!(arg instanceof hyperspace_pb.SearchMultiCollectionResponse)) {
+    throw new Error('Expected argument of type hyperspace.SearchMultiCollectionResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_SearchMultiCollectionResponse(buffer_arg) {
+  return hyperspace_pb.SearchMultiCollectionResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_SearchRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.SearchRequest)) {
+    throw new Error('Expected argument of type hyperspace.SearchRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_SearchRequest(buffer_arg) {
+  return hyperspace_pb.SearchRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_SearchResponse(arg) {
+  if (!(arg instanceof hyperspace_pb.SearchResponse)) {
+    throw new Error('Expected argument of type hyperspace.SearchResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_SearchResponse(buffer_arg) {
+  return hyperspace_pb.SearchResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_SearchTextRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.SearchTextRequest)) {
+    throw new Error('Expected argument of type hyperspace.SearchTextRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_SearchTextRequest(buffer_arg) {
+  return hyperspace_pb.SearchTextRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_StatusResponse(arg) {
+  if (!(arg instanceof hyperspace_pb.StatusResponse)) {
+    throw new Error('Expected argument of type hyperspace.StatusResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_StatusResponse(buffer_arg) {
+  return hyperspace_pb.StatusResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_SyncHandshakeRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.SyncHandshakeRequest)) {
+    throw new Error('Expected argument of type hyperspace.SyncHandshakeRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_SyncHandshakeRequest(buffer_arg) {
+  return hyperspace_pb.SyncHandshakeRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_SyncHandshakeResponse(arg) {
+  if (!(arg instanceof hyperspace_pb.SyncHandshakeResponse)) {
+    throw new Error('Expected argument of type hyperspace.SyncHandshakeResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_SyncHandshakeResponse(buffer_arg) {
+  return hyperspace_pb.SyncHandshakeResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_SyncPullRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.SyncPullRequest)) {
+    throw new Error('Expected argument of type hyperspace.SyncPullRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_SyncPullRequest(buffer_arg) {
+  return hyperspace_pb.SyncPullRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_SyncPushResponse(arg) {
+  if (!(arg instanceof hyperspace_pb.SyncPushResponse)) {
+    throw new Error('Expected argument of type hyperspace.SyncPushResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_SyncPushResponse(buffer_arg) {
+  return hyperspace_pb.SyncPushResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_SyncVectorData(arg) {
+  if (!(arg instanceof hyperspace_pb.SyncVectorData)) {
+    throw new Error('Expected argument of type hyperspace.SyncVectorData');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_SyncVectorData(buffer_arg) {
+  return hyperspace_pb.SyncVectorData.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_SystemStats(arg) {
+  if (!(arg instanceof hyperspace_pb.SystemStats)) {
+    throw new Error('Expected argument of type hyperspace.SystemStats');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_SystemStats(buffer_arg) {
+  return hyperspace_pb.SystemStats.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_TraverseRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.TraverseRequest)) {
+    throw new Error('Expected argument of type hyperspace.TraverseRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_TraverseRequest(buffer_arg) {
+  return hyperspace_pb.TraverseRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_TraverseResponse(arg) {
+  if (!(arg instanceof hyperspace_pb.TraverseResponse)) {
+    throw new Error('Expected argument of type hyperspace.TraverseResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_TraverseResponse(buffer_arg) {
+  return hyperspace_pb.TraverseResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_UnfreezeCollectionRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.UnfreezeCollectionRequest)) {
+    throw new Error('Expected argument of type hyperspace.UnfreezeCollectionRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_UnfreezeCollectionRequest(buffer_arg) {
+  return hyperspace_pb.UnfreezeCollectionRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_UpdatePayloadRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.UpdatePayloadRequest)) {
+    throw new Error('Expected argument of type hyperspace.UpdatePayloadRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_UpdatePayloadRequest(buffer_arg) {
+  return hyperspace_pb.UpdatePayloadRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_VectorizeRequest(arg) {
+  if (!(arg instanceof hyperspace_pb.VectorizeRequest)) {
+    throw new Error('Expected argument of type hyperspace.VectorizeRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_VectorizeRequest(buffer_arg) {
+  return hyperspace_pb.VectorizeRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_hyperspace_VectorizeResponse(arg) {
+  if (!(arg instanceof hyperspace_pb.VectorizeResponse)) {
+    throw new Error('Expected argument of type hyperspace.VectorizeResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_hyperspace_VectorizeResponse(buffer_arg) {
+  return hyperspace_pb.VectorizeResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+
+var DatabaseService = exports.DatabaseService = {
+  // Collection Management
+createCollection: {
+    path: '/hyperspace.Database/CreateCollection',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.CreateCollectionRequest,
+    responseType: hyperspace_pb.StatusResponse,
+    requestSerialize: serialize_hyperspace_CreateCollectionRequest,
+    requestDeserialize: deserialize_hyperspace_CreateCollectionRequest,
+    responseSerialize: serialize_hyperspace_StatusResponse,
+    responseDeserialize: deserialize_hyperspace_StatusResponse,
+  },
+  deleteCollection: {
+    path: '/hyperspace.Database/DeleteCollection',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.DeleteCollectionRequest,
+    responseType: hyperspace_pb.StatusResponse,
+    requestSerialize: serialize_hyperspace_DeleteCollectionRequest,
+    requestDeserialize: deserialize_hyperspace_DeleteCollectionRequest,
+    responseSerialize: serialize_hyperspace_StatusResponse,
+    responseDeserialize: deserialize_hyperspace_StatusResponse,
+  },
+  listCollections: {
+    path: '/hyperspace.Database/ListCollections',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.Empty,
+    responseType: hyperspace_pb.ListCollectionsResponse,
+    requestSerialize: serialize_hyperspace_Empty,
+    requestDeserialize: deserialize_hyperspace_Empty,
+    responseSerialize: serialize_hyperspace_ListCollectionsResponse,
+    responseDeserialize: deserialize_hyperspace_ListCollectionsResponse,
+  },
+  getCollectionStats: {
+    path: '/hyperspace.Database/GetCollectionStats',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.CollectionStatsRequest,
+    responseType: hyperspace_pb.CollectionStatsResponse,
+    requestSerialize: serialize_hyperspace_CollectionStatsRequest,
+    requestDeserialize: deserialize_hyperspace_CollectionStatsRequest,
+    responseSerialize: serialize_hyperspace_CollectionStatsResponse,
+    responseDeserialize: deserialize_hyperspace_CollectionStatsResponse,
+  },
+  freezeCollection: {
+    path: '/hyperspace.Database/FreezeCollection',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.FreezeCollectionRequest,
+    responseType: hyperspace_pb.StatusResponse,
+    requestSerialize: serialize_hyperspace_FreezeCollectionRequest,
+    requestDeserialize: deserialize_hyperspace_FreezeCollectionRequest,
+    responseSerialize: serialize_hyperspace_StatusResponse,
+    responseDeserialize: deserialize_hyperspace_StatusResponse,
+  },
+  unfreezeCollection: {
+    path: '/hyperspace.Database/UnfreezeCollection',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.UnfreezeCollectionRequest,
+    responseType: hyperspace_pb.StatusResponse,
+    requestSerialize: serialize_hyperspace_UnfreezeCollectionRequest,
+    requestDeserialize: deserialize_hyperspace_UnfreezeCollectionRequest,
+    responseSerialize: serialize_hyperspace_StatusResponse,
+    responseDeserialize: deserialize_hyperspace_StatusResponse,
+  },
+  // Insert vectors
+insert: {
+    path: '/hyperspace.Database/Insert',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.InsertRequest,
+    responseType: hyperspace_pb.InsertResponse,
+    requestSerialize: serialize_hyperspace_InsertRequest,
+    requestDeserialize: deserialize_hyperspace_InsertRequest,
+    responseSerialize: serialize_hyperspace_InsertResponse,
+    responseDeserialize: deserialize_hyperspace_InsertResponse,
+  },
+  batchInsert: {
+    path: '/hyperspace.Database/BatchInsert',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.BatchInsertRequest,
+    responseType: hyperspace_pb.InsertResponse,
+    requestSerialize: serialize_hyperspace_BatchInsertRequest,
+    requestDeserialize: deserialize_hyperspace_BatchInsertRequest,
+    responseSerialize: serialize_hyperspace_InsertResponse,
+    responseDeserialize: deserialize_hyperspace_InsertResponse,
+  },
+  insertText: {
+    path: '/hyperspace.Database/InsertText',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.InsertTextRequest,
+    responseType: hyperspace_pb.InsertResponse,
+    requestSerialize: serialize_hyperspace_InsertTextRequest,
+    requestDeserialize: deserialize_hyperspace_InsertTextRequest,
+    responseSerialize: serialize_hyperspace_InsertResponse,
+    responseDeserialize: deserialize_hyperspace_InsertResponse,
+  },
+  vectorize: {
+    path: '/hyperspace.Database/Vectorize',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.VectorizeRequest,
+    responseType: hyperspace_pb.VectorizeResponse,
+    requestSerialize: serialize_hyperspace_VectorizeRequest,
+    requestDeserialize: deserialize_hyperspace_VectorizeRequest,
+    responseSerialize: serialize_hyperspace_VectorizeResponse,
+    responseDeserialize: deserialize_hyperspace_VectorizeResponse,
+  },
+  searchText: {
+    path: '/hyperspace.Database/SearchText',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.SearchTextRequest,
+    responseType: hyperspace_pb.SearchResponse,
+    requestSerialize: serialize_hyperspace_SearchTextRequest,
+    requestDeserialize: deserialize_hyperspace_SearchTextRequest,
+    responseSerialize: serialize_hyperspace_SearchResponse,
+    responseDeserialize: deserialize_hyperspace_SearchResponse,
+  },
+  // Delete vectors
+delete: {
+    path: '/hyperspace.Database/Delete',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.DeleteRequest,
+    responseType: hyperspace_pb.DeleteResponse,
+    requestSerialize: serialize_hyperspace_DeleteRequest,
+    requestDeserialize: deserialize_hyperspace_DeleteRequest,
+    responseSerialize: serialize_hyperspace_DeleteResponse,
+    responseDeserialize: deserialize_hyperspace_DeleteResponse,
+  },
+  // Extended Data Ops
+getPoints: {
+    path: '/hyperspace.Database/GetPoints',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.GetPointsRequest,
+    responseType: hyperspace_pb.GetPointsResponse,
+    requestSerialize: serialize_hyperspace_GetPointsRequest,
+    requestDeserialize: deserialize_hyperspace_GetPointsRequest,
+    responseSerialize: serialize_hyperspace_GetPointsResponse,
+    responseDeserialize: deserialize_hyperspace_GetPointsResponse,
+  },
+  updatePayload: {
+    path: '/hyperspace.Database/UpdatePayload',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.UpdatePayloadRequest,
+    responseType: hyperspace_pb.StatusResponse,
+    requestSerialize: serialize_hyperspace_UpdatePayloadRequest,
+    requestDeserialize: deserialize_hyperspace_UpdatePayloadRequest,
+    responseSerialize: serialize_hyperspace_StatusResponse,
+    responseDeserialize: deserialize_hyperspace_StatusResponse,
+  },
+  scroll: {
+    path: '/hyperspace.Database/Scroll',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.ScrollRequest,
+    responseType: hyperspace_pb.ScrollResponse,
+    requestSerialize: serialize_hyperspace_ScrollRequest,
+    requestDeserialize: deserialize_hyperspace_ScrollRequest,
+    responseSerialize: serialize_hyperspace_ScrollResponse,
+    responseDeserialize: deserialize_hyperspace_ScrollResponse,
+  },
+  count: {
+    path: '/hyperspace.Database/Count',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.CountRequest,
+    responseType: hyperspace_pb.CountResponse,
+    requestSerialize: serialize_hyperspace_CountRequest,
+    requestDeserialize: deserialize_hyperspace_CountRequest,
+    responseSerialize: serialize_hyperspace_CountResponse,
+    responseDeserialize: deserialize_hyperspace_CountResponse,
+  },
+  // Search (ANN)
+search: {
+    path: '/hyperspace.Database/Search',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.SearchRequest,
+    responseType: hyperspace_pb.SearchResponse,
+    requestSerialize: serialize_hyperspace_SearchRequest,
+    requestDeserialize: deserialize_hyperspace_SearchRequest,
+    responseSerialize: serialize_hyperspace_SearchResponse,
+    responseDeserialize: deserialize_hyperspace_SearchResponse,
+  },
+  // Batch Search (ANN)
+searchBatch: {
+    path: '/hyperspace.Database/SearchBatch',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.BatchSearchRequest,
+    responseType: hyperspace_pb.BatchSearchResponse,
+    requestSerialize: serialize_hyperspace_BatchSearchRequest,
+    requestDeserialize: deserialize_hyperspace_BatchSearchRequest,
+    responseSerialize: serialize_hyperspace_BatchSearchResponse,
+    responseDeserialize: deserialize_hyperspace_BatchSearchResponse,
+  },
+  // Multi-Geometry Search (v3.0)
+searchMultiCollection: {
+    path: '/hyperspace.Database/SearchMultiCollection',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.SearchMultiCollectionRequest,
+    responseType: hyperspace_pb.SearchMultiCollectionResponse,
+    requestSerialize: serialize_hyperspace_SearchMultiCollectionRequest,
+    requestDeserialize: deserialize_hyperspace_SearchMultiCollectionRequest,
+    responseSerialize: serialize_hyperspace_SearchMultiCollectionResponse,
+    responseDeserialize: deserialize_hyperspace_SearchMultiCollectionResponse,
+  },
+  // Graph Traversal API (v2.3)
+getNode: {
+    path: '/hyperspace.Database/GetNode',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.GetNodeRequest,
+    responseType: hyperspace_pb.GraphNode,
+    requestSerialize: serialize_hyperspace_GetNodeRequest,
+    requestDeserialize: deserialize_hyperspace_GetNodeRequest,
+    responseSerialize: serialize_hyperspace_GraphNode,
+    responseDeserialize: deserialize_hyperspace_GraphNode,
+  },
+  getNeighbors: {
+    path: '/hyperspace.Database/GetNeighbors',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.GetNeighborsRequest,
+    responseType: hyperspace_pb.GetNeighborsResponse,
+    requestSerialize: serialize_hyperspace_GetNeighborsRequest,
+    requestDeserialize: deserialize_hyperspace_GetNeighborsRequest,
+    responseSerialize: serialize_hyperspace_GetNeighborsResponse,
+    responseDeserialize: deserialize_hyperspace_GetNeighborsResponse,
+  },
+  getConceptParents: {
+    path: '/hyperspace.Database/GetConceptParents',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.GetConceptParentsRequest,
+    responseType: hyperspace_pb.GetConceptParentsResponse,
+    requestSerialize: serialize_hyperspace_GetConceptParentsRequest,
+    requestDeserialize: deserialize_hyperspace_GetConceptParentsRequest,
+    responseSerialize: serialize_hyperspace_GetConceptParentsResponse,
+    responseDeserialize: deserialize_hyperspace_GetConceptParentsResponse,
+  },
+  traverse: {
+    path: '/hyperspace.Database/Traverse',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.TraverseRequest,
+    responseType: hyperspace_pb.TraverseResponse,
+    requestSerialize: serialize_hyperspace_TraverseRequest,
+    requestDeserialize: deserialize_hyperspace_TraverseRequest,
+    responseSerialize: serialize_hyperspace_TraverseResponse,
+    responseDeserialize: deserialize_hyperspace_TraverseResponse,
+  },
+  findSemanticClusters: {
+    path: '/hyperspace.Database/FindSemanticClusters',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.FindSemanticClustersRequest,
+    responseType: hyperspace_pb.FindSemanticClustersResponse,
+    requestSerialize: serialize_hyperspace_FindSemanticClustersRequest,
+    requestDeserialize: deserialize_hyperspace_FindSemanticClustersRequest,
+    responseSerialize: serialize_hyperspace_FindSemanticClustersResponse,
+    responseDeserialize: deserialize_hyperspace_FindSemanticClustersResponse,
+  },
+  getSubsumptionTree: {
+    path: '/hyperspace.Database/GetSubsumptionTree',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.GetSubsumptionTreeRequest,
+    responseType: hyperspace_pb.GetSubsumptionTreeResponse,
+    requestSerialize: serialize_hyperspace_GetSubsumptionTreeRequest,
+    requestDeserialize: deserialize_hyperspace_GetSubsumptionTreeRequest,
+    responseSerialize: serialize_hyperspace_GetSubsumptionTreeResponse,
+    responseDeserialize: deserialize_hyperspace_GetSubsumptionTreeResponse,
+  },
+  // Stream statistics for TUI (Global or Collection tailored)
+monitor: {
+    path: '/hyperspace.Database/Monitor',
+    requestStream: false,
+    responseStream: true,
+    requestType: hyperspace_pb.MonitorRequest,
+    responseType: hyperspace_pb.SystemStats,
+    requestSerialize: serialize_hyperspace_MonitorRequest,
+    requestDeserialize: deserialize_hyperspace_MonitorRequest,
+    responseSerialize: serialize_hyperspace_SystemStats,
+    responseDeserialize: deserialize_hyperspace_SystemStats,
+  },
+  // Admin Controls
+triggerSnapshot: {
+    path: '/hyperspace.Database/TriggerSnapshot',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.Empty,
+    responseType: hyperspace_pb.StatusResponse,
+    requestSerialize: serialize_hyperspace_Empty,
+    requestDeserialize: deserialize_hyperspace_Empty,
+    responseSerialize: serialize_hyperspace_StatusResponse,
+    responseDeserialize: deserialize_hyperspace_StatusResponse,
+  },
+  triggerVacuum: {
+    path: '/hyperspace.Database/TriggerVacuum',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.Empty,
+    responseType: hyperspace_pb.StatusResponse,
+    requestSerialize: serialize_hyperspace_Empty,
+    requestDeserialize: deserialize_hyperspace_Empty,
+    responseSerialize: serialize_hyperspace_StatusResponse,
+    responseDeserialize: deserialize_hyperspace_StatusResponse,
+  },
+  triggerReconsolidation: {
+    path: '/hyperspace.Database/TriggerReconsolidation',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.ReconsolidationRequest,
+    responseType: hyperspace_pb.StatusResponse,
+    requestSerialize: serialize_hyperspace_ReconsolidationRequest,
+    requestDeserialize: deserialize_hyperspace_ReconsolidationRequest,
+    responseSerialize: serialize_hyperspace_StatusResponse,
+    responseDeserialize: deserialize_hyperspace_StatusResponse,
+  },
+  // Dynamic Configuration
+configure: {
+    path: '/hyperspace.Database/Configure',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.ConfigUpdate,
+    responseType: hyperspace_pb.StatusResponse,
+    requestSerialize: serialize_hyperspace_ConfigUpdate,
+    requestDeserialize: deserialize_hyperspace_ConfigUpdate,
+    responseSerialize: serialize_hyperspace_StatusResponse,
+    responseDeserialize: deserialize_hyperspace_StatusResponse,
+  },
+  // Replication (Leader -> Follower)
+replicate: {
+    path: '/hyperspace.Database/Replicate',
+    requestStream: false,
+    responseStream: true,
+    requestType: hyperspace_pb.ReplicationRequest,
+    responseType: hyperspace_pb.ReplicationLog,
+    requestSerialize: serialize_hyperspace_ReplicationRequest,
+    requestDeserialize: deserialize_hyperspace_ReplicationRequest,
+    responseSerialize: serialize_hyperspace_ReplicationLog,
+    responseDeserialize: deserialize_hyperspace_ReplicationLog,
+  },
+  // CDC/Event Stream (External subscribers)
+subscribeToEvents: {
+    path: '/hyperspace.Database/SubscribeToEvents',
+    requestStream: false,
+    responseStream: true,
+    requestType: hyperspace_pb.EventSubscriptionRequest,
+    responseType: hyperspace_pb.EventMessage,
+    requestSerialize: serialize_hyperspace_EventSubscriptionRequest,
+    requestDeserialize: deserialize_hyperspace_EventSubscriptionRequest,
+    responseSerialize: serialize_hyperspace_EventMessage,
+    responseDeserialize: deserialize_hyperspace_EventMessage,
+  },
+  getDigest: {
+    path: '/hyperspace.Database/GetDigest',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.DigestRequest,
+    responseType: hyperspace_pb.DigestResponse,
+    requestSerialize: serialize_hyperspace_DigestRequest,
+    requestDeserialize: deserialize_hyperspace_DigestRequest,
+    responseSerialize: serialize_hyperspace_DigestResponse,
+    responseDeserialize: deserialize_hyperspace_DigestResponse,
+  },
+  rebuildIndex: {
+    path: '/hyperspace.Database/RebuildIndex',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.RebuildIndexRequest,
+    responseType: hyperspace_pb.StatusResponse,
+    requestSerialize: serialize_hyperspace_RebuildIndexRequest,
+    requestDeserialize: deserialize_hyperspace_RebuildIndexRequest,
+    responseSerialize: serialize_hyperspace_StatusResponse,
+    responseDeserialize: deserialize_hyperspace_StatusResponse,
+  },
+  // Delta Sync (Merkle Tree — Task 2.1)
+// Step 1: Client sends its digest, server returns which buckets differ.
+syncHandshake: {
+    path: '/hyperspace.Database/SyncHandshake',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.SyncHandshakeRequest,
+    responseType: hyperspace_pb.SyncHandshakeResponse,
+    requestSerialize: serialize_hyperspace_SyncHandshakeRequest,
+    requestDeserialize: deserialize_hyperspace_SyncHandshakeRequest,
+    responseSerialize: serialize_hyperspace_SyncHandshakeResponse,
+    responseDeserialize: deserialize_hyperspace_SyncHandshakeResponse,
+  },
+  // Step 2: Client requests vectors from specific buckets, server streams them.
+syncPull: {
+    path: '/hyperspace.Database/SyncPull',
+    requestStream: false,
+    responseStream: true,
+    requestType: hyperspace_pb.SyncPullRequest,
+    responseType: hyperspace_pb.SyncVectorData,
+    requestSerialize: serialize_hyperspace_SyncPullRequest,
+    requestDeserialize: deserialize_hyperspace_SyncPullRequest,
+    responseSerialize: serialize_hyperspace_SyncVectorData,
+    responseDeserialize: deserialize_hyperspace_SyncVectorData,
+  },
+  // Step 3 (optional): Client pushes its unique vectors to the server.
+syncPush: {
+    path: '/hyperspace.Database/SyncPush',
+    requestStream: true,
+    responseStream: false,
+    requestType: hyperspace_pb.SyncVectorData,
+    responseType: hyperspace_pb.SyncPushResponse,
+    requestSerialize: serialize_hyperspace_SyncVectorData,
+    requestDeserialize: deserialize_hyperspace_SyncVectorData,
+    responseSerialize: serialize_hyperspace_SyncPushResponse,
+    responseDeserialize: deserialize_hyperspace_SyncPushResponse,
+  },
+  // Health Status
+healthCheck: {
+    path: '/hyperspace.Database/HealthCheck',
+    requestStream: false,
+    responseStream: false,
+    requestType: hyperspace_pb.Empty,
+    responseType: hyperspace_pb.HealthCheckResponse,
+    requestSerialize: serialize_hyperspace_Empty,
+    requestDeserialize: deserialize_hyperspace_Empty,
+    responseSerialize: serialize_hyperspace_HealthCheckResponse,
+    responseDeserialize: deserialize_hyperspace_HealthCheckResponse,
+  },
+};
+
+exports.DatabaseClient = grpc.makeGenericClientConstructor(DatabaseService, 'Database');