hyperspace-sdk-ts 3.1.6 → 3.1.7

package/dist/proto/hyperspace_pb.d.ts

@@ -0,0 +1,2716 @@
+// package: hyperspace
+// file: hyperspace.proto
+
+/* tslint:disable */
+/* eslint-disable */
+
+import * as jspb from "google-protobuf";
+
+export class ReplicationRequest extends jspb.Message { 
+    getLastLogicalClock(): number;
+    setLastLogicalClock(value: number): ReplicationRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ReplicationRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: ReplicationRequest): ReplicationRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ReplicationRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ReplicationRequest;
+    static deserializeBinaryFromReader(message: ReplicationRequest, reader: jspb.BinaryReader): ReplicationRequest;
+}
+
+export namespace ReplicationRequest {
+    export type AsObject = {
+        lastLogicalClock: number,
+    }
+}
+
+export class ReplicationLog extends jspb.Message { 
+    getLogicalClock(): number;
+    setLogicalClock(value: number): ReplicationLog;
+    getOriginNodeId(): string;
+    setOriginNodeId(value: string): ReplicationLog;
+    getCollection(): string;
+    setCollection(value: string): ReplicationLog;
+
+    hasInsert(): boolean;
+    clearInsert(): void;
+    getInsert(): InsertOp | undefined;
+    setInsert(value?: InsertOp): ReplicationLog;
+
+    hasCreateCollection(): boolean;
+    clearCreateCollection(): void;
+    getCreateCollection(): CreateCollectionOp | undefined;
+    setCreateCollection(value?: CreateCollectionOp): ReplicationLog;
+
+    hasDeleteCollection(): boolean;
+    clearDeleteCollection(): void;
+    getDeleteCollection(): DeleteCollectionOp | undefined;
+    setDeleteCollection(value?: DeleteCollectionOp): ReplicationLog;
+
+    hasDelete(): boolean;
+    clearDelete(): void;
+    getDelete(): DeleteOp | undefined;
+    setDelete(value?: DeleteOp): ReplicationLog;
+
+    getOperationCase(): ReplicationLog.OperationCase;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ReplicationLog.AsObject;
+    static toObject(includeInstance: boolean, msg: ReplicationLog): ReplicationLog.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ReplicationLog, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ReplicationLog;
+    static deserializeBinaryFromReader(message: ReplicationLog, reader: jspb.BinaryReader): ReplicationLog;
+}
+
+export namespace ReplicationLog {
+    export type AsObject = {
+        logicalClock: number,
+        originNodeId: string,
+        collection: string,
+        insert?: InsertOp.AsObject,
+        createCollection?: CreateCollectionOp.AsObject,
+        deleteCollection?: DeleteCollectionOp.AsObject,
+        pb_delete?: DeleteOp.AsObject,
+    }
+
+    export enum OperationCase {
+        OPERATION_NOT_SET = 0,
+        INSERT = 4,
+        CREATE_COLLECTION = 5,
+        DELETE_COLLECTION = 6,
+        DELETE = 7,
+    }
+
+}
+
+export class InsertOp extends jspb.Message { 
+    getId(): number;
+    setId(value: number): InsertOp;
+    clearVectorList(): void;
+    getVectorList(): Array<number>;
+    setVectorList(value: Array<number>): InsertOp;
+    addVector(value: number, index?: number): number;
+
+    getMetadataMap(): jspb.Map<string, string>;
+    clearMetadataMap(): void;
+
+    getTypedMetadataMap(): jspb.Map<string, MetadataValue>;
+    clearTypedMetadataMap(): void;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): InsertOp.AsObject;
+    static toObject(includeInstance: boolean, msg: InsertOp): InsertOp.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: InsertOp, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): InsertOp;
+    static deserializeBinaryFromReader(message: InsertOp, reader: jspb.BinaryReader): InsertOp;
+}
+
+export namespace InsertOp {
+    export type AsObject = {
+        id: number,
+        vectorList: Array<number>,
+
+        metadataMap: Array<[string, string]>,
+
+        typedMetadataMap: Array<[string, MetadataValue.AsObject]>,
+    }
+}
+
+export class CreateCollectionOp extends jspb.Message { 
+
+    hasSchema(): boolean;
+    clearSchema(): void;
+    getSchema(): CollectionSchema | undefined;
+    setSchema(value?: CollectionSchema): CreateCollectionOp;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CreateCollectionOp.AsObject;
+    static toObject(includeInstance: boolean, msg: CreateCollectionOp): CreateCollectionOp.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CreateCollectionOp, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CreateCollectionOp;
+    static deserializeBinaryFromReader(message: CreateCollectionOp, reader: jspb.BinaryReader): CreateCollectionOp;
+}
+
+export namespace CreateCollectionOp {
+    export type AsObject = {
+        schema?: CollectionSchema.AsObject,
+    }
+}
+
+export class DeleteCollectionOp extends jspb.Message { 
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): DeleteCollectionOp.AsObject;
+    static toObject(includeInstance: boolean, msg: DeleteCollectionOp): DeleteCollectionOp.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: DeleteCollectionOp, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): DeleteCollectionOp;
+    static deserializeBinaryFromReader(message: DeleteCollectionOp, reader: jspb.BinaryReader): DeleteCollectionOp;
+}
+
+export namespace DeleteCollectionOp {
+    export type AsObject = {
+    }
+}
+
+export class DeleteOp extends jspb.Message { 
+    getId(): number;
+    setId(value: number): DeleteOp;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): DeleteOp.AsObject;
+    static toObject(includeInstance: boolean, msg: DeleteOp): DeleteOp.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: DeleteOp, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): DeleteOp;
+    static deserializeBinaryFromReader(message: DeleteOp, reader: jspb.BinaryReader): DeleteOp;
+}
+
+export namespace DeleteOp {
+    export type AsObject = {
+        id: number,
+    }
+}
+
+export class QuantizationConfig extends jspb.Message { 
+    getMode(): QuantizationMode;
+    setMode(value: QuantizationMode): QuantizationConfig;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): QuantizationConfig.AsObject;
+    static toObject(includeInstance: boolean, msg: QuantizationConfig): QuantizationConfig.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: QuantizationConfig, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): QuantizationConfig;
+    static deserializeBinaryFromReader(message: QuantizationConfig, reader: jspb.BinaryReader): QuantizationConfig;
+}
+
+export namespace QuantizationConfig {
+    export type AsObject = {
+        mode: QuantizationMode,
+    }
+}
+
+export class CreateCollectionRequest extends jspb.Message { 
+    getName(): string;
+    setName(value: string): CreateCollectionRequest;
+
+    hasSchema(): boolean;
+    clearSchema(): void;
+    getSchema(): CollectionSchema | undefined;
+    setSchema(value?: CollectionSchema): CreateCollectionRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CreateCollectionRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: CreateCollectionRequest): CreateCollectionRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CreateCollectionRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CreateCollectionRequest;
+    static deserializeBinaryFromReader(message: CreateCollectionRequest, reader: jspb.BinaryReader): CreateCollectionRequest;
+}
+
+export namespace CreateCollectionRequest {
+    export type AsObject = {
+        name: string,
+        schema?: CollectionSchema.AsObject,
+    }
+}
+
+export class VectorComponent extends jspb.Message { 
+    getName(): string;
+    setName(value: string): VectorComponent;
+    getMetric(): string;
+    setMetric(value: string): VectorComponent;
+    getFullDimension(): number;
+    setFullDimension(value: number): VectorComponent;
+    getWeight(): number;
+    setWeight(value: number): VectorComponent;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): VectorComponent.AsObject;
+    static toObject(includeInstance: boolean, msg: VectorComponent): VectorComponent.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: VectorComponent, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): VectorComponent;
+    static deserializeBinaryFromReader(message: VectorComponent, reader: jspb.BinaryReader): VectorComponent;
+}
+
+export namespace VectorComponent {
+    export type AsObject = {
+        name: string,
+        metric: string,
+        fullDimension: number,
+        weight: number,
+    }
+}
+
+export class MrlLayer extends jspb.Message { 
+    getComponentName(): string;
+    setComponentName(value: string): MrlLayer;
+    getCutoffDimension(): number;
+    setCutoffDimension(value: number): MrlLayer;
+    getStoreInRam(): boolean;
+    setStoreInRam(value: boolean): MrlLayer;
+    getRerankTopK(): number;
+    setRerankTopK(value: number): MrlLayer;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): MrlLayer.AsObject;
+    static toObject(includeInstance: boolean, msg: MrlLayer): MrlLayer.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: MrlLayer, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): MrlLayer;
+    static deserializeBinaryFromReader(message: MrlLayer, reader: jspb.BinaryReader): MrlLayer;
+}
+
+export namespace MrlLayer {
+    export type AsObject = {
+        componentName: string,
+        cutoffDimension: number,
+        storeInRam: boolean,
+        rerankTopK: number,
+    }
+}
+
+export class CollectionSchema extends jspb.Message { 
+    clearComponentsList(): void;
+    getComponentsList(): Array<VectorComponent>;
+    setComponentsList(value: Array<VectorComponent>): CollectionSchema;
+    addComponents(value?: VectorComponent, index?: number): VectorComponent;
+    clearCascadePipelineList(): void;
+    getCascadePipelineList(): Array<MrlLayer>;
+    setCascadePipelineList(value: Array<MrlLayer>): CollectionSchema;
+    addCascadePipeline(value?: MrlLayer, index?: number): MrlLayer;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CollectionSchema.AsObject;
+    static toObject(includeInstance: boolean, msg: CollectionSchema): CollectionSchema.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CollectionSchema, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CollectionSchema;
+    static deserializeBinaryFromReader(message: CollectionSchema, reader: jspb.BinaryReader): CollectionSchema;
+}
+
+export namespace CollectionSchema {
+    export type AsObject = {
+        componentsList: Array<VectorComponent.AsObject>,
+        cascadePipelineList: Array<MrlLayer.AsObject>,
+    }
+}
+
+export class CollectionComponent extends jspb.Message { 
+    getSpace(): string;
+    setSpace(value: string): CollectionComponent;
+    getDimension(): number;
+    setDimension(value: number): CollectionComponent;
+    getMetric(): string;
+    setMetric(value: string): CollectionComponent;
+
+    hasWeight(): boolean;
+    clearWeight(): void;
+    getWeight(): number | undefined;
+    setWeight(value: number): CollectionComponent;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CollectionComponent.AsObject;
+    static toObject(includeInstance: boolean, msg: CollectionComponent): CollectionComponent.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CollectionComponent, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CollectionComponent;
+    static deserializeBinaryFromReader(message: CollectionComponent, reader: jspb.BinaryReader): CollectionComponent;
+}
+
+export namespace CollectionComponent {
+    export type AsObject = {
+        space: string,
+        dimension: number,
+        metric: string,
+        weight?: number,
+    }
+}
+
+export class DeleteCollectionRequest extends jspb.Message { 
+    getName(): string;
+    setName(value: string): DeleteCollectionRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): DeleteCollectionRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: DeleteCollectionRequest): DeleteCollectionRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: DeleteCollectionRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): DeleteCollectionRequest;
+    static deserializeBinaryFromReader(message: DeleteCollectionRequest, reader: jspb.BinaryReader): DeleteCollectionRequest;
+}
+
+export namespace DeleteCollectionRequest {
+    export type AsObject = {
+        name: string,
+    }
+}
+
+export class CollectionSummary extends jspb.Message { 
+    getName(): string;
+    setName(value: string): CollectionSummary;
+    getCount(): number;
+    setCount(value: number): CollectionSummary;
+
+    hasSchema(): boolean;
+    clearSchema(): void;
+    getSchema(): CollectionSchema | undefined;
+    setSchema(value?: CollectionSchema): CollectionSummary;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CollectionSummary.AsObject;
+    static toObject(includeInstance: boolean, msg: CollectionSummary): CollectionSummary.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CollectionSummary, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CollectionSummary;
+    static deserializeBinaryFromReader(message: CollectionSummary, reader: jspb.BinaryReader): CollectionSummary;
+}
+
+export namespace CollectionSummary {
+    export type AsObject = {
+        name: string,
+        count: number,
+        schema?: CollectionSchema.AsObject,
+    }
+}
+
+export class ListCollectionsResponse extends jspb.Message { 
+    clearCollectionsList(): void;
+    getCollectionsList(): Array<CollectionSummary>;
+    setCollectionsList(value: Array<CollectionSummary>): ListCollectionsResponse;
+    addCollections(value?: CollectionSummary, index?: number): CollectionSummary;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ListCollectionsResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: ListCollectionsResponse): ListCollectionsResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ListCollectionsResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ListCollectionsResponse;
+    static deserializeBinaryFromReader(message: ListCollectionsResponse, reader: jspb.BinaryReader): ListCollectionsResponse;
+}
+
+export namespace ListCollectionsResponse {
+    export type AsObject = {
+        collectionsList: Array<CollectionSummary.AsObject>,
+    }
+}
+
+export class CollectionStatsRequest extends jspb.Message { 
+    getName(): string;
+    setName(value: string): CollectionStatsRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CollectionStatsRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: CollectionStatsRequest): CollectionStatsRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CollectionStatsRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CollectionStatsRequest;
+    static deserializeBinaryFromReader(message: CollectionStatsRequest, reader: jspb.BinaryReader): CollectionStatsRequest;
+}
+
+export namespace CollectionStatsRequest {
+    export type AsObject = {
+        name: string,
+    }
+}
+
+export class CollectionStatsResponse extends jspb.Message { 
+    getCount(): number;
+    setCount(value: number): CollectionStatsResponse;
+    getIndexingQueue(): number;
+    setIndexingQueue(value: number): CollectionStatsResponse;
+    getDiskUsageBytes(): number;
+    setDiskUsageBytes(value: number): CollectionStatsResponse;
+    getRamUsageBytes(): number;
+    setRamUsageBytes(value: number): CollectionStatsResponse;
+    getActiveTasks(): number;
+    setActiveTasks(value: number): CollectionStatsResponse;
+
+    hasSchema(): boolean;
+    clearSchema(): void;
+    getSchema(): CollectionSchema | undefined;
+    setSchema(value?: CollectionSchema): CollectionStatsResponse;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CollectionStatsResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: CollectionStatsResponse): CollectionStatsResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CollectionStatsResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CollectionStatsResponse;
+    static deserializeBinaryFromReader(message: CollectionStatsResponse, reader: jspb.BinaryReader): CollectionStatsResponse;
+}
+
+export namespace CollectionStatsResponse {
+    export type AsObject = {
+        count: number,
+        indexingQueue: number,
+        diskUsageBytes: number,
+        ramUsageBytes: number,
+        activeTasks: number,
+        schema?: CollectionSchema.AsObject,
+    }
+}
+
+export class RebuildIndexRequest extends jspb.Message { 
+    getName(): string;
+    setName(value: string): RebuildIndexRequest;
+
+    hasFilterQuery(): boolean;
+    clearFilterQuery(): void;
+    getFilterQuery(): VacuumFilterQuery | undefined;
+    setFilterQuery(value?: VacuumFilterQuery): RebuildIndexRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): RebuildIndexRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: RebuildIndexRequest): RebuildIndexRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: RebuildIndexRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): RebuildIndexRequest;
+    static deserializeBinaryFromReader(message: RebuildIndexRequest, reader: jspb.BinaryReader): RebuildIndexRequest;
+}
+
+export namespace RebuildIndexRequest {
+    export type AsObject = {
+        name: string,
+        filterQuery?: VacuumFilterQuery.AsObject,
+    }
+}
+
+export class ConfigUpdate extends jspb.Message { 
+    getCollection(): string;
+    setCollection(value: string): ConfigUpdate;
+
+    hasEfSearch(): boolean;
+    clearEfSearch(): void;
+    getEfSearch(): number | undefined;
+    setEfSearch(value: number): ConfigUpdate;
+
+    hasEfConstruction(): boolean;
+    clearEfConstruction(): void;
+    getEfConstruction(): number | undefined;
+    setEfConstruction(value: number): ConfigUpdate;
+
+    hasM(): boolean;
+    clearM(): void;
+    getM(): number | undefined;
+    setM(value: number): ConfigUpdate;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ConfigUpdate.AsObject;
+    static toObject(includeInstance: boolean, msg: ConfigUpdate): ConfigUpdate.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ConfigUpdate, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ConfigUpdate;
+    static deserializeBinaryFromReader(message: ConfigUpdate, reader: jspb.BinaryReader): ConfigUpdate;
+}
+
+export namespace ConfigUpdate {
+    export type AsObject = {
+        collection: string,
+        efSearch?: number,
+        efConstruction?: number,
+        m?: number,
+    }
+}
+
+export class VacuumFilterQuery extends jspb.Message { 
+    getKey(): string;
+    setKey(value: string): VacuumFilterQuery;
+    getOp(): string;
+    setOp(value: string): VacuumFilterQuery;
+    getValue(): number;
+    setValue(value: number): VacuumFilterQuery;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): VacuumFilterQuery.AsObject;
+    static toObject(includeInstance: boolean, msg: VacuumFilterQuery): VacuumFilterQuery.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: VacuumFilterQuery, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): VacuumFilterQuery;
+    static deserializeBinaryFromReader(message: VacuumFilterQuery, reader: jspb.BinaryReader): VacuumFilterQuery;
+}
+
+export namespace VacuumFilterQuery {
+    export type AsObject = {
+        key: string,
+        op: string,
+        value: number,
+    }
+}
+
+export class ReconsolidationRequest extends jspb.Message { 
+    getCollection(): string;
+    setCollection(value: string): ReconsolidationRequest;
+    clearTargetVectorList(): void;
+    getTargetVectorList(): Array<number>;
+    setTargetVectorList(value: Array<number>): ReconsolidationRequest;
+    addTargetVector(value: number, index?: number): number;
+    getLearningRate(): number;
+    setLearningRate(value: number): ReconsolidationRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ReconsolidationRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: ReconsolidationRequest): ReconsolidationRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ReconsolidationRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ReconsolidationRequest;
+    static deserializeBinaryFromReader(message: ReconsolidationRequest, reader: jspb.BinaryReader): ReconsolidationRequest;
+}
+
+export namespace ReconsolidationRequest {
+    export type AsObject = {
+        collection: string,
+        targetVectorList: Array<number>,
+        learningRate: number,
+    }
+}
+
+export class InsertRequest extends jspb.Message { 
+    getCollection(): string;
+    setCollection(value: string): InsertRequest;
+    clearVectorList(): void;
+    getVectorList(): Array<number>;
+    setVectorList(value: Array<number>): InsertRequest;
+    addVector(value: number, index?: number): number;
+    getId(): number;
+    setId(value: number): InsertRequest;
+
+    getMetadataMap(): jspb.Map<string, string>;
+    clearMetadataMap(): void;
+    getOriginNodeId(): string;
+    setOriginNodeId(value: string): InsertRequest;
+    getLogicalClock(): number;
+    setLogicalClock(value: number): InsertRequest;
+    getDurability(): DurabilityLevel;
+    setDurability(value: DurabilityLevel): InsertRequest;
+
+    getTypedMetadataMap(): jspb.Map<string, MetadataValue>;
+    clearTypedMetadataMap(): void;
+
+    hasPayload(): boolean;
+    clearPayload(): void;
+    getPayload(): Uint8Array | string;
+    getPayload_asU8(): Uint8Array;
+    getPayload_asB64(): string;
+    setPayload(value: Uint8Array | string): InsertRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): InsertRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: InsertRequest): InsertRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: InsertRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): InsertRequest;
+    static deserializeBinaryFromReader(message: InsertRequest, reader: jspb.BinaryReader): InsertRequest;
+}
+
+export namespace InsertRequest {
+    export type AsObject = {
+        collection: string,
+        vectorList: Array<number>,
+        id: number,
+
+        metadataMap: Array<[string, string]>,
+        originNodeId: string,
+        logicalClock: number,
+        durability: DurabilityLevel,
+
+        typedMetadataMap: Array<[string, MetadataValue.AsObject]>,
+        payload: Uint8Array | string,
+    }
+}
+
+export class VectorData extends jspb.Message { 
+    clearVectorList(): void;
+    getVectorList(): Array<number>;
+    setVectorList(value: Array<number>): VectorData;
+    addVector(value: number, index?: number): number;
+    getId(): number;
+    setId(value: number): VectorData;
+
+    getMetadataMap(): jspb.Map<string, string>;
+    clearMetadataMap(): void;
+
+    getTypedMetadataMap(): jspb.Map<string, MetadataValue>;
+    clearTypedMetadataMap(): void;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): VectorData.AsObject;
+    static toObject(includeInstance: boolean, msg: VectorData): VectorData.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: VectorData, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): VectorData;
+    static deserializeBinaryFromReader(message: VectorData, reader: jspb.BinaryReader): VectorData;
+}
+
+export namespace VectorData {
+    export type AsObject = {
+        vectorList: Array<number>,
+        id: number,
+
+        metadataMap: Array<[string, string]>,
+
+        typedMetadataMap: Array<[string, MetadataValue.AsObject]>,
+    }
+}
+
+export class BatchInsertRequest extends jspb.Message { 
+    getCollection(): string;
+    setCollection(value: string): BatchInsertRequest;
+    clearVectorsList(): void;
+    getVectorsList(): Array<VectorData>;
+    setVectorsList(value: Array<VectorData>): BatchInsertRequest;
+    addVectors(value?: VectorData, index?: number): VectorData;
+    getOriginNodeId(): string;
+    setOriginNodeId(value: string): BatchInsertRequest;
+    getLogicalClock(): number;
+    setLogicalClock(value: number): BatchInsertRequest;
+    getDurability(): DurabilityLevel;
+    setDurability(value: DurabilityLevel): BatchInsertRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): BatchInsertRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: BatchInsertRequest): BatchInsertRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: BatchInsertRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): BatchInsertRequest;
+    static deserializeBinaryFromReader(message: BatchInsertRequest, reader: jspb.BinaryReader): BatchInsertRequest;
+}
+
+export namespace BatchInsertRequest {
+    export type AsObject = {
+        collection: string,
+        vectorsList: Array<VectorData.AsObject>,
+        originNodeId: string,
+        logicalClock: number,
+        durability: DurabilityLevel,
+    }
+}
+
+export class InsertTextRequest extends jspb.Message { 
+    getCollection(): string;
+    setCollection(value: string): InsertTextRequest;
+    getId(): number;
+    setId(value: number): InsertTextRequest;
+    getText(): string;
+    setText(value: string): InsertTextRequest;
+
+    getMetadataMap(): jspb.Map<string, string>;
+    clearMetadataMap(): void;
+    getDurability(): DurabilityLevel;
+    setDurability(value: DurabilityLevel): InsertTextRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): InsertTextRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: InsertTextRequest): InsertTextRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: InsertTextRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): InsertTextRequest;
+    static deserializeBinaryFromReader(message: InsertTextRequest, reader: jspb.BinaryReader): InsertTextRequest;
+}
+
+export namespace InsertTextRequest {
+    export type AsObject = {
+        collection: string,
+        id: number,
+        text: string,
+
+        metadataMap: Array<[string, string]>,
+        durability: DurabilityLevel,
+    }
+}
+
+export class VectorizeRequest extends jspb.Message { 
+    getText(): string;
+    setText(value: string): VectorizeRequest;
+    getMetric(): string;
+    setMetric(value: string): VectorizeRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): VectorizeRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: VectorizeRequest): VectorizeRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: VectorizeRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): VectorizeRequest;
+    static deserializeBinaryFromReader(message: VectorizeRequest, reader: jspb.BinaryReader): VectorizeRequest;
+}
+
+export namespace VectorizeRequest {
+    export type AsObject = {
+        text: string,
+        metric: string,
+    }
+}
+
+export class VectorizeResponse extends jspb.Message { 
+    clearVectorList(): void;
+    getVectorList(): Array<number>;
+    setVectorList(value: Array<number>): VectorizeResponse;
+    addVector(value: number, index?: number): number;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): VectorizeResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: VectorizeResponse): VectorizeResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: VectorizeResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): VectorizeResponse;
+    static deserializeBinaryFromReader(message: VectorizeResponse, reader: jspb.BinaryReader): VectorizeResponse;
+}
+
+export namespace VectorizeResponse {
+    export type AsObject = {
+        vectorList: Array<number>,
+    }
+}
+
+export class SearchTextRequest extends jspb.Message { 
+    getCollection(): string;
+    setCollection(value: string): SearchTextRequest;
+    getText(): string;
+    setText(value: string): SearchTextRequest;
+    getTopK(): number;
+    setTopK(value: number): SearchTextRequest;
+
+    getFilterMap(): jspb.Map<string, string>;
+    clearFilterMap(): void;
+    clearFiltersList(): void;
+    getFiltersList(): Array<Filter>;
+    setFiltersList(value: Array<Filter>): SearchTextRequest;
+    addFilters(value?: Filter, index?: number): Filter;
+
+    hasBm25Options(): boolean;
+    clearBm25Options(): void;
+    getBm25Options(): Bm25Options | undefined;
+    setBm25Options(value?: Bm25Options): SearchTextRequest;
+
+    hasHybridAlpha(): boolean;
+    clearHybridAlpha(): void;
+    getHybridAlpha(): number | undefined;
+    setHybridAlpha(value: number): SearchTextRequest;
+    getIncludePayload(): boolean;
+    setIncludePayload(value: boolean): SearchTextRequest;
+
+    getComponentWeightsMap(): jspb.Map<string, number>;
+    clearComponentWeightsMap(): void;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): SearchTextRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: SearchTextRequest): SearchTextRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: SearchTextRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): SearchTextRequest;
+    static deserializeBinaryFromReader(message: SearchTextRequest, reader: jspb.BinaryReader): SearchTextRequest;
+}
+
+export namespace SearchTextRequest {
+    export type AsObject = {
+        collection: string,
+        text: string,
+        topK: number,
+
+        filterMap: Array<[string, string]>,
+        filtersList: Array<Filter.AsObject>,
+        bm25Options?: Bm25Options.AsObject,
+        hybridAlpha?: number,
+        includePayload: boolean,
+
+        componentWeightsMap: Array<[string, number]>,
+    }
+}
+
+export class Bm25Options extends jspb.Message { 
+
+    hasMethod(): boolean;
+    clearMethod(): void;
+    getMethod(): string | undefined;
+    setMethod(value: string): Bm25Options;
+
+    hasK1(): boolean;
+    clearK1(): void;
+    getK1(): number | undefined;
+    setK1(value: number): Bm25Options;
+
+    hasB(): boolean;
+    clearB(): void;
+    getB(): number | undefined;
+    setB(value: number): Bm25Options;
+
+    hasDelta(): boolean;
+    clearDelta(): void;
+    getDelta(): number | undefined;
+    setDelta(value: number): Bm25Options;
+
+    hasLanguage(): boolean;
+    clearLanguage(): void;
+    getLanguage(): string | undefined;
+    setLanguage(value: string): Bm25Options;
+
+    hasNgrams(): boolean;
+    clearNgrams(): void;
+    getNgrams(): number | undefined;
+    setNgrams(value: number): Bm25Options;
+
+    hasFusionMethod(): boolean;
+    clearFusionMethod(): void;
+    getFusionMethod(): string | undefined;
+    setFusionMethod(value: string): Bm25Options;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Bm25Options.AsObject;
+    static toObject(includeInstance: boolean, msg: Bm25Options): Bm25Options.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: Bm25Options, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Bm25Options;
+    static deserializeBinaryFromReader(message: Bm25Options, reader: jspb.BinaryReader): Bm25Options;
+}
+
+export namespace Bm25Options {
+    export type AsObject = {
+        method?: string,
+        k1?: number,
+        b?: number,
+        delta?: number,
+        language?: string,
+        ngrams?: number,
+        fusionMethod?: string,
+    }
+}
+
+export class InsertResponse extends jspb.Message { 
+    getSuccess(): boolean;
+    setSuccess(value: boolean): InsertResponse;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): InsertResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: InsertResponse): InsertResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: InsertResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): InsertResponse;
+    static deserializeBinaryFromReader(message: InsertResponse, reader: jspb.BinaryReader): InsertResponse;
+}
+
+export namespace InsertResponse {
+    export type AsObject = {
+        success: boolean,
+    }
+}
+
+export class DeleteRequest extends jspb.Message { 
+    getCollection(): string;
+    setCollection(value: string): DeleteRequest;
+    getId(): number;
+    setId(value: number): DeleteRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): DeleteRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: DeleteRequest): DeleteRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: DeleteRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): DeleteRequest;
+    static deserializeBinaryFromReader(message: DeleteRequest, reader: jspb.BinaryReader): DeleteRequest;
+}
+
+export namespace DeleteRequest {
+    export type AsObject = {
+        collection: string,
+        id: number,
+    }
+}
+
+export class DeleteResponse extends jspb.Message { 
+    getSuccess(): boolean;
+    setSuccess(value: boolean): DeleteResponse;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): DeleteResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: DeleteResponse): DeleteResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: DeleteResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): DeleteResponse;
+    static deserializeBinaryFromReader(message: DeleteResponse, reader: jspb.BinaryReader): DeleteResponse;
+}
+
+export namespace DeleteResponse {
+    export type AsObject = {
+        success: boolean,
+    }
+}
+
+export class GetPointsRequest extends jspb.Message { 
+    getCollection(): string;
+    setCollection(value: string): GetPointsRequest;
+    clearIdsList(): void;
+    getIdsList(): Array<number>;
+    setIdsList(value: Array<number>): GetPointsRequest;
+    addIds(value: number, index?: number): number;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetPointsRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: GetPointsRequest): GetPointsRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetPointsRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetPointsRequest;
+    static deserializeBinaryFromReader(message: GetPointsRequest, reader: jspb.BinaryReader): GetPointsRequest;
+}
+
+export namespace GetPointsRequest {
+    export type AsObject = {
+        collection: string,
+        idsList: Array<number>,
+    }
+}
+
+export class GetPointsResponse extends jspb.Message { 
+    clearPointsList(): void;
+    getPointsList(): Array<VectorData>;
+    setPointsList(value: Array<VectorData>): GetPointsResponse;
+    addPoints(value?: VectorData, index?: number): VectorData;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetPointsResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: GetPointsResponse): GetPointsResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetPointsResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetPointsResponse;
+    static deserializeBinaryFromReader(message: GetPointsResponse, reader: jspb.BinaryReader): GetPointsResponse;
+}
+
+export namespace GetPointsResponse {
+    export type AsObject = {
+        pointsList: Array<VectorData.AsObject>,
+    }
+}
+
+export class UpdatePayloadRequest extends jspb.Message { 
+    getCollection(): string;
+    setCollection(value: string): UpdatePayloadRequest;
+    getId(): number;
+    setId(value: number): UpdatePayloadRequest;
+
+    getMetadataMap(): jspb.Map<string, string>;
+    clearMetadataMap(): void;
+
+    getTypedMetadataMap(): jspb.Map<string, MetadataValue>;
+    clearTypedMetadataMap(): void;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): UpdatePayloadRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: UpdatePayloadRequest): UpdatePayloadRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: UpdatePayloadRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): UpdatePayloadRequest;
+    static deserializeBinaryFromReader(message: UpdatePayloadRequest, reader: jspb.BinaryReader): UpdatePayloadRequest;
+}
+
+export namespace UpdatePayloadRequest {
+    export type AsObject = {
+        collection: string,
+        id: number,
+
+        metadataMap: Array<[string, string]>,
+
+        typedMetadataMap: Array<[string, MetadataValue.AsObject]>,
+    }
+}
+
+export class ScrollRequest extends jspb.Message { 
+    getCollection(): string;
+    setCollection(value: string): ScrollRequest;
+    getLimit(): number;
+    setLimit(value: number): ScrollRequest;
+    getOffset(): number;
+    setOffset(value: number): ScrollRequest;
+    clearFiltersList(): void;
+    getFiltersList(): Array<Filter>;
+    setFiltersList(value: Array<Filter>): ScrollRequest;
+    addFilters(value?: Filter, index?: number): Filter;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ScrollRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: ScrollRequest): ScrollRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ScrollRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ScrollRequest;
+    static deserializeBinaryFromReader(message: ScrollRequest, reader: jspb.BinaryReader): ScrollRequest;
+}
+
+export namespace ScrollRequest {
+    export type AsObject = {
+        collection: string,
+        limit: number,
+        offset: number,
+        filtersList: Array<Filter.AsObject>,
+    }
+}
+
+export class ScrollResponse extends jspb.Message { 
+    clearPointsList(): void;
+    getPointsList(): Array<VectorData>;
+    setPointsList(value: Array<VectorData>): ScrollResponse;
+    addPoints(value?: VectorData, index?: number): VectorData;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ScrollResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: ScrollResponse): ScrollResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ScrollResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ScrollResponse;
+    static deserializeBinaryFromReader(message: ScrollResponse, reader: jspb.BinaryReader): ScrollResponse;
+}
+
+export namespace ScrollResponse {
+    export type AsObject = {
+        pointsList: Array<VectorData.AsObject>,
+    }
+}
+
+export class CountRequest extends jspb.Message { 
+    getCollection(): string;
+    setCollection(value: string): CountRequest;
+    clearFiltersList(): void;
+    getFiltersList(): Array<Filter>;
+    setFiltersList(value: Array<Filter>): CountRequest;
+    addFilters(value?: Filter, index?: number): Filter;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CountRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: CountRequest): CountRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CountRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CountRequest;
+    static deserializeBinaryFromReader(message: CountRequest, reader: jspb.BinaryReader): CountRequest;
+}
+
+export namespace CountRequest {
+    export type AsObject = {
+        collection: string,
+        filtersList: Array<Filter.AsObject>,
+    }
+}
+
+export class CountResponse extends jspb.Message { 
+    getCount(): number;
+    setCount(value: number): CountResponse;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CountResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: CountResponse): CountResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CountResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CountResponse;
+    static deserializeBinaryFromReader(message: CountResponse, reader: jspb.BinaryReader): CountResponse;
+}
+
+export namespace CountResponse {
+    export type AsObject = {
+        count: number,
+    }
+}
+
+export class HealthCheckResponse extends jspb.Message { 
+    getStatus(): string;
+    setStatus(value: string): HealthCheckResponse;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): HealthCheckResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: HealthCheckResponse): HealthCheckResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: HealthCheckResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): HealthCheckResponse;
+    static deserializeBinaryFromReader(message: HealthCheckResponse, reader: jspb.BinaryReader): HealthCheckResponse;
+}
+
+export namespace HealthCheckResponse {
+    export type AsObject = {
+        status: string,
+    }
+}
+
+export class SearchRequest extends jspb.Message { 
+    getCollection(): string;
+    setCollection(value: string): SearchRequest;
+    clearVectorList(): void;
+    getVectorList(): Array<number>;
+    setVectorList(value: Array<number>): SearchRequest;
+    addVector(value: number, index?: number): number;
+    getTopK(): number;
+    setTopK(value: number): SearchRequest;
+
+    getFilterMap(): jspb.Map<string, string>;
+    clearFilterMap(): void;
+    clearFiltersList(): void;
+    getFiltersList(): Array<Filter>;
+    setFiltersList(value: Array<Filter>): SearchRequest;
+    addFilters(value?: Filter, index?: number): Filter;
+
+    hasHybridQuery(): boolean;
+    clearHybridQuery(): void;
+    getHybridQuery(): string | undefined;
+    setHybridQuery(value: string): SearchRequest;
+
+    hasHybridAlpha(): boolean;
+    clearHybridAlpha(): void;
+    getHybridAlpha(): number | undefined;
+    setHybridAlpha(value: number): SearchRequest;
+    getUseWasserstein(): boolean;
+    setUseWasserstein(value: boolean): SearchRequest;
+
+    hasBm25Options(): boolean;
+    clearBm25Options(): void;
+    getBm25Options(): Bm25Options | undefined;
+    setBm25Options(value?: Bm25Options): SearchRequest;
+
+    hasMrlDimension(): boolean;
+    clearMrlDimension(): void;
+    getMrlDimension(): number | undefined;
+    setMrlDimension(value: number): SearchRequest;
+    getIncludePayload(): boolean;
+    setIncludePayload(value: boolean): SearchRequest;
+
+    getComponentWeightsMap(): jspb.Map<string, number>;
+    clearComponentWeightsMap(): void;
+    getUseWave(): boolean;
+    setUseWave(value: boolean): SearchRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): SearchRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: SearchRequest): SearchRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: SearchRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): SearchRequest;
+    static deserializeBinaryFromReader(message: SearchRequest, reader: jspb.BinaryReader): SearchRequest;
+}
+
+export namespace SearchRequest {
+    export type AsObject = {
+        collection: string,
+        vectorList: Array<number>,
+        topK: number,
+
+        filterMap: Array<[string, string]>,
+        filtersList: Array<Filter.AsObject>,
+        hybridQuery?: string,
+        hybridAlpha?: number,
+        useWasserstein: boolean,
+        bm25Options?: Bm25Options.AsObject,
+        mrlDimension?: number,
+        includePayload: boolean,
+
+        componentWeightsMap: Array<[string, number]>,
+        useWave: boolean,
+    }
+}
+
+export class Filter extends jspb.Message { 
+
+    hasMatch(): boolean;
+    clearMatch(): void;
+    getMatch(): Match | undefined;
+    setMatch(value?: Match): Filter;
+
+    hasRange(): boolean;
+    clearRange(): void;
+    getRange(): Range | undefined;
+    setRange(value?: Range): Filter;
+
+    hasInCone(): boolean;
+    clearInCone(): void;
+    getInCone(): InCone | undefined;
+    setInCone(value?: InCone): Filter;
+
+    hasInBox(): boolean;
+    clearInBox(): void;
+    getInBox(): InBox | undefined;
+    setInBox(value?: InBox): Filter;
+
+    hasInBall(): boolean;
+    clearInBall(): void;
+    getInBall(): InBall | undefined;
+    setInBall(value?: InBall): Filter;
+
+    hasAndOp(): boolean;
+    clearAndOp(): void;
+    getAndOp(): FilterAnd | undefined;
+    setAndOp(value?: FilterAnd): Filter;
+
+    hasOrOp(): boolean;
+    clearOrOp(): void;
+    getOrOp(): FilterOr | undefined;
+    setOrOp(value?: FilterOr): Filter;
+
+    hasNotOp(): boolean;
+    clearNotOp(): void;
+    getNotOp(): FilterNot | undefined;
+    setNotOp(value?: FilterNot): Filter;
+
+    hasPrefix(): boolean;
+    clearPrefix(): void;
+    getPrefix(): Prefix | undefined;
+    setPrefix(value?: Prefix): Filter;
+
+    getConditionCase(): Filter.ConditionCase;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Filter.AsObject;
+    static toObject(includeInstance: boolean, msg: Filter): Filter.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: Filter, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Filter;
+    static deserializeBinaryFromReader(message: Filter, reader: jspb.BinaryReader): Filter;
+}
+
+export namespace Filter {
+    export type AsObject = {
+        match?: Match.AsObject,
+        range?: Range.AsObject,
+        inCone?: InCone.AsObject,
+        inBox?: InBox.AsObject,
+        inBall?: InBall.AsObject,
+        andOp?: FilterAnd.AsObject,
+        orOp?: FilterOr.AsObject,
+        notOp?: FilterNot.AsObject,
+        prefix?: Prefix.AsObject,
+    }
+
+    export enum ConditionCase {
+        CONDITION_NOT_SET = 0,
+        MATCH = 1,
+        RANGE = 2,
+        IN_CONE = 3,
+        IN_BOX = 4,
+        IN_BALL = 5,
+        AND_OP = 6,
+        OR_OP = 7,
+        NOT_OP = 8,
+        PREFIX = 9,
+    }
+
+}
+
+export class FilterAnd extends jspb.Message { 
+    clearConditionsList(): void;
+    getConditionsList(): Array<Filter>;
+    setConditionsList(value: Array<Filter>): FilterAnd;
+    addConditions(value?: Filter, index?: number): Filter;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): FilterAnd.AsObject;
+    static toObject(includeInstance: boolean, msg: FilterAnd): FilterAnd.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: FilterAnd, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): FilterAnd;
+    static deserializeBinaryFromReader(message: FilterAnd, reader: jspb.BinaryReader): FilterAnd;
+}
+
+export namespace FilterAnd {
+    export type AsObject = {
+        conditionsList: Array<Filter.AsObject>,
+    }
+}
+
+export class FilterOr extends jspb.Message { 
+    clearConditionsList(): void;
+    getConditionsList(): Array<Filter>;
+    setConditionsList(value: Array<Filter>): FilterOr;
+    addConditions(value?: Filter, index?: number): Filter;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): FilterOr.AsObject;
+    static toObject(includeInstance: boolean, msg: FilterOr): FilterOr.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: FilterOr, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): FilterOr;
+    static deserializeBinaryFromReader(message: FilterOr, reader: jspb.BinaryReader): FilterOr;
+}
+
+export namespace FilterOr {
+    export type AsObject = {
+        conditionsList: Array<Filter.AsObject>,
+    }
+}
+
+export class FilterNot extends jspb.Message { 
+
+    hasCondition(): boolean;
+    clearCondition(): void;
+    getCondition(): Filter | undefined;
+    setCondition(value?: Filter): FilterNot;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): FilterNot.AsObject;
+    static toObject(includeInstance: boolean, msg: FilterNot): FilterNot.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: FilterNot, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): FilterNot;
+    static deserializeBinaryFromReader(message: FilterNot, reader: jspb.BinaryReader): FilterNot;
+}
+
+export namespace FilterNot {
+    export type AsObject = {
+        condition?: Filter.AsObject,
+    }
+}
+
+export class Match extends jspb.Message { 
+    getKey(): string;
+    setKey(value: string): Match;
+    getValue(): string;
+    setValue(value: string): Match;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Match.AsObject;
+    static toObject(includeInstance: boolean, msg: Match): Match.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: Match, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Match;
+    static deserializeBinaryFromReader(message: Match, reader: jspb.BinaryReader): Match;
+}
+
+export namespace Match {
+    export type AsObject = {
+        key: string,
+        value: string,
+    }
+}
+
+export class Prefix extends jspb.Message { 
+    getKey(): string;
+    setKey(value: string): Prefix;
+    getPrefix(): string;
+    setPrefix(value: string): Prefix;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Prefix.AsObject;
+    static toObject(includeInstance: boolean, msg: Prefix): Prefix.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: Prefix, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Prefix;
+    static deserializeBinaryFromReader(message: Prefix, reader: jspb.BinaryReader): Prefix;
+}
+
+export namespace Prefix {
+    export type AsObject = {
+        key: string,
+        prefix: string,
+    }
+}
+
+export class Range extends jspb.Message { 
+    getKey(): string;
+    setKey(value: string): Range;
+
+    hasGte(): boolean;
+    clearGte(): void;
+    getGte(): number | undefined;
+    setGte(value: number): Range;
+
+    hasLte(): boolean;
+    clearLte(): void;
+    getLte(): number | undefined;
+    setLte(value: number): Range;
+
+    hasGteF64(): boolean;
+    clearGteF64(): void;
+    getGteF64(): number | undefined;
+    setGteF64(value: number): Range;
+
+    hasLteF64(): boolean;
+    clearLteF64(): void;
+    getLteF64(): number | undefined;
+    setLteF64(value: number): Range;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Range.AsObject;
+    static toObject(includeInstance: boolean, msg: Range): Range.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: Range, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Range;
+    static deserializeBinaryFromReader(message: Range, reader: jspb.BinaryReader): Range;
+}
+
+export namespace Range {
+    export type AsObject = {
+        key: string,
+        gte?: number,
+        lte?: number,
+        gteF64?: number,
+        lteF64?: number,
+    }
+}
+
+export class InCone extends jspb.Message { 
+    clearAxesList(): void;
+    getAxesList(): Array<number>;
+    setAxesList(value: Array<number>): InCone;
+    addAxes(value: number, index?: number): number;
+    clearAperturesList(): void;
+    getAperturesList(): Array<number>;
+    setAperturesList(value: Array<number>): InCone;
+    addApertures(value: number, index?: number): number;
+    getCen(): number;
+    setCen(value: number): InCone;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): InCone.AsObject;
+    static toObject(includeInstance: boolean, msg: InCone): InCone.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: InCone, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): InCone;
+    static deserializeBinaryFromReader(message: InCone, reader: jspb.BinaryReader): InCone;
+}
+
+export namespace InCone {
+    export type AsObject = {
+        axesList: Array<number>,
+        aperturesList: Array<number>,
+        cen: number,
+    }
+}
+
+export class InBox extends jspb.Message { 
+    clearMinBoundsList(): void;
+    getMinBoundsList(): Array<number>;
+    setMinBoundsList(value: Array<number>): InBox;
+    addMinBounds(value: number, index?: number): number;
+    clearMaxBoundsList(): void;
+    getMaxBoundsList(): Array<number>;
+    setMaxBoundsList(value: Array<number>): InBox;
+    addMaxBounds(value: number, index?: number): number;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): InBox.AsObject;
+    static toObject(includeInstance: boolean, msg: InBox): InBox.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: InBox, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): InBox;
+    static deserializeBinaryFromReader(message: InBox, reader: jspb.BinaryReader): InBox;
+}
+
+export namespace InBox {
+    export type AsObject = {
+        minBoundsList: Array<number>,
+        maxBoundsList: Array<number>,
+    }
+}
+
+export class InBall extends jspb.Message { 
+    clearCenterList(): void;
+    getCenterList(): Array<number>;
+    setCenterList(value: Array<number>): InBall;
+    addCenter(value: number, index?: number): number;
+    getRadius(): number;
+    setRadius(value: number): InBall;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): InBall.AsObject;
+    static toObject(includeInstance: boolean, msg: InBall): InBall.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: InBall, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): InBall;
+    static deserializeBinaryFromReader(message: InBall, reader: jspb.BinaryReader): InBall;
+}
+
+export namespace InBall {
+    export type AsObject = {
+        centerList: Array<number>,
+        radius: number,
+    }
+}
+
+export class SearchResponse extends jspb.Message { 
+    clearResultsList(): void;
+    getResultsList(): Array<SearchResult>;
+    setResultsList(value: Array<SearchResult>): SearchResponse;
+    addResults(value?: SearchResult, index?: number): SearchResult;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): SearchResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: SearchResponse): SearchResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: SearchResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): SearchResponse;
+    static deserializeBinaryFromReader(message: SearchResponse, reader: jspb.BinaryReader): SearchResponse;
+}
+
+export namespace SearchResponse {
+    export type AsObject = {
+        resultsList: Array<SearchResult.AsObject>,
+    }
+}
+
+export class BatchSearchRequest extends jspb.Message { 
+    clearSearchesList(): void;
+    getSearchesList(): Array<SearchRequest>;
+    setSearchesList(value: Array<SearchRequest>): BatchSearchRequest;
+    addSearches(value?: SearchRequest, index?: number): SearchRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): BatchSearchRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: BatchSearchRequest): BatchSearchRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: BatchSearchRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): BatchSearchRequest;
+    static deserializeBinaryFromReader(message: BatchSearchRequest, reader: jspb.BinaryReader): BatchSearchRequest;
+}
+
+export namespace BatchSearchRequest {
+    export type AsObject = {
+        searchesList: Array<SearchRequest.AsObject>,
+    }
+}
+
+export class BatchSearchResponse extends jspb.Message { 
+    clearResponsesList(): void;
+    getResponsesList(): Array<SearchResponse>;
+    setResponsesList(value: Array<SearchResponse>): BatchSearchResponse;
+    addResponses(value?: SearchResponse, index?: number): SearchResponse;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): BatchSearchResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: BatchSearchResponse): BatchSearchResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: BatchSearchResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): BatchSearchResponse;
+    static deserializeBinaryFromReader(message: BatchSearchResponse, reader: jspb.BinaryReader): BatchSearchResponse;
+}
+
+export namespace BatchSearchResponse {
+    export type AsObject = {
+        responsesList: Array<SearchResponse.AsObject>,
+    }
+}
+
+export class SearchMultiCollectionRequest extends jspb.Message { 
+    clearCollectionsList(): void;
+    getCollectionsList(): Array<string>;
+    setCollectionsList(value: Array<string>): SearchMultiCollectionRequest;
+    addCollections(value: string, index?: number): string;
+    clearVectorList(): void;
+    getVectorList(): Array<number>;
+    setVectorList(value: Array<number>): SearchMultiCollectionRequest;
+    addVector(value: number, index?: number): number;
+    getTopK(): number;
+    setTopK(value: number): SearchMultiCollectionRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): SearchMultiCollectionRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: SearchMultiCollectionRequest): SearchMultiCollectionRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: SearchMultiCollectionRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): SearchMultiCollectionRequest;
+    static deserializeBinaryFromReader(message: SearchMultiCollectionRequest, reader: jspb.BinaryReader): SearchMultiCollectionRequest;
+}
+
+export namespace SearchMultiCollectionRequest {
+    export type AsObject = {
+        collectionsList: Array<string>,
+        vectorList: Array<number>,
+        topK: number,
+    }
+}
+
+export class SearchMultiCollectionResponse extends jspb.Message { 
+
+    getResponsesMap(): jspb.Map<string, SearchResponse>;
+    clearResponsesMap(): void;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): SearchMultiCollectionResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: SearchMultiCollectionResponse): SearchMultiCollectionResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: SearchMultiCollectionResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): SearchMultiCollectionResponse;
+    static deserializeBinaryFromReader(message: SearchMultiCollectionResponse, reader: jspb.BinaryReader): SearchMultiCollectionResponse;
+}
+
+export namespace SearchMultiCollectionResponse {
+    export type AsObject = {
+
+        responsesMap: Array<[string, SearchResponse.AsObject]>,
+    }
+}
+
+export class SearchResult extends jspb.Message { 
+    getId(): number;
+    setId(value: number): SearchResult;
+    getDistance(): number;
+    setDistance(value: number): SearchResult;
+
+    getMetadataMap(): jspb.Map<string, string>;
+    clearMetadataMap(): void;
+
+    getTypedMetadataMap(): jspb.Map<string, MetadataValue>;
+    clearTypedMetadataMap(): void;
+
+    hasPayload(): boolean;
+    clearPayload(): void;
+    getPayload(): Uint8Array | string;
+    getPayload_asU8(): Uint8Array;
+    getPayload_asB64(): string;
+    setPayload(value: Uint8Array | string): SearchResult;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): SearchResult.AsObject;
+    static toObject(includeInstance: boolean, msg: SearchResult): SearchResult.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: SearchResult, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): SearchResult;
+    static deserializeBinaryFromReader(message: SearchResult, reader: jspb.BinaryReader): SearchResult;
+}
+
+export namespace SearchResult {
+    export type AsObject = {
+        id: number,
+        distance: number,
+
+        metadataMap: Array<[string, string]>,
+
+        typedMetadataMap: Array<[string, MetadataValue.AsObject]>,
+        payload: Uint8Array | string,
+    }
+}
+
+export class GetNodeRequest extends jspb.Message { 
+    getCollection(): string;
+    setCollection(value: string): GetNodeRequest;
+    getId(): number;
+    setId(value: number): GetNodeRequest;
+    getLayer(): number;
+    setLayer(value: number): GetNodeRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetNodeRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: GetNodeRequest): GetNodeRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetNodeRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetNodeRequest;
+    static deserializeBinaryFromReader(message: GetNodeRequest, reader: jspb.BinaryReader): GetNodeRequest;
+}
+
+export namespace GetNodeRequest {
+    export type AsObject = {
+        collection: string,
+        id: number,
+        layer: number,
+    }
+}
+
+export class GraphNode extends jspb.Message { 
+    getId(): number;
+    setId(value: number): GraphNode;
+    getLayer(): number;
+    setLayer(value: number): GraphNode;
+    clearNeighborsList(): void;
+    getNeighborsList(): Array<number>;
+    setNeighborsList(value: Array<number>): GraphNode;
+    addNeighbors(value: number, index?: number): number;
+
+    getMetadataMap(): jspb.Map<string, string>;
+    clearMetadataMap(): void;
+
+    getTypedMetadataMap(): jspb.Map<string, MetadataValue>;
+    clearTypedMetadataMap(): void;
+    clearEdgeTypesList(): void;
+    getEdgeTypesList(): Array<EdgeType>;
+    setEdgeTypesList(value: Array<EdgeType>): GraphNode;
+    addEdgeTypes(value: EdgeType, index?: number): EdgeType;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GraphNode.AsObject;
+    static toObject(includeInstance: boolean, msg: GraphNode): GraphNode.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GraphNode, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GraphNode;
+    static deserializeBinaryFromReader(message: GraphNode, reader: jspb.BinaryReader): GraphNode;
+}
+
+export namespace GraphNode {
+    export type AsObject = {
+        id: number,
+        layer: number,
+        neighborsList: Array<number>,
+
+        metadataMap: Array<[string, string]>,
+
+        typedMetadataMap: Array<[string, MetadataValue.AsObject]>,
+        edgeTypesList: Array<EdgeType>,
+    }
+}
+
+export class GetNeighborsRequest extends jspb.Message { 
+    getCollection(): string;
+    setCollection(value: string): GetNeighborsRequest;
+    getId(): number;
+    setId(value: number): GetNeighborsRequest;
+    getLayer(): number;
+    setLayer(value: number): GetNeighborsRequest;
+    getLimit(): number;
+    setLimit(value: number): GetNeighborsRequest;
+    getOffset(): number;
+    setOffset(value: number): GetNeighborsRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetNeighborsRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: GetNeighborsRequest): GetNeighborsRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetNeighborsRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetNeighborsRequest;
+    static deserializeBinaryFromReader(message: GetNeighborsRequest, reader: jspb.BinaryReader): GetNeighborsRequest;
+}
+
+export namespace GetNeighborsRequest {
+    export type AsObject = {
+        collection: string,
+        id: number,
+        layer: number,
+        limit: number,
+        offset: number,
+    }
+}
+
+export class GetNeighborsResponse extends jspb.Message { 
+    clearNeighborsList(): void;
+    getNeighborsList(): Array<GraphNode>;
+    setNeighborsList(value: Array<GraphNode>): GetNeighborsResponse;
+    addNeighbors(value?: GraphNode, index?: number): GraphNode;
+    clearEdgeWeightsList(): void;
+    getEdgeWeightsList(): Array<number>;
+    setEdgeWeightsList(value: Array<number>): GetNeighborsResponse;
+    addEdgeWeights(value: number, index?: number): number;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetNeighborsResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: GetNeighborsResponse): GetNeighborsResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetNeighborsResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetNeighborsResponse;
+    static deserializeBinaryFromReader(message: GetNeighborsResponse, reader: jspb.BinaryReader): GetNeighborsResponse;
+}
+
+export namespace GetNeighborsResponse {
+    export type AsObject = {
+        neighborsList: Array<GraphNode.AsObject>,
+        edgeWeightsList: Array<number>,
+    }
+}
+
+export class TraverseRequest extends jspb.Message { 
+    getCollection(): string;
+    setCollection(value: string): TraverseRequest;
+    getStartId(): number;
+    setStartId(value: number): TraverseRequest;
+    getMaxDepth(): number;
+    setMaxDepth(value: number): TraverseRequest;
+    getMaxNodes(): number;
+    setMaxNodes(value: number): TraverseRequest;
+    getLayer(): number;
+    setLayer(value: number): TraverseRequest;
+
+    getFilterMap(): jspb.Map<string, string>;
+    clearFilterMap(): void;
+    clearFiltersList(): void;
+    getFiltersList(): Array<Filter>;
+    setFiltersList(value: Array<Filter>): TraverseRequest;
+    addFilters(value?: Filter, index?: number): Filter;
+    getTraversalMode(): TraversalMode;
+    setTraversalMode(value: TraversalMode): TraverseRequest;
+    getBreadthLimit(): number;
+    setBreadthLimit(value: number): TraverseRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): TraverseRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: TraverseRequest): TraverseRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: TraverseRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): TraverseRequest;
+    static deserializeBinaryFromReader(message: TraverseRequest, reader: jspb.BinaryReader): TraverseRequest;
+}
+
+export namespace TraverseRequest {
+    export type AsObject = {
+        collection: string,
+        startId: number,
+        maxDepth: number,
+        maxNodes: number,
+        layer: number,
+
+        filterMap: Array<[string, string]>,
+        filtersList: Array<Filter.AsObject>,
+        traversalMode: TraversalMode,
+        breadthLimit: number,
+    }
+}
+
+export class TraverseResponse extends jspb.Message { 
+    clearNodesList(): void;
+    getNodesList(): Array<GraphNode>;
+    setNodesList(value: Array<GraphNode>): TraverseResponse;
+    addNodes(value?: GraphNode, index?: number): GraphNode;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): TraverseResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: TraverseResponse): TraverseResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: TraverseResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): TraverseResponse;
+    static deserializeBinaryFromReader(message: TraverseResponse, reader: jspb.BinaryReader): TraverseResponse;
+}
+
+export namespace TraverseResponse {
+    export type AsObject = {
+        nodesList: Array<GraphNode.AsObject>,
+    }
+}
+
+export class GetSubsumptionTreeRequest extends jspb.Message { 
+    getCollection(): string;
+    setCollection(value: string): GetSubsumptionTreeRequest;
+    getRootId(): number;
+    setRootId(value: number): GetSubsumptionTreeRequest;
+    getMaxDepth(): number;
+    setMaxDepth(value: number): GetSubsumptionTreeRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetSubsumptionTreeRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: GetSubsumptionTreeRequest): GetSubsumptionTreeRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetSubsumptionTreeRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetSubsumptionTreeRequest;
+    static deserializeBinaryFromReader(message: GetSubsumptionTreeRequest, reader: jspb.BinaryReader): GetSubsumptionTreeRequest;
+}
+
+export namespace GetSubsumptionTreeRequest {
+    export type AsObject = {
+        collection: string,
+        rootId: number,
+        maxDepth: number,
+    }
+}
+
+export class GetSubsumptionTreeResponse extends jspb.Message { 
+    clearNodesList(): void;
+    getNodesList(): Array<GraphNode>;
+    setNodesList(value: Array<GraphNode>): GetSubsumptionTreeResponse;
+    addNodes(value?: GraphNode, index?: number): GraphNode;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetSubsumptionTreeResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: GetSubsumptionTreeResponse): GetSubsumptionTreeResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetSubsumptionTreeResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetSubsumptionTreeResponse;
+    static deserializeBinaryFromReader(message: GetSubsumptionTreeResponse, reader: jspb.BinaryReader): GetSubsumptionTreeResponse;
+}
+
+export namespace GetSubsumptionTreeResponse {
+    export type AsObject = {
+        nodesList: Array<GraphNode.AsObject>,
+    }
+}
+
+export class FindSemanticClustersRequest extends jspb.Message { 
+    getCollection(): string;
+    setCollection(value: string): FindSemanticClustersRequest;
+    getLayer(): number;
+    setLayer(value: number): FindSemanticClustersRequest;
+    getMinClusterSize(): number;
+    setMinClusterSize(value: number): FindSemanticClustersRequest;
+    getMaxClusters(): number;
+    setMaxClusters(value: number): FindSemanticClustersRequest;
+    getMaxNodes(): number;
+    setMaxNodes(value: number): FindSemanticClustersRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): FindSemanticClustersRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: FindSemanticClustersRequest): FindSemanticClustersRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: FindSemanticClustersRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): FindSemanticClustersRequest;
+    static deserializeBinaryFromReader(message: FindSemanticClustersRequest, reader: jspb.BinaryReader): FindSemanticClustersRequest;
+}
+
+export namespace FindSemanticClustersRequest {
+    export type AsObject = {
+        collection: string,
+        layer: number,
+        minClusterSize: number,
+        maxClusters: number,
+        maxNodes: number,
+    }
+}
+
+export class GetConceptParentsRequest extends jspb.Message { 
+    getCollection(): string;
+    setCollection(value: string): GetConceptParentsRequest;
+    getId(): number;
+    setId(value: number): GetConceptParentsRequest;
+    getLayer(): number;
+    setLayer(value: number): GetConceptParentsRequest;
+    getLimit(): number;
+    setLimit(value: number): GetConceptParentsRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetConceptParentsRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: GetConceptParentsRequest): GetConceptParentsRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetConceptParentsRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetConceptParentsRequest;
+    static deserializeBinaryFromReader(message: GetConceptParentsRequest, reader: jspb.BinaryReader): GetConceptParentsRequest;
+}
+
+export namespace GetConceptParentsRequest {
+    export type AsObject = {
+        collection: string,
+        id: number,
+        layer: number,
+        limit: number,
+    }
+}
+
+export class GetConceptParentsResponse extends jspb.Message { 
+    clearParentsList(): void;
+    getParentsList(): Array<GraphNode>;
+    setParentsList(value: Array<GraphNode>): GetConceptParentsResponse;
+    addParents(value?: GraphNode, index?: number): GraphNode;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetConceptParentsResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: GetConceptParentsResponse): GetConceptParentsResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetConceptParentsResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetConceptParentsResponse;
+    static deserializeBinaryFromReader(message: GetConceptParentsResponse, reader: jspb.BinaryReader): GetConceptParentsResponse;
+}
+
+export namespace GetConceptParentsResponse {
+    export type AsObject = {
+        parentsList: Array<GraphNode.AsObject>,
+    }
+}
+
+export class GraphCluster extends jspb.Message { 
+    clearNodeIdsList(): void;
+    getNodeIdsList(): Array<number>;
+    setNodeIdsList(value: Array<number>): GraphCluster;
+    addNodeIds(value: number, index?: number): number;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GraphCluster.AsObject;
+    static toObject(includeInstance: boolean, msg: GraphCluster): GraphCluster.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GraphCluster, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GraphCluster;
+    static deserializeBinaryFromReader(message: GraphCluster, reader: jspb.BinaryReader): GraphCluster;
+}
+
+export namespace GraphCluster {
+    export type AsObject = {
+        nodeIdsList: Array<number>,
+    }
+}
+
+export class FindSemanticClustersResponse extends jspb.Message { 
+    clearClustersList(): void;
+    getClustersList(): Array<GraphCluster>;
+    setClustersList(value: Array<GraphCluster>): FindSemanticClustersResponse;
+    addClusters(value?: GraphCluster, index?: number): GraphCluster;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): FindSemanticClustersResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: FindSemanticClustersResponse): FindSemanticClustersResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: FindSemanticClustersResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): FindSemanticClustersResponse;
+    static deserializeBinaryFromReader(message: FindSemanticClustersResponse, reader: jspb.BinaryReader): FindSemanticClustersResponse;
+}
+
+export namespace FindSemanticClustersResponse {
+    export type AsObject = {
+        clustersList: Array<GraphCluster.AsObject>,
+    }
+}
+
+export class MetadataValue extends jspb.Message { 
+
+    hasStringValue(): boolean;
+    clearStringValue(): void;
+    getStringValue(): string;
+    setStringValue(value: string): MetadataValue;
+
+    hasIntValue(): boolean;
+    clearIntValue(): void;
+    getIntValue(): number;
+    setIntValue(value: number): MetadataValue;
+
+    hasDoubleValue(): boolean;
+    clearDoubleValue(): void;
+    getDoubleValue(): number;
+    setDoubleValue(value: number): MetadataValue;
+
+    hasBoolValue(): boolean;
+    clearBoolValue(): void;
+    getBoolValue(): boolean;
+    setBoolValue(value: boolean): MetadataValue;
+
+    getKindCase(): MetadataValue.KindCase;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): MetadataValue.AsObject;
+    static toObject(includeInstance: boolean, msg: MetadataValue): MetadataValue.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: MetadataValue, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): MetadataValue;
+    static deserializeBinaryFromReader(message: MetadataValue, reader: jspb.BinaryReader): MetadataValue;
+}
+
+export namespace MetadataValue {
+    export type AsObject = {
+        stringValue: string,
+        intValue: number,
+        doubleValue: number,
+        boolValue: boolean,
+    }
+
+    export enum KindCase {
+        KIND_NOT_SET = 0,
+        STRING_VALUE = 1,
+        INT_VALUE = 2,
+        DOUBLE_VALUE = 3,
+        BOOL_VALUE = 4,
+    }
+
+}
+
+export class EventSubscriptionRequest extends jspb.Message { 
+    clearTypesList(): void;
+    getTypesList(): Array<EventType>;
+    setTypesList(value: Array<EventType>): EventSubscriptionRequest;
+    addTypes(value: EventType, index?: number): EventType;
+
+    hasCollection(): boolean;
+    clearCollection(): void;
+    getCollection(): string | undefined;
+    setCollection(value: string): EventSubscriptionRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): EventSubscriptionRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: EventSubscriptionRequest): EventSubscriptionRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: EventSubscriptionRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): EventSubscriptionRequest;
+    static deserializeBinaryFromReader(message: EventSubscriptionRequest, reader: jspb.BinaryReader): EventSubscriptionRequest;
+}
+
+export namespace EventSubscriptionRequest {
+    export type AsObject = {
+        typesList: Array<EventType>,
+        collection?: string,
+    }
+}
+
+export class VectorInsertedEvent extends jspb.Message { 
+    getId(): number;
+    setId(value: number): VectorInsertedEvent;
+    getCollection(): string;
+    setCollection(value: string): VectorInsertedEvent;
+    getLogicalClock(): number;
+    setLogicalClock(value: number): VectorInsertedEvent;
+    getOriginNodeId(): string;
+    setOriginNodeId(value: string): VectorInsertedEvent;
+
+    getMetadataMap(): jspb.Map<string, string>;
+    clearMetadataMap(): void;
+
+    getTypedMetadataMap(): jspb.Map<string, MetadataValue>;
+    clearTypedMetadataMap(): void;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): VectorInsertedEvent.AsObject;
+    static toObject(includeInstance: boolean, msg: VectorInsertedEvent): VectorInsertedEvent.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: VectorInsertedEvent, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): VectorInsertedEvent;
+    static deserializeBinaryFromReader(message: VectorInsertedEvent, reader: jspb.BinaryReader): VectorInsertedEvent;
+}
+
+export namespace VectorInsertedEvent {
+    export type AsObject = {
+        id: number,
+        collection: string,
+        logicalClock: number,
+        originNodeId: string,
+
+        metadataMap: Array<[string, string]>,
+
+        typedMetadataMap: Array<[string, MetadataValue.AsObject]>,
+    }
+}
+
+export class TrajectoryStepEvent extends jspb.Message { 
+    getId(): number;
+    setId(value: number): TrajectoryStepEvent;
+    getCollection(): string;
+    setCollection(value: string): TrajectoryStepEvent;
+    getX(): number;
+    setX(value: number): TrajectoryStepEvent;
+    getY(): number;
+    setY(value: number): TrajectoryStepEvent;
+
+    getMetadataMap(): jspb.Map<string, string>;
+    clearMetadataMap(): void;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): TrajectoryStepEvent.AsObject;
+    static toObject(includeInstance: boolean, msg: TrajectoryStepEvent): TrajectoryStepEvent.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: TrajectoryStepEvent, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): TrajectoryStepEvent;
+    static deserializeBinaryFromReader(message: TrajectoryStepEvent, reader: jspb.BinaryReader): TrajectoryStepEvent;
+}
+
+export namespace TrajectoryStepEvent {
+    export type AsObject = {
+        id: number,
+        collection: string,
+        x: number,
+        y: number,
+
+        metadataMap: Array<[string, string]>,
+    }
+}
+
+export class VectorDeletedEvent extends jspb.Message { 
+    getId(): number;
+    setId(value: number): VectorDeletedEvent;
+    getCollection(): string;
+    setCollection(value: string): VectorDeletedEvent;
+    getLogicalClock(): number;
+    setLogicalClock(value: number): VectorDeletedEvent;
+    getOriginNodeId(): string;
+    setOriginNodeId(value: string): VectorDeletedEvent;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): VectorDeletedEvent.AsObject;
+    static toObject(includeInstance: boolean, msg: VectorDeletedEvent): VectorDeletedEvent.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: VectorDeletedEvent, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): VectorDeletedEvent;
+    static deserializeBinaryFromReader(message: VectorDeletedEvent, reader: jspb.BinaryReader): VectorDeletedEvent;
+}
+
+export namespace VectorDeletedEvent {
+    export type AsObject = {
+        id: number,
+        collection: string,
+        logicalClock: number,
+        originNodeId: string,
+    }
+}
+
+export class EventMessage extends jspb.Message { 
+    getType(): EventType;
+    setType(value: EventType): EventMessage;
+
+    hasVectorInserted(): boolean;
+    clearVectorInserted(): void;
+    getVectorInserted(): VectorInsertedEvent | undefined;
+    setVectorInserted(value?: VectorInsertedEvent): EventMessage;
+
+    hasVectorDeleted(): boolean;
+    clearVectorDeleted(): void;
+    getVectorDeleted(): VectorDeletedEvent | undefined;
+    setVectorDeleted(value?: VectorDeletedEvent): EventMessage;
+
+    hasTrajectoryStep(): boolean;
+    clearTrajectoryStep(): void;
+    getTrajectoryStep(): TrajectoryStepEvent | undefined;
+    setTrajectoryStep(value?: TrajectoryStepEvent): EventMessage;
+
+    getPayloadCase(): EventMessage.PayloadCase;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): EventMessage.AsObject;
+    static toObject(includeInstance: boolean, msg: EventMessage): EventMessage.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: EventMessage, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): EventMessage;
+    static deserializeBinaryFromReader(message: EventMessage, reader: jspb.BinaryReader): EventMessage;
+}
+
+export namespace EventMessage {
+    export type AsObject = {
+        type: EventType,
+        vectorInserted?: VectorInsertedEvent.AsObject,
+        vectorDeleted?: VectorDeletedEvent.AsObject,
+        trajectoryStep?: TrajectoryStepEvent.AsObject,
+    }
+
+    export enum PayloadCase {
+        PAYLOAD_NOT_SET = 0,
+        VECTOR_INSERTED = 2,
+        VECTOR_DELETED = 3,
+        TRAJECTORY_STEP = 4,
+    }
+
+}
+
+export class Empty extends jspb.Message { 
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Empty.AsObject;
+    static toObject(includeInstance: boolean, msg: Empty): Empty.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: Empty, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Empty;
+    static deserializeBinaryFromReader(message: Empty, reader: jspb.BinaryReader): Empty;
+}
+
+export namespace Empty {
+    export type AsObject = {
+    }
+}
+
+export class StatusResponse extends jspb.Message { 
+    getStatus(): string;
+    setStatus(value: string): StatusResponse;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): StatusResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: StatusResponse): StatusResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: StatusResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): StatusResponse;
+    static deserializeBinaryFromReader(message: StatusResponse, reader: jspb.BinaryReader): StatusResponse;
+}
+
+export namespace StatusResponse {
+    export type AsObject = {
+        status: string,
+    }
+}
+
+export class MonitorRequest extends jspb.Message { 
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): MonitorRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: MonitorRequest): MonitorRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: MonitorRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): MonitorRequest;
+    static deserializeBinaryFromReader(message: MonitorRequest, reader: jspb.BinaryReader): MonitorRequest;
+}
+
+export namespace MonitorRequest {
+    export type AsObject = {
+    }
+}
+
+export class SystemStats extends jspb.Message { 
+    getTotalCollections(): number;
+    setTotalCollections(value: number): SystemStats;
+    getTotalVectors(): number;
+    setTotalVectors(value: number): SystemStats;
+    getTotalMemoryMb(): number;
+    setTotalMemoryMb(value: number): SystemStats;
+    getQps(): number;
+    setQps(value: number): SystemStats;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): SystemStats.AsObject;
+    static toObject(includeInstance: boolean, msg: SystemStats): SystemStats.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: SystemStats, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): SystemStats;
+    static deserializeBinaryFromReader(message: SystemStats, reader: jspb.BinaryReader): SystemStats;
+}
+
+export namespace SystemStats {
+    export type AsObject = {
+        totalCollections: number,
+        totalVectors: number,
+        totalMemoryMb: number,
+        qps: number,
+    }
+}
+
+export class DigestRequest extends jspb.Message { 
+    getCollection(): string;
+    setCollection(value: string): DigestRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): DigestRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: DigestRequest): DigestRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: DigestRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): DigestRequest;
+    static deserializeBinaryFromReader(message: DigestRequest, reader: jspb.BinaryReader): DigestRequest;
+}
+
+export namespace DigestRequest {
+    export type AsObject = {
+        collection: string,
+    }
+}
+
+export class DigestResponse extends jspb.Message { 
+    getLogicalClock(): number;
+    setLogicalClock(value: number): DigestResponse;
+    getStateHash(): number;
+    setStateHash(value: number): DigestResponse;
+    clearBucketsList(): void;
+    getBucketsList(): Array<number>;
+    setBucketsList(value: Array<number>): DigestResponse;
+    addBuckets(value: number, index?: number): number;
+    getCount(): number;
+    setCount(value: number): DigestResponse;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): DigestResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: DigestResponse): DigestResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: DigestResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): DigestResponse;
+    static deserializeBinaryFromReader(message: DigestResponse, reader: jspb.BinaryReader): DigestResponse;
+}
+
+export namespace DigestResponse {
+    export type AsObject = {
+        logicalClock: number,
+        stateHash: number,
+        bucketsList: Array<number>,
+        count: number,
+    }
+}
+
+export class SyncHandshakeRequest extends jspb.Message { 
+    getCollection(): string;
+    setCollection(value: string): SyncHandshakeRequest;
+    clearClientBucketsList(): void;
+    getClientBucketsList(): Array<number>;
+    setClientBucketsList(value: Array<number>): SyncHandshakeRequest;
+    addClientBuckets(value: number, index?: number): number;
+    getClientLogicalClock(): number;
+    setClientLogicalClock(value: number): SyncHandshakeRequest;
+    getClientCount(): number;
+    setClientCount(value: number): SyncHandshakeRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): SyncHandshakeRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: SyncHandshakeRequest): SyncHandshakeRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: SyncHandshakeRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): SyncHandshakeRequest;
+    static deserializeBinaryFromReader(message: SyncHandshakeRequest, reader: jspb.BinaryReader): SyncHandshakeRequest;
+}
+
+export namespace SyncHandshakeRequest {
+    export type AsObject = {
+        collection: string,
+        clientBucketsList: Array<number>,
+        clientLogicalClock: number,
+        clientCount: number,
+    }
+}
+
+export class DiffBucket extends jspb.Message { 
+    getBucketIndex(): number;
+    setBucketIndex(value: number): DiffBucket;
+    getServerHash(): number;
+    setServerHash(value: number): DiffBucket;
+    getClientHash(): number;
+    setClientHash(value: number): DiffBucket;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): DiffBucket.AsObject;
+    static toObject(includeInstance: boolean, msg: DiffBucket): DiffBucket.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: DiffBucket, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): DiffBucket;
+    static deserializeBinaryFromReader(message: DiffBucket, reader: jspb.BinaryReader): DiffBucket;
+}
+
+export namespace DiffBucket {
+    export type AsObject = {
+        bucketIndex: number,
+        serverHash: number,
+        clientHash: number,
+    }
+}
+
+export class SyncHandshakeResponse extends jspb.Message { 
+    clearDiffBucketsList(): void;
+    getDiffBucketsList(): Array<DiffBucket>;
+    setDiffBucketsList(value: Array<DiffBucket>): SyncHandshakeResponse;
+    addDiffBuckets(value?: DiffBucket, index?: number): DiffBucket;
+    getServerLogicalClock(): number;
+    setServerLogicalClock(value: number): SyncHandshakeResponse;
+    getServerCount(): number;
+    setServerCount(value: number): SyncHandshakeResponse;
+    getInSync(): boolean;
+    setInSync(value: boolean): SyncHandshakeResponse;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): SyncHandshakeResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: SyncHandshakeResponse): SyncHandshakeResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: SyncHandshakeResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): SyncHandshakeResponse;
+    static deserializeBinaryFromReader(message: SyncHandshakeResponse, reader: jspb.BinaryReader): SyncHandshakeResponse;
+}
+
+export namespace SyncHandshakeResponse {
+    export type AsObject = {
+        diffBucketsList: Array<DiffBucket.AsObject>,
+        serverLogicalClock: number,
+        serverCount: number,
+        inSync: boolean,
+    }
+}
+
+export class SyncPullRequest extends jspb.Message { 
+    getCollection(): string;
+    setCollection(value: string): SyncPullRequest;
+    clearBucketIndicesList(): void;
+    getBucketIndicesList(): Array<number>;
+    setBucketIndicesList(value: Array<number>): SyncPullRequest;
+    addBucketIndices(value: number, index?: number): number;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): SyncPullRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: SyncPullRequest): SyncPullRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: SyncPullRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): SyncPullRequest;
+    static deserializeBinaryFromReader(message: SyncPullRequest, reader: jspb.BinaryReader): SyncPullRequest;
+}
+
+export namespace SyncPullRequest {
+    export type AsObject = {
+        collection: string,
+        bucketIndicesList: Array<number>,
+    }
+}
+
+export class SyncVectorData extends jspb.Message { 
+    getCollection(): string;
+    setCollection(value: string): SyncVectorData;
+    getId(): number;
+    setId(value: number): SyncVectorData;
+    clearVectorList(): void;
+    getVectorList(): Array<number>;
+    setVectorList(value: Array<number>): SyncVectorData;
+    addVector(value: number, index?: number): number;
+
+    getMetadataMap(): jspb.Map<string, string>;
+    clearMetadataMap(): void;
+    getBucketIndex(): number;
+    setBucketIndex(value: number): SyncVectorData;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): SyncVectorData.AsObject;
+    static toObject(includeInstance: boolean, msg: SyncVectorData): SyncVectorData.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: SyncVectorData, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): SyncVectorData;
+    static deserializeBinaryFromReader(message: SyncVectorData, reader: jspb.BinaryReader): SyncVectorData;
+}
+
+export namespace SyncVectorData {
+    export type AsObject = {
+        collection: string,
+        id: number,
+        vectorList: Array<number>,
+
+        metadataMap: Array<[string, string]>,
+        bucketIndex: number,
+    }
+}
+
+export class SyncPushResponse extends jspb.Message { 
+    getAccepted(): number;
+    setAccepted(value: number): SyncPushResponse;
+    getRejected(): number;
+    setRejected(value: number): SyncPushResponse;
+    getDuplicates(): number;
+    setDuplicates(value: number): SyncPushResponse;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): SyncPushResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: SyncPushResponse): SyncPushResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: SyncPushResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): SyncPushResponse;
+    static deserializeBinaryFromReader(message: SyncPushResponse, reader: jspb.BinaryReader): SyncPushResponse;
+}
+
+export namespace SyncPushResponse {
+    export type AsObject = {
+        accepted: number,
+        rejected: number,
+        duplicates: number,
+    }
+}
+
+export class FreezeCollectionRequest extends jspb.Message { 
+    getName(): string;
+    setName(value: string): FreezeCollectionRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): FreezeCollectionRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: FreezeCollectionRequest): FreezeCollectionRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: FreezeCollectionRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): FreezeCollectionRequest;
+    static deserializeBinaryFromReader(message: FreezeCollectionRequest, reader: jspb.BinaryReader): FreezeCollectionRequest;
+}
+
+export namespace FreezeCollectionRequest {
+    export type AsObject = {
+        name: string,
+    }
+}
+
+export class UnfreezeCollectionRequest extends jspb.Message { 
+    getName(): string;
+    setName(value: string): UnfreezeCollectionRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): UnfreezeCollectionRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: UnfreezeCollectionRequest): UnfreezeCollectionRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: UnfreezeCollectionRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): UnfreezeCollectionRequest;
+    static deserializeBinaryFromReader(message: UnfreezeCollectionRequest, reader: jspb.BinaryReader): UnfreezeCollectionRequest;
+}
+
+export namespace UnfreezeCollectionRequest {
+    export type AsObject = {
+        name: string,
+    }
+}
+
+export enum QuantizationMode {
+    NONE = 0,
+    SCALAR_I8 = 1,
+}
+
+export enum DurabilityLevel {
+    DEFAULT_LEVEL = 0,
+    ASYNC = 1,
+    BATCH = 2,
+    STRICT = 3,
+}
+
+export enum EdgeType {
+    UNKNOWN = 0,
+    SIMILARITY = 1,
+    HIERARCHY = 2,
+}
+
+export enum TraversalMode {
+    GREEDY = 0,
+    DIFFUSIVE = 1,
+    MOMENTUM = 2,
+}
+
+export enum EventType {
+    EVENT_UNKNOWN = 0,
+    VECTOR_INSERTED = 1,
+    VECTOR_DELETED = 2,
+    TRAJECTORY_STEP = 3,
+}