diff --git a/generated/api_grpc_pb.d.ts b/generated/api_grpc_pb.d.ts
index 00ef5af..f9b6bf0 100644
--- a/generated/api_grpc_pb.d.ts
+++ b/generated/api_grpc_pb.d.ts
@@ -1,49 +1,109 @@
 // package: api
 // file: api.proto
 
-import * as grpc from "@grpc/grpc-js";
+/* tslint:disable */
+/* eslint-disable */
+
+import * as grpc from "grpc";
 import * as api_pb from "./api_pb";
 
-export class DgraphClient extends grpc.Client {
-    public login(
-        request: api_pb.LoginRequest,
-        metadata: grpc.Metadata | null,
-        options: grpc.CallOptions | null,
-        callback: (err?: Error | null, res?: api_pb.Response) => void
-    ): void;
-
-    public alter(
-        operation: api_pb.Operation,
-        metadata: grpc.Metadata | null,
-        options: grpc.CallOptions | null,
-        callback: (err?: Error | null, res?: api_pb.Payload) => void
-    ): void;
-
-    public query(
-        request: api_pb.Request,
-        metadata: grpc.Metadata | null,
-        options: grpc.CallOptions | null,
-        callback: (err?: Error | null, res?: api_pb.Response) => void
-    ): void;
-
-    public mutate(
-        request: api_pb.Mutation,
-        metadata: grpc.Metadata | null,
-        options: grpc.CallOptions | null,
-        callback: (err?: Error | null, res?: api_pb.Response) => void
-    ): void;
-
-    public commitOrAbort(
-        request: api_pb.TxnContext,
-        metadata: grpc.Metadata | null,
-        options: grpc.CallOptions | null,
-        callback: (err?: Error | null, res?: api_pb.TxnContext) => void
-    ): void;
-
-    public checkVersion(
-        request: api_pb.Check,
-        metadata: grpc.Metadata | null,
-        options: grpc.CallOptions | null,
-        callback: (err?: Error | null, res?: api_pb.Version) => void
-    ): void;
+interface IDgraphService extends grpc.ServiceDefinition<grpc.UntypedServiceImplementation> {
+    login: IDgraphService_ILogin;
+    query: IDgraphService_IQuery;
+    alter: IDgraphService_IAlter;
+    commitOrAbort: IDgraphService_ICommitOrAbort;
+    checkVersion: IDgraphService_ICheckVersion;
+}
+
+interface IDgraphService_ILogin extends grpc.MethodDefinition<api_pb.LoginRequest, api_pb.Response> {
+    path: "/api.Dgraph/Login";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<api_pb.LoginRequest>;
+    requestDeserialize: grpc.deserialize<api_pb.LoginRequest>;
+    responseSerialize: grpc.serialize<api_pb.Response>;
+    responseDeserialize: grpc.deserialize<api_pb.Response>;
+}
+interface IDgraphService_IQuery extends grpc.MethodDefinition<api_pb.Request, api_pb.Response> {
+    path: "/api.Dgraph/Query";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<api_pb.Request>;
+    requestDeserialize: grpc.deserialize<api_pb.Request>;
+    responseSerialize: grpc.serialize<api_pb.Response>;
+    responseDeserialize: grpc.deserialize<api_pb.Response>;
+}
+interface IDgraphService_IAlter extends grpc.MethodDefinition<api_pb.Operation, api_pb.Payload> {
+    path: "/api.Dgraph/Alter";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<api_pb.Operation>;
+    requestDeserialize: grpc.deserialize<api_pb.Operation>;
+    responseSerialize: grpc.serialize<api_pb.Payload>;
+    responseDeserialize: grpc.deserialize<api_pb.Payload>;
+}
+interface IDgraphService_ICommitOrAbort extends grpc.MethodDefinition<api_pb.TxnContext, api_pb.TxnContext> {
+    path: "/api.Dgraph/CommitOrAbort";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<api_pb.TxnContext>;
+    requestDeserialize: grpc.deserialize<api_pb.TxnContext>;
+    responseSerialize: grpc.serialize<api_pb.TxnContext>;
+    responseDeserialize: grpc.deserialize<api_pb.TxnContext>;
+}
+interface IDgraphService_ICheckVersion extends grpc.MethodDefinition<api_pb.Check, api_pb.Version> {
+    path: "/api.Dgraph/CheckVersion";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<api_pb.Check>;
+    requestDeserialize: grpc.deserialize<api_pb.Check>;
+    responseSerialize: grpc.serialize<api_pb.Version>;
+    responseDeserialize: grpc.deserialize<api_pb.Version>;
+}
+
+export const DgraphService: IDgraphService;
+
+export interface IDgraphServer {
+    login: grpc.handleUnaryCall<api_pb.LoginRequest, api_pb.Response>;
+    query: grpc.handleUnaryCall<api_pb.Request, api_pb.Response>;
+    alter: grpc.handleUnaryCall<api_pb.Operation, api_pb.Payload>;
+    commitOrAbort: grpc.handleUnaryCall<api_pb.TxnContext, api_pb.TxnContext>;
+    checkVersion: grpc.handleUnaryCall<api_pb.Check, api_pb.Version>;
+}
+
+export interface IDgraphClient {
+    login(request: api_pb.LoginRequest, callback: (error: grpc.ServiceError | null, response: api_pb.Response) => void): grpc.ClientUnaryCall;
+    login(request: api_pb.LoginRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: api_pb.Response) => void): grpc.ClientUnaryCall;
+    login(request: api_pb.LoginRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: api_pb.Response) => void): grpc.ClientUnaryCall;
+    query(request: api_pb.Request, callback: (error: grpc.ServiceError | null, response: api_pb.Response) => void): grpc.ClientUnaryCall;
+    query(request: api_pb.Request, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: api_pb.Response) => void): grpc.ClientUnaryCall;
+    query(request: api_pb.Request, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: api_pb.Response) => void): grpc.ClientUnaryCall;
+    alter(request: api_pb.Operation, callback: (error: grpc.ServiceError | null, response: api_pb.Payload) => void): grpc.ClientUnaryCall;
+    alter(request: api_pb.Operation, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: api_pb.Payload) => void): grpc.ClientUnaryCall;
+    alter(request: api_pb.Operation, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: api_pb.Payload) => void): grpc.ClientUnaryCall;
+    commitOrAbort(request: api_pb.TxnContext, callback: (error: grpc.ServiceError | null, response: api_pb.TxnContext) => void): grpc.ClientUnaryCall;
+    commitOrAbort(request: api_pb.TxnContext, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: api_pb.TxnContext) => void): grpc.ClientUnaryCall;
+    commitOrAbort(request: api_pb.TxnContext, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: api_pb.TxnContext) => void): grpc.ClientUnaryCall;
+    checkVersion(request: api_pb.Check, callback: (error: grpc.ServiceError | null, response: api_pb.Version) => void): grpc.ClientUnaryCall;
+    checkVersion(request: api_pb.Check, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: api_pb.Version) => void): grpc.ClientUnaryCall;
+    checkVersion(request: api_pb.Check, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: api_pb.Version) => void): grpc.ClientUnaryCall;
+}
+
+export class DgraphClient extends grpc.Client implements IDgraphClient {
+    constructor(address: string, credentials: grpc.ChannelCredentials, options?: object);
+    public login(request: api_pb.LoginRequest, callback: (error: grpc.ServiceError | null, response: api_pb.Response) => void): grpc.ClientUnaryCall;
+    public login(request: api_pb.LoginRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: api_pb.Response) => void): grpc.ClientUnaryCall;
+    public login(request: api_pb.LoginRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: api_pb.Response) => void): grpc.ClientUnaryCall;
+    public query(request: api_pb.Request, callback: (error: grpc.ServiceError | null, response: api_pb.Response) => void): grpc.ClientUnaryCall;
+    public query(request: api_pb.Request, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: api_pb.Response) => void): grpc.ClientUnaryCall;
+    public query(request: api_pb.Request, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: api_pb.Response) => void): grpc.ClientUnaryCall;
+    public alter(request: api_pb.Operation, callback: (error: grpc.ServiceError | null, response: api_pb.Payload) => void): grpc.ClientUnaryCall;
+    public alter(request: api_pb.Operation, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: api_pb.Payload) => void): grpc.ClientUnaryCall;
+    public alter(request: api_pb.Operation, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: api_pb.Payload) => void): grpc.ClientUnaryCall;
+    public commitOrAbort(request: api_pb.TxnContext, callback: (error: grpc.ServiceError | null, response: api_pb.TxnContext) => void): grpc.ClientUnaryCall;
+    public commitOrAbort(request: api_pb.TxnContext, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: api_pb.TxnContext) => void): grpc.ClientUnaryCall;
+    public commitOrAbort(request: api_pb.TxnContext, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: api_pb.TxnContext) => void): grpc.ClientUnaryCall;
+    public checkVersion(request: api_pb.Check, callback: (error: grpc.ServiceError | null, response: api_pb.Version) => void): grpc.ClientUnaryCall;
+    public checkVersion(request: api_pb.Check, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: api_pb.Version) => void): grpc.ClientUnaryCall;
+    public checkVersion(request: api_pb.Check, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: api_pb.Version) => void): grpc.ClientUnaryCall;
 }
diff --git a/generated/api_grpc_pb.js b/generated/api_grpc_pb.js
index 83bb063..d5009c5 100644
--- a/generated/api_grpc_pb.js
+++ b/generated/api_grpc_pb.js
@@ -21,155 +21,156 @@
 // SongServerRequest. Use snake_case (underscore_separated_names) for field names – for
 // example, song_name.
 //
-"use strict";
-var grpc = require("@grpc/grpc-js");
-var api_pb = require("./api_pb.js");
+'use strict';
+var grpc = require('grpc');
+var api_pb = require('./api_pb.js');
 
 function serialize_api_Check(arg) {
-    if (!(arg instanceof api_pb.Check)) {
-        throw new Error("Expected argument of type api.Check");
-    }
-    return Buffer.from(arg.serializeBinary());
+  if (!(arg instanceof api_pb.Check)) {
+    throw new Error('Expected argument of type api.Check');
+  }
+  return Buffer.from(arg.serializeBinary());
 }
 
 function deserialize_api_Check(buffer_arg) {
-    return api_pb.Check.deserializeBinary(new Uint8Array(buffer_arg));
+  return api_pb.Check.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
 function serialize_api_LoginRequest(arg) {
-    if (!(arg instanceof api_pb.LoginRequest)) {
-        throw new Error("Expected argument of type api.LoginRequest");
-    }
-    return Buffer.from(arg.serializeBinary());
+  if (!(arg instanceof api_pb.LoginRequest)) {
+    throw new Error('Expected argument of type api.LoginRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
 }
 
 function deserialize_api_LoginRequest(buffer_arg) {
-    return api_pb.LoginRequest.deserializeBinary(new Uint8Array(buffer_arg));
+  return api_pb.LoginRequest.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
 function serialize_api_Operation(arg) {
-    if (!(arg instanceof api_pb.Operation)) {
-        throw new Error("Expected argument of type api.Operation");
-    }
-    return Buffer.from(arg.serializeBinary());
+  if (!(arg instanceof api_pb.Operation)) {
+    throw new Error('Expected argument of type api.Operation');
+  }
+  return Buffer.from(arg.serializeBinary());
 }
 
 function deserialize_api_Operation(buffer_arg) {
-    return api_pb.Operation.deserializeBinary(new Uint8Array(buffer_arg));
+  return api_pb.Operation.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
 function serialize_api_Payload(arg) {
-    if (!(arg instanceof api_pb.Payload)) {
-        throw new Error("Expected argument of type api.Payload");
-    }
-    return Buffer.from(arg.serializeBinary());
+  if (!(arg instanceof api_pb.Payload)) {
+    throw new Error('Expected argument of type api.Payload');
+  }
+  return Buffer.from(arg.serializeBinary());
 }
 
 function deserialize_api_Payload(buffer_arg) {
-    return api_pb.Payload.deserializeBinary(new Uint8Array(buffer_arg));
+  return api_pb.Payload.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
 function serialize_api_Request(arg) {
-    if (!(arg instanceof api_pb.Request)) {
-        throw new Error("Expected argument of type api.Request");
-    }
-    return Buffer.from(arg.serializeBinary());
+  if (!(arg instanceof api_pb.Request)) {
+    throw new Error('Expected argument of type api.Request');
+  }
+  return Buffer.from(arg.serializeBinary());
 }
 
 function deserialize_api_Request(buffer_arg) {
-    return api_pb.Request.deserializeBinary(new Uint8Array(buffer_arg));
+  return api_pb.Request.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
 function serialize_api_Response(arg) {
-    if (!(arg instanceof api_pb.Response)) {
-        throw new Error("Expected argument of type api.Response");
-    }
-    return Buffer.from(arg.serializeBinary());
+  if (!(arg instanceof api_pb.Response)) {
+    throw new Error('Expected argument of type api.Response');
+  }
+  return Buffer.from(arg.serializeBinary());
 }
 
 function deserialize_api_Response(buffer_arg) {
-    return api_pb.Response.deserializeBinary(new Uint8Array(buffer_arg));
+  return api_pb.Response.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
 function serialize_api_TxnContext(arg) {
-    if (!(arg instanceof api_pb.TxnContext)) {
-        throw new Error("Expected argument of type api.TxnContext");
-    }
-    return Buffer.from(arg.serializeBinary());
+  if (!(arg instanceof api_pb.TxnContext)) {
+    throw new Error('Expected argument of type api.TxnContext');
+  }
+  return Buffer.from(arg.serializeBinary());
 }
 
 function deserialize_api_TxnContext(buffer_arg) {
-    return api_pb.TxnContext.deserializeBinary(new Uint8Array(buffer_arg));
+  return api_pb.TxnContext.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
 function serialize_api_Version(arg) {
-    if (!(arg instanceof api_pb.Version)) {
-        throw new Error("Expected argument of type api.Version");
-    }
-    return Buffer.from(arg.serializeBinary());
+  if (!(arg instanceof api_pb.Version)) {
+    throw new Error('Expected argument of type api.Version');
+  }
+  return Buffer.from(arg.serializeBinary());
 }
 
 function deserialize_api_Version(buffer_arg) {
-    return api_pb.Version.deserializeBinary(new Uint8Array(buffer_arg));
+  return api_pb.Version.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
+
 // Graph response.
-var DgraphService = (exports.DgraphService = {
-    login: {
-        path: "/api.Dgraph/Login",
-        requestStream: false,
-        responseStream: false,
-        requestType: api_pb.LoginRequest,
-        responseType: api_pb.Response,
-        requestSerialize: serialize_api_LoginRequest,
-        requestDeserialize: deserialize_api_LoginRequest,
-        responseSerialize: serialize_api_Response,
-        responseDeserialize: deserialize_api_Response,
-    },
-    query: {
-        path: "/api.Dgraph/Query",
-        requestStream: false,
-        responseStream: false,
-        requestType: api_pb.Request,
-        responseType: api_pb.Response,
-        requestSerialize: serialize_api_Request,
-        requestDeserialize: deserialize_api_Request,
-        responseSerialize: serialize_api_Response,
-        responseDeserialize: deserialize_api_Response,
-    },
-    alter: {
-        path: "/api.Dgraph/Alter",
-        requestStream: false,
-        responseStream: false,
-        requestType: api_pb.Operation,
-        responseType: api_pb.Payload,
-        requestSerialize: serialize_api_Operation,
-        requestDeserialize: deserialize_api_Operation,
-        responseSerialize: serialize_api_Payload,
-        responseDeserialize: deserialize_api_Payload,
-    },
-    commitOrAbort: {
-        path: "/api.Dgraph/CommitOrAbort",
-        requestStream: false,
-        responseStream: false,
-        requestType: api_pb.TxnContext,
-        responseType: api_pb.TxnContext,
-        requestSerialize: serialize_api_TxnContext,
-        requestDeserialize: deserialize_api_TxnContext,
-        responseSerialize: serialize_api_TxnContext,
-        responseDeserialize: deserialize_api_TxnContext,
-    },
-    checkVersion: {
-        path: "/api.Dgraph/CheckVersion",
-        requestStream: false,
-        responseStream: false,
-        requestType: api_pb.Check,
-        responseType: api_pb.Version,
-        requestSerialize: serialize_api_Check,
-        requestDeserialize: deserialize_api_Check,
-        responseSerialize: serialize_api_Version,
-        responseDeserialize: deserialize_api_Version,
-    },
-});
+var DgraphService = exports.DgraphService = {
+  login: {
+    path: '/api.Dgraph/Login',
+    requestStream: false,
+    responseStream: false,
+    requestType: api_pb.LoginRequest,
+    responseType: api_pb.Response,
+    requestSerialize: serialize_api_LoginRequest,
+    requestDeserialize: deserialize_api_LoginRequest,
+    responseSerialize: serialize_api_Response,
+    responseDeserialize: deserialize_api_Response,
+  },
+  query: {
+    path: '/api.Dgraph/Query',
+    requestStream: false,
+    responseStream: false,
+    requestType: api_pb.Request,
+    responseType: api_pb.Response,
+    requestSerialize: serialize_api_Request,
+    requestDeserialize: deserialize_api_Request,
+    responseSerialize: serialize_api_Response,
+    responseDeserialize: deserialize_api_Response,
+  },
+  alter: {
+    path: '/api.Dgraph/Alter',
+    requestStream: false,
+    responseStream: false,
+    requestType: api_pb.Operation,
+    responseType: api_pb.Payload,
+    requestSerialize: serialize_api_Operation,
+    requestDeserialize: deserialize_api_Operation,
+    responseSerialize: serialize_api_Payload,
+    responseDeserialize: deserialize_api_Payload,
+  },
+  commitOrAbort: {
+    path: '/api.Dgraph/CommitOrAbort',
+    requestStream: false,
+    responseStream: false,
+    requestType: api_pb.TxnContext,
+    responseType: api_pb.TxnContext,
+    requestSerialize: serialize_api_TxnContext,
+    requestDeserialize: deserialize_api_TxnContext,
+    responseSerialize: serialize_api_TxnContext,
+    responseDeserialize: deserialize_api_TxnContext,
+  },
+  checkVersion: {
+    path: '/api.Dgraph/CheckVersion',
+    requestStream: false,
+    responseStream: false,
+    requestType: api_pb.Check,
+    responseType: api_pb.Version,
+    requestSerialize: serialize_api_Check,
+    requestDeserialize: deserialize_api_Check,
+    responseSerialize: serialize_api_Version,
+    responseDeserialize: deserialize_api_Version,
+  },
+};
 
 exports.DgraphClient = grpc.makeGenericClientConstructor(DgraphService);
diff --git a/generated/api_pb.d.ts b/generated/api_pb.d.ts
index 61542f4..08a5944 100644
--- a/generated/api_pb.d.ts
+++ b/generated/api_pb.d.ts
@@ -1,688 +1,667 @@
 // package: api
 // file: api.proto
 
-import * as jspb from "google-protobuf";
-
-export class Request extends jspb.Message {
-  getStartTs(): number;
-  setStartTs(value: number): void;
-
-  getQuery(): string;
-  setQuery(value: string): void;
-
-  getVarsMap(): jspb.Map<string, string>;
-  clearVarsMap(): void;
-  getReadOnly(): boolean;
-  setReadOnly(value: boolean): void;
-
-  getBestEffort(): boolean;
-  setBestEffort(value: boolean): void;
-
-  clearMutationsList(): void;
-  getMutationsList(): Array<Mutation>;
-  setMutationsList(value: Array<Mutation>): void;
-  addMutations(value?: Mutation, index?: number): Mutation;
-
-  getCommitNow(): boolean;
-  setCommitNow(value: boolean): void;
+/* tslint:disable */
+/* eslint-disable */
 
-  getRespFormat(): Request.RespFormatMap[keyof Request.RespFormatMap];
-  setRespFormat(value: Request.RespFormatMap[keyof Request.RespFormatMap]): void;
-
-  getHash(): string;
-  setHash(value: string): void;
+import * as jspb from "google-protobuf";
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Request.AsObject;
-  static toObject(includeInstance: boolean, msg: Request): Request.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Request, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Request;
-  static deserializeBinaryFromReader(message: Request, reader: jspb.BinaryReader): Request;
+export class Request extends jspb.Message { 
+    getStartTs(): number;
+    setStartTs(value: number): Request;
+    getQuery(): string;
+    setQuery(value: string): Request;
+
+    getVarsMap(): jspb.Map<string, string>;
+    clearVarsMap(): void;
+    getReadOnly(): boolean;
+    setReadOnly(value: boolean): Request;
+    getBestEffort(): boolean;
+    setBestEffort(value: boolean): Request;
+    clearMutationsList(): void;
+    getMutationsList(): Array<Mutation>;
+    setMutationsList(value: Array<Mutation>): Request;
+    addMutations(value?: Mutation, index?: number): Mutation;
+    getCommitNow(): boolean;
+    setCommitNow(value: boolean): Request;
+    getRespFormat(): Request.RespFormat;
+    setRespFormat(value: Request.RespFormat): Request;
+    getHash(): string;
+    setHash(value: string): Request;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Request.AsObject;
+    static toObject(includeInstance: boolean, msg: Request): Request.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: Request, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Request;
+    static deserializeBinaryFromReader(message: Request, reader: jspb.BinaryReader): Request;
 }
 
 export namespace Request {
-  export type AsObject = {
-    startTs: number,
-    query: string,
-    varsMap: Array<[string, string]>,
-    readOnly: boolean,
-    bestEffort: boolean,
-    mutationsList: Array<Mutation.AsObject>,
-    commitNow: boolean,
-    respFormat: Request.RespFormatMap[keyof Request.RespFormatMap],
-    hash: string,
-  }
-
-  export interface RespFormatMap {
-    JSON: 0;
-    RDF: 1;
-  }
-
-  export const RespFormat: RespFormatMap;
-}
-
-export class Uids extends jspb.Message {
-  clearUidsList(): void;
-  getUidsList(): Array<string>;
-  setUidsList(value: Array<string>): void;
-  addUids(value: string, index?: number): string;
-
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Uids.AsObject;
-  static toObject(includeInstance: boolean, msg: Uids): Uids.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Uids, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Uids;
-  static deserializeBinaryFromReader(message: Uids, reader: jspb.BinaryReader): Uids;
+    export type AsObject = {
+        startTs: number,
+        query: string,
+
+        varsMap: Array<[string, string]>,
+        readOnly: boolean,
+        bestEffort: boolean,
+        mutationsList: Array<Mutation.AsObject>,
+        commitNow: boolean,
+        respFormat: Request.RespFormat,
+        hash: string,
+    }
+
+    export enum RespFormat {
+    JSON = 0,
+    RDF = 1,
+    }
+
+}
+
+export class Uids extends jspb.Message { 
+    clearUidsList(): void;
+    getUidsList(): Array<string>;
+    setUidsList(value: Array<string>): Uids;
+    addUids(value: string, index?: number): string;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Uids.AsObject;
+    static toObject(includeInstance: boolean, msg: Uids): Uids.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: Uids, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Uids;
+    static deserializeBinaryFromReader(message: Uids, reader: jspb.BinaryReader): Uids;
 }
 
 export namespace Uids {
-  export type AsObject = {
-    uidsList: Array<string>,
-  }
+    export type AsObject = {
+        uidsList: Array<string>,
+    }
 }
 
-export class ListOfString extends jspb.Message {
-  clearValueList(): void;
-  getValueList(): Array<string>;
-  setValueList(value: Array<string>): void;
-  addValue(value: string, index?: number): string;
+export class ListOfString extends jspb.Message { 
+    clearValueList(): void;
+    getValueList(): Array<string>;
+    setValueList(value: Array<string>): ListOfString;
+    addValue(value: string, index?: number): string;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): ListOfString.AsObject;
-  static toObject(includeInstance: boolean, msg: ListOfString): ListOfString.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: ListOfString, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): ListOfString;
-  static deserializeBinaryFromReader(message: ListOfString, reader: jspb.BinaryReader): ListOfString;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ListOfString.AsObject;
+    static toObject(includeInstance: boolean, msg: ListOfString): ListOfString.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ListOfString, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ListOfString;
+    static deserializeBinaryFromReader(message: ListOfString, reader: jspb.BinaryReader): ListOfString;
 }
 
 export namespace ListOfString {
-  export type AsObject = {
-    valueList: Array<string>,
-  }
-}
-
-export class Response extends jspb.Message {
-  getJson(): Uint8Array | string;
-  getJson_asU8(): Uint8Array;
-  getJson_asB64(): string;
-  setJson(value: Uint8Array | string): void;
-
-  hasTxn(): boolean;
-  clearTxn(): void;
-  getTxn(): TxnContext | undefined;
-  setTxn(value?: TxnContext): void;
-
-  hasLatency(): boolean;
-  clearLatency(): void;
-  getLatency(): Latency | undefined;
-  setLatency(value?: Latency): void;
-
-  hasMetrics(): boolean;
-  clearMetrics(): void;
-  getMetrics(): Metrics | undefined;
-  setMetrics(value?: Metrics): void;
-
-  getUidsMap(): jspb.Map<string, string>;
-  clearUidsMap(): void;
-  getRdf(): Uint8Array | string;
-  getRdf_asU8(): Uint8Array;
-  getRdf_asB64(): string;
-  setRdf(value: Uint8Array | string): void;
-
-  getHdrsMap(): jspb.Map<string, ListOfString>;
-  clearHdrsMap(): void;
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Response.AsObject;
-  static toObject(includeInstance: boolean, msg: Response): Response.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Response, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Response;
-  static deserializeBinaryFromReader(message: Response, reader: jspb.BinaryReader): Response;
+    export type AsObject = {
+        valueList: Array<string>,
+    }
+}
+
+export class Response extends jspb.Message { 
+    getJson(): Uint8Array | string;
+    getJson_asU8(): Uint8Array;
+    getJson_asB64(): string;
+    setJson(value: Uint8Array | string): Response;
+
+    hasTxn(): boolean;
+    clearTxn(): void;
+    getTxn(): TxnContext | undefined;
+    setTxn(value?: TxnContext): Response;
+
+    hasLatency(): boolean;
+    clearLatency(): void;
+    getLatency(): Latency | undefined;
+    setLatency(value?: Latency): Response;
+
+    hasMetrics(): boolean;
+    clearMetrics(): void;
+    getMetrics(): Metrics | undefined;
+    setMetrics(value?: Metrics): Response;
+
+    getUidsMap(): jspb.Map<string, string>;
+    clearUidsMap(): void;
+    getRdf(): Uint8Array | string;
+    getRdf_asU8(): Uint8Array;
+    getRdf_asB64(): string;
+    setRdf(value: Uint8Array | string): Response;
+
+    getHdrsMap(): jspb.Map<string, ListOfString>;
+    clearHdrsMap(): void;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Response.AsObject;
+    static toObject(includeInstance: boolean, msg: Response): Response.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: Response, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Response;
+    static deserializeBinaryFromReader(message: Response, reader: jspb.BinaryReader): Response;
 }
 
 export namespace Response {
-  export type AsObject = {
-    json: Uint8Array | string,
-    txn?: TxnContext.AsObject,
-    latency?: Latency.AsObject,
-    metrics?: Metrics.AsObject,
-    uidsMap: Array<[string, string]>,
-    rdf: Uint8Array | string,
-    hdrsMap: Array<[string, ListOfString.AsObject]>,
-  }
-}
-
-export class Mutation extends jspb.Message {
-  getSetJson(): Uint8Array | string;
-  getSetJson_asU8(): Uint8Array;
-  getSetJson_asB64(): string;
-  setSetJson(value: Uint8Array | string): void;
-
-  getDeleteJson(): Uint8Array | string;
-  getDeleteJson_asU8(): Uint8Array;
-  getDeleteJson_asB64(): string;
-  setDeleteJson(value: Uint8Array | string): void;
-
-  getSetNquads(): Uint8Array | string;
-  getSetNquads_asU8(): Uint8Array;
-  getSetNquads_asB64(): string;
-  setSetNquads(value: Uint8Array | string): void;
-
-  getDelNquads(): Uint8Array | string;
-  getDelNquads_asU8(): Uint8Array;
-  getDelNquads_asB64(): string;
-  setDelNquads(value: Uint8Array | string): void;
-
-  clearSetList(): void;
-  getSetList(): Array<NQuad>;
-  setSetList(value: Array<NQuad>): void;
-  addSet(value?: NQuad, index?: number): NQuad;
-
-  clearDelList(): void;
-  getDelList(): Array<NQuad>;
-  setDelList(value: Array<NQuad>): void;
-  addDel(value?: NQuad, index?: number): NQuad;
-
-  getCond(): string;
-  setCond(value: string): void;
-
-  getCommitNow(): boolean;
-  setCommitNow(value: boolean): void;
-
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Mutation.AsObject;
-  static toObject(includeInstance: boolean, msg: Mutation): Mutation.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Mutation, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Mutation;
-  static deserializeBinaryFromReader(message: Mutation, reader: jspb.BinaryReader): Mutation;
+    export type AsObject = {
+        json: Uint8Array | string,
+        txn?: TxnContext.AsObject,
+        latency?: Latency.AsObject,
+        metrics?: Metrics.AsObject,
+
+        uidsMap: Array<[string, string]>,
+        rdf: Uint8Array | string,
+
+        hdrsMap: Array<[string, ListOfString.AsObject]>,
+    }
+}
+
+export class Mutation extends jspb.Message { 
+    getSetJson(): Uint8Array | string;
+    getSetJson_asU8(): Uint8Array;
+    getSetJson_asB64(): string;
+    setSetJson(value: Uint8Array | string): Mutation;
+    getDeleteJson(): Uint8Array | string;
+    getDeleteJson_asU8(): Uint8Array;
+    getDeleteJson_asB64(): string;
+    setDeleteJson(value: Uint8Array | string): Mutation;
+    getSetNquads(): Uint8Array | string;
+    getSetNquads_asU8(): Uint8Array;
+    getSetNquads_asB64(): string;
+    setSetNquads(value: Uint8Array | string): Mutation;
+    getDelNquads(): Uint8Array | string;
+    getDelNquads_asU8(): Uint8Array;
+    getDelNquads_asB64(): string;
+    setDelNquads(value: Uint8Array | string): Mutation;
+    clearSetList(): void;
+    getSetList(): Array<NQuad>;
+    setSetList(value: Array<NQuad>): Mutation;
+    addSet(value?: NQuad, index?: number): NQuad;
+    clearDelList(): void;
+    getDelList(): Array<NQuad>;
+    setDelList(value: Array<NQuad>): Mutation;
+    addDel(value?: NQuad, index?: number): NQuad;
+    getCond(): string;
+    setCond(value: string): Mutation;
+    getCommitNow(): boolean;
+    setCommitNow(value: boolean): Mutation;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Mutation.AsObject;
+    static toObject(includeInstance: boolean, msg: Mutation): Mutation.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: Mutation, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Mutation;
+    static deserializeBinaryFromReader(message: Mutation, reader: jspb.BinaryReader): Mutation;
 }
 
 export namespace Mutation {
-  export type AsObject = {
-    setJson: Uint8Array | string,
-    deleteJson: Uint8Array | string,
-    setNquads: Uint8Array | string,
-    delNquads: Uint8Array | string,
-    setList: Array<NQuad.AsObject>,
-    delList: Array<NQuad.AsObject>,
-    cond: string,
-    commitNow: boolean,
-  }
-}
-
-export class Operation extends jspb.Message {
-  getSchema(): string;
-  setSchema(value: string): void;
-
-  getDropAttr(): string;
-  setDropAttr(value: string): void;
-
-  getDropAll(): boolean;
-  setDropAll(value: boolean): void;
-
-  getDropOp(): Operation.DropOpMap[keyof Operation.DropOpMap];
-  setDropOp(value: Operation.DropOpMap[keyof Operation.DropOpMap]): void;
-
-  getDropValue(): string;
-  setDropValue(value: string): void;
-
-  getRunInBackground(): boolean;
-  setRunInBackground(value: boolean): void;
-
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Operation.AsObject;
-  static toObject(includeInstance: boolean, msg: Operation): Operation.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Operation, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Operation;
-  static deserializeBinaryFromReader(message: Operation, reader: jspb.BinaryReader): Operation;
+    export type AsObject = {
+        setJson: Uint8Array | string,
+        deleteJson: Uint8Array | string,
+        setNquads: Uint8Array | string,
+        delNquads: Uint8Array | string,
+        setList: Array<NQuad.AsObject>,
+        delList: Array<NQuad.AsObject>,
+        cond: string,
+        commitNow: boolean,
+    }
+}
+
+export class Operation extends jspb.Message { 
+    getSchema(): string;
+    setSchema(value: string): Operation;
+    getDropAttr(): string;
+    setDropAttr(value: string): Operation;
+    getDropAll(): boolean;
+    setDropAll(value: boolean): Operation;
+    getDropOp(): Operation.DropOp;
+    setDropOp(value: Operation.DropOp): Operation;
+    getDropValue(): string;
+    setDropValue(value: string): Operation;
+    getRunInBackground(): boolean;
+    setRunInBackground(value: boolean): Operation;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Operation.AsObject;
+    static toObject(includeInstance: boolean, msg: Operation): Operation.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: Operation, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Operation;
+    static deserializeBinaryFromReader(message: Operation, reader: jspb.BinaryReader): Operation;
 }
 
 export namespace Operation {
-  export type AsObject = {
-    schema: string,
-    dropAttr: string,
-    dropAll: boolean,
-    dropOp: Operation.DropOpMap[keyof Operation.DropOpMap],
-    dropValue: string,
-    runInBackground: boolean,
-  }
-
-  export interface DropOpMap {
-    NONE: 0;
-    ALL: 1;
-    DATA: 2;
-    ATTR: 3;
-    TYPE: 4;
-  }
-
-  export const DropOp: DropOpMap;
-}
-
-export class Payload extends jspb.Message {
-  getData(): Uint8Array | string;
-  getData_asU8(): Uint8Array;
-  getData_asB64(): string;
-  setData(value: Uint8Array | string): void;
-
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Payload.AsObject;
-  static toObject(includeInstance: boolean, msg: Payload): Payload.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Payload, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Payload;
-  static deserializeBinaryFromReader(message: Payload, reader: jspb.BinaryReader): Payload;
+    export type AsObject = {
+        schema: string,
+        dropAttr: string,
+        dropAll: boolean,
+        dropOp: Operation.DropOp,
+        dropValue: string,
+        runInBackground: boolean,
+    }
+
+    export enum DropOp {
+    NONE = 0,
+    ALL = 1,
+    DATA = 2,
+    ATTR = 3,
+    TYPE = 4,
+    }
+
+}
+
+export class Payload extends jspb.Message { 
+    getData(): Uint8Array | string;
+    getData_asU8(): Uint8Array;
+    getData_asB64(): string;
+    setData(value: Uint8Array | string): Payload;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Payload.AsObject;
+    static toObject(includeInstance: boolean, msg: Payload): Payload.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: Payload, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Payload;
+    static deserializeBinaryFromReader(message: Payload, reader: jspb.BinaryReader): Payload;
 }
 
 export namespace Payload {
-  export type AsObject = {
-    data: Uint8Array | string,
-  }
+    export type AsObject = {
+        data: Uint8Array | string,
+    }
+}
+
+export class TxnContext extends jspb.Message { 
+    getStartTs(): number;
+    setStartTs(value: number): TxnContext;
+    getCommitTs(): number;
+    setCommitTs(value: number): TxnContext;
+    getAborted(): boolean;
+    setAborted(value: boolean): TxnContext;
+    clearKeysList(): void;
+    getKeysList(): Array<string>;
+    setKeysList(value: Array<string>): TxnContext;
+    addKeys(value: string, index?: number): string;
+    clearPredsList(): void;
+    getPredsList(): Array<string>;
+    setPredsList(value: Array<string>): TxnContext;
+    addPreds(value: string, index?: number): string;
+    getHash(): string;
+    setHash(value: string): TxnContext;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): TxnContext.AsObject;
+    static toObject(includeInstance: boolean, msg: TxnContext): TxnContext.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: TxnContext, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): TxnContext;
+    static deserializeBinaryFromReader(message: TxnContext, reader: jspb.BinaryReader): TxnContext;
 }
 
-export class TxnContext extends jspb.Message {
-  getStartTs(): number;
-  setStartTs(value: number): void;
-
-  getCommitTs(): number;
-  setCommitTs(value: number): void;
-
-  getAborted(): boolean;
-  setAborted(value: boolean): void;
-
-  clearKeysList(): void;
-  getKeysList(): Array<string>;
-  setKeysList(value: Array<string>): void;
-  addKeys(value: string, index?: number): string;
-
-  clearPredsList(): void;
-  getPredsList(): Array<string>;
-  setPredsList(value: Array<string>): void;
-  addPreds(value: string, index?: number): string;
-
-  getHash(): string;
-  setHash(value: string): void;
-
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): TxnContext.AsObject;
-  static toObject(includeInstance: boolean, msg: TxnContext): TxnContext.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: TxnContext, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): TxnContext;
-  static deserializeBinaryFromReader(message: TxnContext, reader: jspb.BinaryReader): TxnContext;
+export namespace TxnContext {
+    export type AsObject = {
+        startTs: number,
+        commitTs: number,
+        aborted: boolean,
+        keysList: Array<string>,
+        predsList: Array<string>,
+        hash: string,
+    }
 }
 
-export namespace TxnContext {
-  export type AsObject = {
-    startTs: number,
-    commitTs: number,
-    aborted: boolean,
-    keysList: Array<string>,
-    predsList: Array<string>,
-    hash: string,
-  }
-}
-
-export class Check extends jspb.Message {
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Check.AsObject;
-  static toObject(includeInstance: boolean, msg: Check): Check.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Check, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Check;
-  static deserializeBinaryFromReader(message: Check, reader: jspb.BinaryReader): Check;
+export class Check extends jspb.Message { 
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Check.AsObject;
+    static toObject(includeInstance: boolean, msg: Check): Check.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: Check, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Check;
+    static deserializeBinaryFromReader(message: Check, reader: jspb.BinaryReader): Check;
 }
 
 export namespace Check {
-  export type AsObject = {
-  }
+    export type AsObject = {
+    }
 }
 
-export class Version extends jspb.Message {
-  getTag(): string;
-  setTag(value: string): void;
+export class Version extends jspb.Message { 
+    getTag(): string;
+    setTag(value: string): Version;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Version.AsObject;
-  static toObject(includeInstance: boolean, msg: Version): Version.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Version, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Version;
-  static deserializeBinaryFromReader(message: Version, reader: jspb.BinaryReader): Version;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Version.AsObject;
+    static toObject(includeInstance: boolean, msg: Version): Version.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: Version, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Version;
+    static deserializeBinaryFromReader(message: Version, reader: jspb.BinaryReader): Version;
 }
 
 export namespace Version {
-  export type AsObject = {
-    tag: string,
-  }
-}
-
-export class Latency extends jspb.Message {
-  getParsingNs(): number;
-  setParsingNs(value: number): void;
-
-  getProcessingNs(): number;
-  setProcessingNs(value: number): void;
-
-  getEncodingNs(): number;
-  setEncodingNs(value: number): void;
-
-  getAssignTimestampNs(): number;
-  setAssignTimestampNs(value: number): void;
-
-  getTotalNs(): number;
-  setTotalNs(value: number): void;
-
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Latency.AsObject;
-  static toObject(includeInstance: boolean, msg: Latency): Latency.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Latency, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Latency;
-  static deserializeBinaryFromReader(message: Latency, reader: jspb.BinaryReader): Latency;
+    export type AsObject = {
+        tag: string,
+    }
+}
+
+export class Latency extends jspb.Message { 
+    getParsingNs(): number;
+    setParsingNs(value: number): Latency;
+    getProcessingNs(): number;
+    setProcessingNs(value: number): Latency;
+    getEncodingNs(): number;
+    setEncodingNs(value: number): Latency;
+    getAssignTimestampNs(): number;
+    setAssignTimestampNs(value: number): Latency;
+    getTotalNs(): number;
+    setTotalNs(value: number): Latency;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Latency.AsObject;
+    static toObject(includeInstance: boolean, msg: Latency): Latency.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: Latency, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Latency;
+    static deserializeBinaryFromReader(message: Latency, reader: jspb.BinaryReader): Latency;
 }
 
 export namespace Latency {
-  export type AsObject = {
-    parsingNs: number,
-    processingNs: number,
-    encodingNs: number,
-    assignTimestampNs: number,
-    totalNs: number,
-  }
-}
-
-export class Metrics extends jspb.Message {
-  getNumUidsMap(): jspb.Map<string, number>;
-  clearNumUidsMap(): void;
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Metrics.AsObject;
-  static toObject(includeInstance: boolean, msg: Metrics): Metrics.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Metrics, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Metrics;
-  static deserializeBinaryFromReader(message: Metrics, reader: jspb.BinaryReader): Metrics;
-}
-
-export namespace Metrics {
-  export type AsObject = {
-    numUidsMap: Array<[string, number]>,
-  }
+    export type AsObject = {
+        parsingNs: number,
+        processingNs: number,
+        encodingNs: number,
+        assignTimestampNs: number,
+        totalNs: number,
+    }
 }
 
-export class NQuad extends jspb.Message {
-  getSubject(): string;
-  setSubject(value: string): void;
-
-  getPredicate(): string;
-  setPredicate(value: string): void;
-
-  getObjectId(): string;
-  setObjectId(value: string): void;
-
-  hasObjectValue(): boolean;
-  clearObjectValue(): void;
-  getObjectValue(): Value | undefined;
-  setObjectValue(value?: Value): void;
+export class Metrics extends jspb.Message { 
 
-  getLang(): string;
-  setLang(value: string): void;
+    getNumUidsMap(): jspb.Map<string, number>;
+    clearNumUidsMap(): void;
 
-  clearFacetsList(): void;
-  getFacetsList(): Array<Facet>;
-  setFacetsList(value: Array<Facet>): void;
-  addFacets(value?: Facet, index?: number): Facet;
-
-  getNamespace(): number;
-  setNamespace(value: number): void;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Metrics.AsObject;
+    static toObject(includeInstance: boolean, msg: Metrics): Metrics.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: Metrics, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Metrics;
+    static deserializeBinaryFromReader(message: Metrics, reader: jspb.BinaryReader): Metrics;
+}
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): NQuad.AsObject;
-  static toObject(includeInstance: boolean, msg: NQuad): NQuad.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: NQuad, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): NQuad;
-  static deserializeBinaryFromReader(message: NQuad, reader: jspb.BinaryReader): NQuad;
+export namespace Metrics {
+    export type AsObject = {
+
+        numUidsMap: Array<[string, number]>,
+    }
+}
+
+export class NQuad extends jspb.Message { 
+    getSubject(): string;
+    setSubject(value: string): NQuad;
+    getPredicate(): string;
+    setPredicate(value: string): NQuad;
+    getObjectId(): string;
+    setObjectId(value: string): NQuad;
+
+    hasObjectValue(): boolean;
+    clearObjectValue(): void;
+    getObjectValue(): Value | undefined;
+    setObjectValue(value?: Value): NQuad;
+    getLang(): string;
+    setLang(value: string): NQuad;
+    clearFacetsList(): void;
+    getFacetsList(): Array<Facet>;
+    setFacetsList(value: Array<Facet>): NQuad;
+    addFacets(value?: Facet, index?: number): Facet;
+    getNamespace(): number;
+    setNamespace(value: number): NQuad;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): NQuad.AsObject;
+    static toObject(includeInstance: boolean, msg: NQuad): NQuad.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: NQuad, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): NQuad;
+    static deserializeBinaryFromReader(message: NQuad, reader: jspb.BinaryReader): NQuad;
 }
 
 export namespace NQuad {
-  export type AsObject = {
-    subject: string,
-    predicate: string,
-    objectId: string,
-    objectValue?: Value.AsObject,
-    lang: string,
-    facetsList: Array<Facet.AsObject>,
-    namespace: number,
-  }
-}
-
-export class Value extends jspb.Message {
-  hasDefaultVal(): boolean;
-  clearDefaultVal(): void;
-  getDefaultVal(): string;
-  setDefaultVal(value: string): void;
-
-  hasBytesVal(): boolean;
-  clearBytesVal(): void;
-  getBytesVal(): Uint8Array | string;
-  getBytesVal_asU8(): Uint8Array;
-  getBytesVal_asB64(): string;
-  setBytesVal(value: Uint8Array | string): void;
-
-  hasIntVal(): boolean;
-  clearIntVal(): void;
-  getIntVal(): number;
-  setIntVal(value: number): void;
-
-  hasBoolVal(): boolean;
-  clearBoolVal(): void;
-  getBoolVal(): boolean;
-  setBoolVal(value: boolean): void;
-
-  hasStrVal(): boolean;
-  clearStrVal(): void;
-  getStrVal(): string;
-  setStrVal(value: string): void;
-
-  hasDoubleVal(): boolean;
-  clearDoubleVal(): void;
-  getDoubleVal(): number;
-  setDoubleVal(value: number): void;
-
-  hasGeoVal(): boolean;
-  clearGeoVal(): void;
-  getGeoVal(): Uint8Array | string;
-  getGeoVal_asU8(): Uint8Array;
-  getGeoVal_asB64(): string;
-  setGeoVal(value: Uint8Array | string): void;
-
-  hasDateVal(): boolean;
-  clearDateVal(): void;
-  getDateVal(): Uint8Array | string;
-  getDateVal_asU8(): Uint8Array;
-  getDateVal_asB64(): string;
-  setDateVal(value: Uint8Array | string): void;
-
-  hasDatetimeVal(): boolean;
-  clearDatetimeVal(): void;
-  getDatetimeVal(): Uint8Array | string;
-  getDatetimeVal_asU8(): Uint8Array;
-  getDatetimeVal_asB64(): string;
-  setDatetimeVal(value: Uint8Array | string): void;
-
-  hasPasswordVal(): boolean;
-  clearPasswordVal(): void;
-  getPasswordVal(): string;
-  setPasswordVal(value: string): void;
-
-  hasUidVal(): boolean;
-  clearUidVal(): void;
-  getUidVal(): number;
-  setUidVal(value: number): void;
-
-  getValCase(): Value.ValCase;
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Value.AsObject;
-  static toObject(includeInstance: boolean, msg: Value): Value.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Value, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Value;
-  static deserializeBinaryFromReader(message: Value, reader: jspb.BinaryReader): Value;
+    export type AsObject = {
+        subject: string,
+        predicate: string,
+        objectId: string,
+        objectValue?: Value.AsObject,
+        lang: string,
+        facetsList: Array<Facet.AsObject>,
+        namespace: number,
+    }
+}
+
+export class Value extends jspb.Message { 
+
+    hasDefaultVal(): boolean;
+    clearDefaultVal(): void;
+    getDefaultVal(): string;
+    setDefaultVal(value: string): Value;
+
+    hasBytesVal(): boolean;
+    clearBytesVal(): void;
+    getBytesVal(): Uint8Array | string;
+    getBytesVal_asU8(): Uint8Array;
+    getBytesVal_asB64(): string;
+    setBytesVal(value: Uint8Array | string): Value;
+
+    hasIntVal(): boolean;
+    clearIntVal(): void;
+    getIntVal(): number;
+    setIntVal(value: number): Value;
+
+    hasBoolVal(): boolean;
+    clearBoolVal(): void;
+    getBoolVal(): boolean;
+    setBoolVal(value: boolean): Value;
+
+    hasStrVal(): boolean;
+    clearStrVal(): void;
+    getStrVal(): string;
+    setStrVal(value: string): Value;
+
+    hasDoubleVal(): boolean;
+    clearDoubleVal(): void;
+    getDoubleVal(): number;
+    setDoubleVal(value: number): Value;
+
+    hasGeoVal(): boolean;
+    clearGeoVal(): void;
+    getGeoVal(): Uint8Array | string;
+    getGeoVal_asU8(): Uint8Array;
+    getGeoVal_asB64(): string;
+    setGeoVal(value: Uint8Array | string): Value;
+
+    hasDateVal(): boolean;
+    clearDateVal(): void;
+    getDateVal(): Uint8Array | string;
+    getDateVal_asU8(): Uint8Array;
+    getDateVal_asB64(): string;
+    setDateVal(value: Uint8Array | string): Value;
+
+    hasDatetimeVal(): boolean;
+    clearDatetimeVal(): void;
+    getDatetimeVal(): Uint8Array | string;
+    getDatetimeVal_asU8(): Uint8Array;
+    getDatetimeVal_asB64(): string;
+    setDatetimeVal(value: Uint8Array | string): Value;
+
+    hasPasswordVal(): boolean;
+    clearPasswordVal(): void;
+    getPasswordVal(): string;
+    setPasswordVal(value: string): Value;
+
+    hasUidVal(): boolean;
+    clearUidVal(): void;
+    getUidVal(): number;
+    setUidVal(value: number): Value;
+
+    hasVfloat32Val(): boolean;
+    clearVfloat32Val(): void;
+    getVfloat32Val(): Uint8Array | string;
+    getVfloat32Val_asU8(): Uint8Array;
+    getVfloat32Val_asB64(): string;
+    setVfloat32Val(value: Uint8Array | string): Value;
+
+    getValCase(): Value.ValCase;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Value.AsObject;
+    static toObject(includeInstance: boolean, msg: Value): Value.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: Value, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Value;
+    static deserializeBinaryFromReader(message: Value, reader: jspb.BinaryReader): Value;
 }
 
 export namespace Value {
-  export type AsObject = {
-    defaultVal: string,
-    bytesVal: Uint8Array | string,
-    intVal: number,
-    boolVal: boolean,
-    strVal: string,
-    doubleVal: number,
-    geoVal: Uint8Array | string,
-    dateVal: Uint8Array | string,
-    datetimeVal: Uint8Array | string,
-    passwordVal: string,
-    uidVal: number,
-  }
-
-  export enum ValCase {
-    VAL_NOT_SET = 0,
-    DEFAULT_VAL = 1,
-    BYTES_VAL = 2,
-    INT_VAL = 3,
-    BOOL_VAL = 4,
-    STR_VAL = 5,
-    DOUBLE_VAL = 6,
-    GEO_VAL = 7,
-    DATE_VAL = 8,
-    DATETIME_VAL = 9,
-    PASSWORD_VAL = 10,
-    UID_VAL = 11,
-  }
-}
-
-export class Facet extends jspb.Message {
-  getKey(): string;
-  setKey(value: string): void;
-
-  getValue(): Uint8Array | string;
-  getValue_asU8(): Uint8Array;
-  getValue_asB64(): string;
-  setValue(value: Uint8Array | string): void;
-
-  getValType(): Facet.ValTypeMap[keyof Facet.ValTypeMap];
-  setValType(value: Facet.ValTypeMap[keyof Facet.ValTypeMap]): void;
-
-  clearTokensList(): void;
-  getTokensList(): Array<string>;
-  setTokensList(value: Array<string>): void;
-  addTokens(value: string, index?: number): string;
-
-  getAlias(): string;
-  setAlias(value: string): void;
-
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Facet.AsObject;
-  static toObject(includeInstance: boolean, msg: Facet): Facet.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Facet, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Facet;
-  static deserializeBinaryFromReader(message: Facet, reader: jspb.BinaryReader): Facet;
+    export type AsObject = {
+        defaultVal: string,
+        bytesVal: Uint8Array | string,
+        intVal: number,
+        boolVal: boolean,
+        strVal: string,
+        doubleVal: number,
+        geoVal: Uint8Array | string,
+        dateVal: Uint8Array | string,
+        datetimeVal: Uint8Array | string,
+        passwordVal: string,
+        uidVal: number,
+        vfloat32Val: Uint8Array | string,
+    }
+
+    export enum ValCase {
+        VAL_NOT_SET = 0,
+        DEFAULT_VAL = 1,
+        BYTES_VAL = 2,
+        INT_VAL = 3,
+        BOOL_VAL = 4,
+        STR_VAL = 5,
+        DOUBLE_VAL = 6,
+        GEO_VAL = 7,
+        DATE_VAL = 8,
+        DATETIME_VAL = 9,
+        PASSWORD_VAL = 10,
+        UID_VAL = 11,
+        VFLOAT32_VAL = 13,
+    }
+
+}
+
+export class Facet extends jspb.Message { 
+    getKey(): string;
+    setKey(value: string): Facet;
+    getValue(): Uint8Array | string;
+    getValue_asU8(): Uint8Array;
+    getValue_asB64(): string;
+    setValue(value: Uint8Array | string): Facet;
+    getValType(): Facet.ValType;
+    setValType(value: Facet.ValType): Facet;
+    clearTokensList(): void;
+    getTokensList(): Array<string>;
+    setTokensList(value: Array<string>): Facet;
+    addTokens(value: string, index?: number): string;
+    getAlias(): string;
+    setAlias(value: string): Facet;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Facet.AsObject;
+    static toObject(includeInstance: boolean, msg: Facet): Facet.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: Facet, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Facet;
+    static deserializeBinaryFromReader(message: Facet, reader: jspb.BinaryReader): Facet;
 }
 
 export namespace Facet {
-  export type AsObject = {
-    key: string,
-    value: Uint8Array | string,
-    valType: Facet.ValTypeMap[keyof Facet.ValTypeMap],
-    tokensList: Array<string>,
-    alias: string,
-  }
-
-  export interface ValTypeMap {
-    STRING: 0;
-    INT: 1;
-    FLOAT: 2;
-    BOOL: 3;
-    DATETIME: 4;
-  }
-
-  export const ValType: ValTypeMap;
-}
-
-export class LoginRequest extends jspb.Message {
-  getUserid(): string;
-  setUserid(value: string): void;
-
-  getPassword(): string;
-  setPassword(value: string): void;
-
-  getRefreshToken(): string;
-  setRefreshToken(value: string): void;
-
-  getNamespace(): number;
-  setNamespace(value: number): void;
-
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): LoginRequest.AsObject;
-  static toObject(includeInstance: boolean, msg: LoginRequest): LoginRequest.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: LoginRequest, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): LoginRequest;
-  static deserializeBinaryFromReader(message: LoginRequest, reader: jspb.BinaryReader): LoginRequest;
+    export type AsObject = {
+        key: string,
+        value: Uint8Array | string,
+        valType: Facet.ValType,
+        tokensList: Array<string>,
+        alias: string,
+    }
+
+    export enum ValType {
+    STRING = 0,
+    INT = 1,
+    FLOAT = 2,
+    BOOL = 3,
+    DATETIME = 4,
+    }
+
+}
+
+export class LoginRequest extends jspb.Message { 
+    getUserid(): string;
+    setUserid(value: string): LoginRequest;
+    getPassword(): string;
+    setPassword(value: string): LoginRequest;
+    getRefreshToken(): string;
+    setRefreshToken(value: string): LoginRequest;
+    getNamespace(): number;
+    setNamespace(value: number): LoginRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): LoginRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: LoginRequest): LoginRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: LoginRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): LoginRequest;
+    static deserializeBinaryFromReader(message: LoginRequest, reader: jspb.BinaryReader): LoginRequest;
 }
 
 export namespace LoginRequest {
-  export type AsObject = {
-    userid: string,
-    password: string,
-    refreshToken: string,
-    namespace: number,
-  }
-}
-
-export class Jwt extends jspb.Message {
-  getAccessJwt(): string;
-  setAccessJwt(value: string): void;
-
-  getRefreshJwt(): string;
-  setRefreshJwt(value: string): void;
-
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Jwt.AsObject;
-  static toObject(includeInstance: boolean, msg: Jwt): Jwt.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Jwt, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Jwt;
-  static deserializeBinaryFromReader(message: Jwt, reader: jspb.BinaryReader): Jwt;
+    export type AsObject = {
+        userid: string,
+        password: string,
+        refreshToken: string,
+        namespace: number,
+    }
+}
+
+export class Jwt extends jspb.Message { 
+    getAccessJwt(): string;
+    setAccessJwt(value: string): Jwt;
+    getRefreshJwt(): string;
+    setRefreshJwt(value: string): Jwt;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Jwt.AsObject;
+    static toObject(includeInstance: boolean, msg: Jwt): Jwt.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: Jwt, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Jwt;
+    static deserializeBinaryFromReader(message: Jwt, reader: jspb.BinaryReader): Jwt;
 }
 
 export namespace Jwt {
-  export type AsObject = {
-    accessJwt: string,
-    refreshJwt: string,
-  }
+    export type AsObject = {
+        accessJwt: string,
+        refreshJwt: string,
+    }
 }
-
diff --git a/generated/api_pb.js b/generated/api_pb.js
index 215162a..1e6fe60 100644
--- a/generated/api_pb.js
+++ b/generated/api_pb.js
@@ -7,8 +7,6 @@
  * @public
  */
 // GENERATED CODE -- DO NOT EDIT!
-/* eslint-disable */
-// @ts-nocheck
 
 var jspb = require('google-protobuf');
 var goog = jspb;
@@ -3785,7 +3783,7 @@ proto.api.NQuad.prototype.setNamespace = function(value) {
  * @private {!Array<!Array<number>>}
  * @const
  */
-proto.api.Value.oneofGroups_ = [[1,2,3,4,5,6,7,8,9,10,11]];
+proto.api.Value.oneofGroups_ = [[1,2,3,4,5,6,7,8,9,10,11,13]];
 
 /**
  * @enum {number}
@@ -3802,7 +3800,8 @@ proto.api.Value.ValCase = {
   DATE_VAL: 8,
   DATETIME_VAL: 9,
   PASSWORD_VAL: 10,
-  UID_VAL: 11
+  UID_VAL: 11,
+  VFLOAT32_VAL: 13
 };
 
 /**
@@ -3853,7 +3852,8 @@ proto.api.Value.toObject = function(includeInstance, msg) {
     dateVal: msg.getDateVal_asB64(),
     datetimeVal: msg.getDatetimeVal_asB64(),
     passwordVal: jspb.Message.getFieldWithDefault(msg, 10, ""),
-    uidVal: jspb.Message.getFieldWithDefault(msg, 11, 0)
+    uidVal: jspb.Message.getFieldWithDefault(msg, 11, 0),
+    vfloat32Val: msg.getVfloat32Val_asB64()
   };
 
   if (includeInstance) {
@@ -3934,6 +3934,10 @@ proto.api.Value.deserializeBinaryFromReader = function(msg, reader) {
       var value = /** @type {number} */ (reader.readUint64());
       msg.setUidVal(value);
       break;
+    case 13:
+      var value = /** @type {!Uint8Array} */ (reader.readBytes());
+      msg.setVfloat32Val(value);
+      break;
     default:
       reader.skipField();
       break;
@@ -4040,6 +4044,13 @@ proto.api.Value.serializeBinaryToWriter = function(message, writer) {
       f
     );
   }
+  f = /** @type {!(string|Uint8Array)} */ (jspb.Message.getField(message, 13));
+  if (f != null) {
+    writer.writeBytes(
+      13,
+      f
+    );
+  }
 };
 
 
@@ -4535,6 +4546,66 @@ proto.api.Value.prototype.hasUidVal = function() {
 };
 
 
+/**
+ * optional bytes vfloat32_val = 13;
+ * @return {!(string|Uint8Array)}
+ */
+proto.api.Value.prototype.getVfloat32Val = function() {
+  return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 13, ""));
+};
+
+
+/**
+ * optional bytes vfloat32_val = 13;
+ * This is a type-conversion wrapper around `getVfloat32Val()`
+ * @return {string}
+ */
+proto.api.Value.prototype.getVfloat32Val_asB64 = function() {
+  return /** @type {string} */ (jspb.Message.bytesAsB64(
+      this.getVfloat32Val()));
+};
+
+
+/**
+ * optional bytes vfloat32_val = 13;
+ * Note that Uint8Array is not supported on all browsers.
+ * @see http://caniuse.com/Uint8Array
+ * This is a type-conversion wrapper around `getVfloat32Val()`
+ * @return {!Uint8Array}
+ */
+proto.api.Value.prototype.getVfloat32Val_asU8 = function() {
+  return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
+      this.getVfloat32Val()));
+};
+
+
+/**
+ * @param {!(string|Uint8Array)} value
+ * @return {!proto.api.Value} returns this
+ */
+proto.api.Value.prototype.setVfloat32Val = function(value) {
+  return jspb.Message.setOneofField(this, 13, proto.api.Value.oneofGroups_[0], value);
+};
+
+
+/**
+ * Clears the field making it undefined.
+ * @return {!proto.api.Value} returns this
+ */
+proto.api.Value.prototype.clearVfloat32Val = function() {
+  return jspb.Message.setOneofField(this, 13, proto.api.Value.oneofGroups_[0], undefined);
+};
+
+
+/**
+ * Returns whether this field is set.
+ * @return {boolean}
+ */
+proto.api.Value.prototype.hasVfloat32Val = function() {
+  return jspb.Message.getField(this, 13) != null;
+};
+
+
 
 /**
  * List of repeated fields within this message type.
diff --git a/protos/api.proto b/protos/api.proto
index 506b1ed..7d9934a 100644
--- a/protos/api.proto
+++ b/protos/api.proto
@@ -175,6 +175,8 @@ message Value {
 		bytes datetime_val = 9;
 		string password_val = 10;
 		uint64 uid_val=11;
+		// number 12 is reserved for bigfloat
+		bytes vfloat32_val=13;
 	}
 }
 
diff --git a/tests/integration/mutate.spec.ts b/tests/integration/mutate.spec.ts
index 40cf2c2..be71e9d 100644
--- a/tests/integration/mutate.spec.ts
+++ b/tests/integration/mutate.spec.ts
@@ -40,4 +40,47 @@ describe("mutate", () => {
 
         expect(res.getJson()).toEqual({ me: [{ name: "ok 200" }, { name: "ok 300" }, { name: "ok 400" }] });
     });
+
+    it("should insert vector", async () => {
+        const client = await setup();
+        await setSchema(client, `project_discription_v: float32vector
+             @index(hnsw(exponent: "5", metric: "euclidian")) .`);
+
+        let txn = client.newTxn();
+        try {
+            const nquad = new dgraph.NQuad();
+            nquad.setSubject(`0x1011`);
+            nquad.setPredicate("project_discription_v");
+
+            const ov = new dgraph.Value();
+            const vector = new Float32Array([5.1, 5.1, 1.1]);
+            const uint8Array = new Uint8Array(vector.buffer);
+            ov.setVfloat32Val(uint8Array)
+            nquad.setObjectValue(ov);
+
+            const mu = new dgraph.Mutation();
+            mu.addSet(nquad);
+            await txn.mutate(mu);
+            await txn.commit();
+        } finally {
+            await txn.discard();
+        }
+
+        txn = client.newTxn();
+        const query = `query {  q (func: uid(0x1011)) { 
+                          uid
+                          project_discription_v
+  
+                         } 
+					} `;
+        const res = await txn.query(query);
+        await txn.commit();
+        expect(res.getJson()).toEqual({
+            q: [
+              {
+                uid: "0x1011",
+                project_discription_v: [5.1, 5.1, 1.1]
+              }
+            ]
+          });    });
 });