hyperspace-sdk-ts 2.2.0 → 3.0.0

package/dist/proto/hyperspace_grpc_pb.js

@@ -147,6 +147,116 @@ 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_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_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_InsertRequest(arg) {
   if (!(arg instanceof hyperspace_pb.InsertRequest)) {
     throw new Error('Expected argument of type hyperspace.InsertRequest');
@@ -213,6 +323,17 @@ 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');
@@ -235,6 +356,28 @@ function deserialize_hyperspace_ReplicationRequest(buffer_arg) {
   return hyperspace_pb.ReplicationRequest.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');
@@ -257,6 +400,17 @@ 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');
@@ -268,6 +422,61 @@ 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');
@@ -279,6 +488,50 @@ 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_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
@@ -360,6 +613,28 @@ insert: {
     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',
@@ -396,6 +671,74 @@ searchBatch: {
     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,
+  },
   // Stream statistics for TUI (Global or Collection tailored)
 monitor: {
     path: '/hyperspace.Database/Monitor',
@@ -431,6 +774,17 @@ triggerSnapshot: {
     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',
@@ -455,6 +809,18 @@ replicate: {
     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,
@@ -477,6 +843,43 @@ replicate: {
     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,
+  },
 };
 
 exports.DatabaseClient = grpc.makeGenericClientConstructor(DatabaseService, 'Database');