// package: ultipa
// file: src/proto/ultipa.proto

import * as jspb from "google-protobuf";

export class HelloUltipaRequest extends jspb.Message {
  getName(): string;
  setName(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): HelloUltipaRequest.AsObject;
  static toObject(includeInstance: boolean, msg: HelloUltipaRequest): HelloUltipaRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: HelloUltipaRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): HelloUltipaRequest;
  static deserializeBinaryFromReader(message: HelloUltipaRequest, reader: jspb.BinaryReader): HelloUltipaRequest;
}

export namespace HelloUltipaRequest {
  export type AsObject = {
    name: string,
  }
}

export class HelloUltipaReply extends jspb.Message {
  hasStatus(): boolean;
  clearStatus(): void;
  getStatus(): Status | undefined;
  setStatus(value?: Status): void;

  getMessage(): string;
  setMessage(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): HelloUltipaReply.AsObject;
  static toObject(includeInstance: boolean, msg: HelloUltipaReply): HelloUltipaReply.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: HelloUltipaReply, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): HelloUltipaReply;
  static deserializeBinaryFromReader(message: HelloUltipaReply, reader: jspb.BinaryReader): HelloUltipaReply;
}

export namespace HelloUltipaReply {
  export type AsObject = {
    status?: Status.AsObject,
    message: string,
  }
}

export class QueryRequest extends jspb.Message {
  getQueryText(): string;
  setQueryText(value: string): void;

  getQueryType(): QueryTypeMap[keyof QueryTypeMap];
  setQueryType(value: QueryTypeMap[keyof QueryTypeMap]): void;

  getTimeout(): number;
  setTimeout(value: number): void;

  getGraphName(): string;
  setGraphName(value: string): void;

  getUserName(): string;
  setUserName(value: string): void;

  getThreadNum(): number;
  setThreadNum(value: number): void;

  getTz(): string;
  setTz(value: string): void;

  getTzOffset(): string;
  setTzOffset(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): QueryRequest.AsObject;
  static toObject(includeInstance: boolean, msg: QueryRequest): QueryRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: QueryRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): QueryRequest;
  static deserializeBinaryFromReader(message: QueryRequest, reader: jspb.BinaryReader): QueryRequest;
}

export namespace QueryRequest {
  export type AsObject = {
    queryText: string,
    queryType: QueryTypeMap[keyof QueryTypeMap],
    timeout: number,
    graphName: string,
    userName: string,
    threadNum: number,
    tz: string,
    tzOffset: string,
  }
}

export class ResultAlias extends jspb.Message {
  getAlias(): string;
  setAlias(value: string): void;

  getResultType(): ResultTypeMap[keyof ResultTypeMap];
  setResultType(value: ResultTypeMap[keyof ResultTypeMap]): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ResultAlias.AsObject;
  static toObject(includeInstance: boolean, msg: ResultAlias): ResultAlias.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: ResultAlias, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ResultAlias;
  static deserializeBinaryFromReader(message: ResultAlias, reader: jspb.BinaryReader): ResultAlias;
}

export namespace ResultAlias {
  export type AsObject = {
    alias: string,
    resultType: ResultTypeMap[keyof ResultTypeMap],
  }
}

export class QueryReply extends jspb.Message {
  hasStatus(): boolean;
  clearStatus(): void;
  getStatus(): Status | undefined;
  setStatus(value?: Status): void;

  getTotalTimeCost(): number;
  setTotalTimeCost(value: number): void;

  getEngineTimeCost(): number;
  setEngineTimeCost(value: number): void;

  clearAliasList(): void;
  getAliasList(): Array<ResultAlias>;
  setAliasList(value: Array<ResultAlias>): void;
  addAlias(value?: ResultAlias, index?: number): ResultAlias;

  clearPathsList(): void;
  getPathsList(): Array<PathAlias>;
  setPathsList(value: Array<PathAlias>): void;
  addPaths(value?: PathAlias, index?: number): PathAlias;

  clearNodesList(): void;
  getNodesList(): Array<NodeAlias>;
  setNodesList(value: Array<NodeAlias>): void;
  addNodes(value?: NodeAlias, index?: number): NodeAlias;

  clearEdgesList(): void;
  getEdgesList(): Array<EdgeAlias>;
  setEdgesList(value: Array<EdgeAlias>): void;
  addEdges(value?: EdgeAlias, index?: number): EdgeAlias;

  clearAttrsList(): void;
  getAttrsList(): Array<AttrAlias>;
  setAttrsList(value: Array<AttrAlias>): void;
  addAttrs(value?: AttrAlias, index?: number): AttrAlias;

  clearTablesList(): void;
  getTablesList(): Array<Table>;
  setTablesList(value: Array<Table>): void;
  addTables(value?: Table, index?: number): Table;

  hasStatistics(): boolean;
  clearStatistics(): void;
  getStatistics(): Table | undefined;
  setStatistics(value?: Table): void;

  hasExplainPlan(): boolean;
  clearExplainPlan(): void;
  getExplainPlan(): ExplainPlan | undefined;
  setExplainPlan(value?: ExplainPlan): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): QueryReply.AsObject;
  static toObject(includeInstance: boolean, msg: QueryReply): QueryReply.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: QueryReply, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): QueryReply;
  static deserializeBinaryFromReader(message: QueryReply, reader: jspb.BinaryReader): QueryReply;
}

export namespace QueryReply {
  export type AsObject = {
    status?: Status.AsObject,
    totalTimeCost: number,
    engineTimeCost: number,
    aliasList: Array<ResultAlias.AsObject>,
    pathsList: Array<PathAlias.AsObject>,
    nodesList: Array<NodeAlias.AsObject>,
    edgesList: Array<EdgeAlias.AsObject>,
    attrsList: Array<AttrAlias.AsObject>,
    tablesList: Array<Table.AsObject>,
    statistics?: Table.AsObject,
    explainPlan?: ExplainPlan.AsObject,
  }
}

export class PathAlias extends jspb.Message {
  clearPathsList(): void;
  getPathsList(): Array<Path>;
  setPathsList(value: Array<Path>): void;
  addPaths(value?: Path, index?: number): Path;

  getAlias(): string;
  setAlias(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): PathAlias.AsObject;
  static toObject(includeInstance: boolean, msg: PathAlias): PathAlias.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: PathAlias, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): PathAlias;
  static deserializeBinaryFromReader(message: PathAlias, reader: jspb.BinaryReader): PathAlias;
}

export namespace PathAlias {
  export type AsObject = {
    pathsList: Array<Path.AsObject>,
    alias: string,
  }
}

export class EdgeAlias extends jspb.Message {
  hasEdgeTable(): boolean;
  clearEdgeTable(): void;
  getEdgeTable(): EntityTable | undefined;
  setEdgeTable(value?: EntityTable): void;

  getAlias(): string;
  setAlias(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): EdgeAlias.AsObject;
  static toObject(includeInstance: boolean, msg: EdgeAlias): EdgeAlias.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: EdgeAlias, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): EdgeAlias;
  static deserializeBinaryFromReader(message: EdgeAlias, reader: jspb.BinaryReader): EdgeAlias;
}

export namespace EdgeAlias {
  export type AsObject = {
    edgeTable?: EntityTable.AsObject,
    alias: string,
  }
}

export class NodeAlias extends jspb.Message {
  hasNodeTable(): boolean;
  clearNodeTable(): void;
  getNodeTable(): EntityTable | undefined;
  setNodeTable(value?: EntityTable): void;

  getAlias(): string;
  setAlias(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): NodeAlias.AsObject;
  static toObject(includeInstance: boolean, msg: NodeAlias): NodeAlias.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: NodeAlias, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): NodeAlias;
  static deserializeBinaryFromReader(message: NodeAlias, reader: jspb.BinaryReader): NodeAlias;
}

export namespace NodeAlias {
  export type AsObject = {
    nodeTable?: EntityTable.AsObject,
    alias: string,
  }
}

export class AttrAlias extends jspb.Message {
  getAlias(): string;
  setAlias(value: string): void;

  hasAttr(): boolean;
  clearAttr(): void;
  getAttr(): Attr | undefined;
  setAttr(value?: Attr): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): AttrAlias.AsObject;
  static toObject(includeInstance: boolean, msg: AttrAlias): AttrAlias.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: AttrAlias, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): AttrAlias;
  static deserializeBinaryFromReader(message: AttrAlias, reader: jspb.BinaryReader): AttrAlias;
}

export namespace AttrAlias {
  export type AsObject = {
    alias: string,
    attr?: Attr.AsObject,
  }
}

export class Attr extends jspb.Message {
  getValueType(): PropertyTypeMap[keyof PropertyTypeMap];
  setValueType(value: PropertyTypeMap[keyof PropertyTypeMap]): void;

  clearValuesList(): void;
  getValuesList(): Array<Uint8Array | string>;
  getValuesList_asU8(): Array<Uint8Array>;
  getValuesList_asB64(): Array<string>;
  setValuesList(value: Array<Uint8Array | string>): void;
  addValues(value: Uint8Array | string, index?: number): Uint8Array | string;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Attr.AsObject;
  static toObject(includeInstance: boolean, msg: Attr): Attr.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: Attr, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Attr;
  static deserializeBinaryFromReader(message: Attr, reader: jspb.BinaryReader): Attr;
}

export namespace Attr {
  export type AsObject = {
    valueType: PropertyTypeMap[keyof PropertyTypeMap],
    valuesList: Array<Uint8Array | string>,
  }
}

export class AttrListData extends jspb.Message {
  getType(): ResultTypeMap[keyof ResultTypeMap];
  setType(value: ResultTypeMap[keyof ResultTypeMap]): void;

  hasNodes(): boolean;
  clearNodes(): void;
  getNodes(): EntityTable | undefined;
  setNodes(value?: EntityTable): void;

  hasEdges(): boolean;
  clearEdges(): void;
  getEdges(): EntityTable | undefined;
  setEdges(value?: EntityTable): void;

  clearPathsList(): void;
  getPathsList(): Array<Path>;
  setPathsList(value: Array<Path>): void;
  addPaths(value?: Path, index?: number): Path;

  clearAttrsList(): void;
  getAttrsList(): Array<Attr>;
  setAttrsList(value: Array<Attr>): void;
  addAttrs(value?: Attr, index?: number): Attr;

  getIsNull(): boolean;
  setIsNull(value: boolean): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): AttrListData.AsObject;
  static toObject(includeInstance: boolean, msg: AttrListData): AttrListData.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: AttrListData, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): AttrListData;
  static deserializeBinaryFromReader(message: AttrListData, reader: jspb.BinaryReader): AttrListData;
}

export namespace AttrListData {
  export type AsObject = {
    type: ResultTypeMap[keyof ResultTypeMap],
    nodes?: EntityTable.AsObject,
    edges?: EntityTable.AsObject,
    pathsList: Array<Path.AsObject>,
    attrsList: Array<Attr.AsObject>,
    isNull: boolean,
  }
}

export class AttrMapData extends jspb.Message {
  hasKey(): boolean;
  clearKey(): void;
  getKey(): Attr | undefined;
  setKey(value?: Attr): void;

  hasValue(): boolean;
  clearValue(): void;
  getValue(): Attr | undefined;
  setValue(value?: Attr): void;

  getIsNull(): boolean;
  setIsNull(value: boolean): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): AttrMapData.AsObject;
  static toObject(includeInstance: boolean, msg: AttrMapData): AttrMapData.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: AttrMapData, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): AttrMapData;
  static deserializeBinaryFromReader(message: AttrMapData, reader: jspb.BinaryReader): AttrMapData;
}

export namespace AttrMapData {
  export type AsObject = {
    key?: Attr.AsObject,
    value?: Attr.AsObject,
    isNull: boolean,
  }
}

export class UserSettingRequest extends jspb.Message {
  getUserName(): string;
  setUserName(value: string): void;

  getOpt(): UserSettingRequest.OPTIONMap[keyof UserSettingRequest.OPTIONMap];
  setOpt(value: UserSettingRequest.OPTIONMap[keyof UserSettingRequest.OPTIONMap]): void;

  getType(): string;
  setType(value: string): void;

  getData(): string;
  setData(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): UserSettingRequest.AsObject;
  static toObject(includeInstance: boolean, msg: UserSettingRequest): UserSettingRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: UserSettingRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): UserSettingRequest;
  static deserializeBinaryFromReader(message: UserSettingRequest, reader: jspb.BinaryReader): UserSettingRequest;
}

export namespace UserSettingRequest {
  export type AsObject = {
    userName: string,
    opt: UserSettingRequest.OPTIONMap[keyof UserSettingRequest.OPTIONMap],
    type: string,
    data: string,
  }

  export interface OPTIONMap {
    OPT_GET: 0;
    OPT_SET: 1;
  }

  export const OPTION: OPTIONMap;
}

export class UserSettingReply extends jspb.Message {
  hasStatus(): boolean;
  clearStatus(): void;
  getStatus(): Status | undefined;
  setStatus(value?: Status): void;

  getData(): string;
  setData(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): UserSettingReply.AsObject;
  static toObject(includeInstance: boolean, msg: UserSettingReply): UserSettingReply.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: UserSettingReply, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): UserSettingReply;
  static deserializeBinaryFromReader(message: UserSettingReply, reader: jspb.BinaryReader): UserSettingReply;
}

export namespace UserSettingReply {
  export type AsObject = {
    status?: Status.AsObject,
    data: string,
  }
}

export class DownloadFileRequest extends jspb.Message {
  getFileName(): string;
  setFileName(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DownloadFileRequest.AsObject;
  static toObject(includeInstance: boolean, msg: DownloadFileRequest): DownloadFileRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: DownloadFileRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DownloadFileRequest;
  static deserializeBinaryFromReader(message: DownloadFileRequest, reader: jspb.BinaryReader): DownloadFileRequest;
}

export namespace DownloadFileRequest {
  export type AsObject = {
    fileName: string,
  }
}

export class DownloadFileReply extends jspb.Message {
  hasStatus(): boolean;
  clearStatus(): void;
  getStatus(): Status | undefined;
  setStatus(value?: Status): void;

  getTotalSize(): number;
  setTotalSize(value: number): void;

  getChunk(): Uint8Array | string;
  getChunk_asU8(): Uint8Array;
  getChunk_asB64(): string;
  setChunk(value: Uint8Array | string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DownloadFileReply.AsObject;
  static toObject(includeInstance: boolean, msg: DownloadFileReply): DownloadFileReply.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: DownloadFileReply, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DownloadFileReply;
  static deserializeBinaryFromReader(message: DownloadFileReply, reader: jspb.BinaryReader): DownloadFileReply;
}

export namespace DownloadFileReply {
  export type AsObject = {
    status?: Status.AsObject,
    totalSize: number,
    chunk: Uint8Array | string,
  }
}

export class ExportRequest extends jspb.Message {
  getDbType(): DBTypeMap[keyof DBTypeMap];
  setDbType(value: DBTypeMap[keyof DBTypeMap]): void;

  getLimit(): number;
  setLimit(value: number): void;

  clearSelectPropertiesList(): void;
  getSelectPropertiesList(): Array<string>;
  setSelectPropertiesList(value: Array<string>): void;
  addSelectProperties(value: string, index?: number): string;

  getSchema(): string;
  setSchema(value: string): void;

  getGraph(): string;
  setGraph(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ExportRequest.AsObject;
  static toObject(includeInstance: boolean, msg: ExportRequest): ExportRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: ExportRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ExportRequest;
  static deserializeBinaryFromReader(message: ExportRequest, reader: jspb.BinaryReader): ExportRequest;
}

export namespace ExportRequest {
  export type AsObject = {
    dbType: DBTypeMap[keyof DBTypeMap],
    limit: number,
    selectPropertiesList: Array<string>,
    schema: string,
    graph: string,
  }
}

export class ExportReply extends jspb.Message {
  hasStatus(): boolean;
  clearStatus(): void;
  getStatus(): Status | undefined;
  setStatus(value?: Status): void;

  hasNodeTable(): boolean;
  clearNodeTable(): void;
  getNodeTable(): EntityTable | undefined;
  setNodeTable(value?: EntityTable): void;

  hasEdgeTable(): boolean;
  clearEdgeTable(): void;
  getEdgeTable(): EntityTable | undefined;
  setEdgeTable(value?: EntityTable): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ExportReply.AsObject;
  static toObject(includeInstance: boolean, msg: ExportReply): ExportReply.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: ExportReply, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ExportReply;
  static deserializeBinaryFromReader(message: ExportReply, reader: jspb.BinaryReader): ExportReply;
}

export namespace ExportReply {
  export type AsObject = {
    status?: Status.AsObject,
    nodeTable?: EntityTable.AsObject,
    edgeTable?: EntityTable.AsObject,
  }
}

export class InsertNodesRequest extends jspb.Message {
  hasNodeTable(): boolean;
  clearNodeTable(): void;
  getNodeTable(): EntityTable | undefined;
  setNodeTable(value?: EntityTable): void;

  getSilent(): boolean;
  setSilent(value: boolean): void;

  getGraphName(): string;
  setGraphName(value: string): void;

  getInsertType(): InsertTypeMap[keyof InsertTypeMap];
  setInsertType(value: InsertTypeMap[keyof InsertTypeMap]): void;

  getInternal(): boolean;
  setInternal(value: boolean): void;

  clearProjectionsList(): void;
  getProjectionsList(): Array<string>;
  setProjectionsList(value: Array<string>): void;
  addProjections(value: string, index?: number): string;

  clearIndexesList(): void;
  getIndexesList(): Array<number>;
  setIndexesList(value: Array<number>): void;
  addIndexes(value: number, index?: number): number;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): InsertNodesRequest.AsObject;
  static toObject(includeInstance: boolean, msg: InsertNodesRequest): InsertNodesRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: InsertNodesRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): InsertNodesRequest;
  static deserializeBinaryFromReader(message: InsertNodesRequest, reader: jspb.BinaryReader): InsertNodesRequest;
}

export namespace InsertNodesRequest {
  export type AsObject = {
    nodeTable?: EntityTable.AsObject,
    silent: boolean,
    graphName: string,
    insertType: InsertTypeMap[keyof InsertTypeMap],
    internal: boolean,
    projectionsList: Array<string>,
    indexesList: Array<number>,
  }
}

export class InsertNodesReply extends jspb.Message {
  hasStatus(): boolean;
  clearStatus(): void;
  getStatus(): Status | undefined;
  setStatus(value?: Status): void;

  getTimeCost(): number;
  setTimeCost(value: number): void;

  getEngineTimeCost(): number;
  setEngineTimeCost(value: number): void;

  clearUuidsList(): void;
  getUuidsList(): Array<string>;
  setUuidsList(value: Array<string>): void;
  addUuids(value: string, index?: number): string;

  clearIdsList(): void;
  getIdsList(): Array<string>;
  setIdsList(value: Array<string>): void;
  addIds(value: string, index?: number): string;

  clearIgnoreIndexesList(): void;
  getIgnoreIndexesList(): Array<number>;
  setIgnoreIndexesList(value: Array<number>): void;
  addIgnoreIndexes(value: number, index?: number): number;

  clearIgnoreErrorCodeList(): void;
  getIgnoreErrorCodeList(): Array<number>;
  setIgnoreErrorCodeList(value: Array<number>): void;
  addIgnoreErrorCode(value: number, index?: number): number;

  hasNodes(): boolean;
  clearNodes(): void;
  getNodes(): EntityTable | undefined;
  setNodes(value?: EntityTable): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): InsertNodesReply.AsObject;
  static toObject(includeInstance: boolean, msg: InsertNodesReply): InsertNodesReply.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: InsertNodesReply, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): InsertNodesReply;
  static deserializeBinaryFromReader(message: InsertNodesReply, reader: jspb.BinaryReader): InsertNodesReply;
}

export namespace InsertNodesReply {
  export type AsObject = {
    status?: Status.AsObject,
    timeCost: number,
    engineTimeCost: number,
    uuidsList: Array<string>,
    idsList: Array<string>,
    ignoreIndexesList: Array<number>,
    ignoreErrorCodeList: Array<number>,
    nodes?: EntityTable.AsObject,
  }
}

export class InsertEdgesRequest extends jspb.Message {
  hasEdgeTable(): boolean;
  clearEdgeTable(): void;
  getEdgeTable(): EntityTable | undefined;
  setEdgeTable(value?: EntityTable): void;

  getSilent(): boolean;
  setSilent(value: boolean): void;

  getGraphName(): string;
  setGraphName(value: string): void;

  getCreateNodeIfNotExist(): boolean;
  setCreateNodeIfNotExist(value: boolean): void;

  getInsertType(): InsertTypeMap[keyof InsertTypeMap];
  setInsertType(value: InsertTypeMap[keyof InsertTypeMap]): void;

  clearProjectionsList(): void;
  getProjectionsList(): Array<string>;
  setProjectionsList(value: Array<string>): void;
  addProjections(value: string, index?: number): string;

  clearIndexesList(): void;
  getIndexesList(): Array<number>;
  setIndexesList(value: Array<number>): void;
  addIndexes(value: number, index?: number): number;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): InsertEdgesRequest.AsObject;
  static toObject(includeInstance: boolean, msg: InsertEdgesRequest): InsertEdgesRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: InsertEdgesRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): InsertEdgesRequest;
  static deserializeBinaryFromReader(message: InsertEdgesRequest, reader: jspb.BinaryReader): InsertEdgesRequest;
}

export namespace InsertEdgesRequest {
  export type AsObject = {
    edgeTable?: EntityTable.AsObject,
    silent: boolean,
    graphName: string,
    createNodeIfNotExist: boolean,
    insertType: InsertTypeMap[keyof InsertTypeMap],
    projectionsList: Array<string>,
    indexesList: Array<number>,
  }
}

export class InsertEdgesReply extends jspb.Message {
  hasStatus(): boolean;
  clearStatus(): void;
  getStatus(): Status | undefined;
  setStatus(value?: Status): void;

  getTimeCost(): number;
  setTimeCost(value: number): void;

  getEngineTimeCost(): number;
  setEngineTimeCost(value: number): void;

  clearUuidsList(): void;
  getUuidsList(): Array<string>;
  setUuidsList(value: Array<string>): void;
  addUuids(value: string, index?: number): string;

  clearIgnoreIndexesList(): void;
  getIgnoreIndexesList(): Array<number>;
  setIgnoreIndexesList(value: Array<number>): void;
  addIgnoreIndexes(value: number, index?: number): number;

  clearIgnoreErrorCodeList(): void;
  getIgnoreErrorCodeList(): Array<number>;
  setIgnoreErrorCodeList(value: Array<number>): void;
  addIgnoreErrorCode(value: number, index?: number): number;

  hasEdges(): boolean;
  clearEdges(): void;
  getEdges(): EntityTable | undefined;
  setEdges(value?: EntityTable): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): InsertEdgesReply.AsObject;
  static toObject(includeInstance: boolean, msg: InsertEdgesReply): InsertEdgesReply.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: InsertEdgesReply, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): InsertEdgesReply;
  static deserializeBinaryFromReader(message: InsertEdgesReply, reader: jspb.BinaryReader): InsertEdgesReply;
}

export namespace InsertEdgesReply {
  export type AsObject = {
    status?: Status.AsObject,
    timeCost: number,
    engineTimeCost: number,
    uuidsList: Array<string>,
    ignoreIndexesList: Array<number>,
    ignoreErrorCodeList: Array<number>,
    edges?: EntityTable.AsObject,
  }
}

export class WithServer extends jspb.Message {
  getHdcServerName(): string;
  setHdcServerName(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): WithServer.AsObject;
  static toObject(includeInstance: boolean, msg: WithServer): WithServer.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: WithServer, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): WithServer;
  static deserializeBinaryFromReader(message: WithServer, reader: jspb.BinaryReader): WithServer;
}

export namespace WithServer {
  export type AsObject = {
    hdcServerName: string,
  }
}

export class InstallAlgoRequest extends jspb.Message {
  getFileName(): string;
  setFileName(value: string): void;

  getMd5(): string;
  setMd5(value: string): void;

  getChunk(): Uint8Array | string;
  getChunk_asU8(): Uint8Array;
  getChunk_asB64(): string;
  setChunk(value: Uint8Array | string): void;

  hasWithServer(): boolean;
  clearWithServer(): void;
  getWithServer(): WithServer | undefined;
  setWithServer(value?: WithServer): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): InstallAlgoRequest.AsObject;
  static toObject(includeInstance: boolean, msg: InstallAlgoRequest): InstallAlgoRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: InstallAlgoRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): InstallAlgoRequest;
  static deserializeBinaryFromReader(message: InstallAlgoRequest, reader: jspb.BinaryReader): InstallAlgoRequest;
}

export namespace InstallAlgoRequest {
  export type AsObject = {
    fileName: string,
    md5: string,
    chunk: Uint8Array | string,
    withServer?: WithServer.AsObject,
  }
}

export class InstallAlgoReply extends jspb.Message {
  hasStatus(): boolean;
  clearStatus(): void;
  getStatus(): Status | undefined;
  setStatus(value?: Status): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): InstallAlgoReply.AsObject;
  static toObject(includeInstance: boolean, msg: InstallAlgoReply): InstallAlgoReply.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: InstallAlgoReply, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): InstallAlgoReply;
  static deserializeBinaryFromReader(message: InstallAlgoReply, reader: jspb.BinaryReader): InstallAlgoReply;
}

export namespace InstallAlgoReply {
  export type AsObject = {
    status?: Status.AsObject,
  }
}

export class UninstallAlgoRequest extends jspb.Message {
  getAlgoName(): string;
  setAlgoName(value: string): void;

  hasWithServer(): boolean;
  clearWithServer(): void;
  getWithServer(): WithServer | undefined;
  setWithServer(value?: WithServer): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): UninstallAlgoRequest.AsObject;
  static toObject(includeInstance: boolean, msg: UninstallAlgoRequest): UninstallAlgoRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: UninstallAlgoRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): UninstallAlgoRequest;
  static deserializeBinaryFromReader(message: UninstallAlgoRequest, reader: jspb.BinaryReader): UninstallAlgoRequest;
}

export namespace UninstallAlgoRequest {
  export type AsObject = {
    algoName: string,
    withServer?: WithServer.AsObject,
  }
}

export class UninstallAlgoReply extends jspb.Message {
  hasStatus(): boolean;
  clearStatus(): void;
  getStatus(): Status | undefined;
  setStatus(value?: Status): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): UninstallAlgoReply.AsObject;
  static toObject(includeInstance: boolean, msg: UninstallAlgoReply): UninstallAlgoReply.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: UninstallAlgoReply, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): UninstallAlgoReply;
  static deserializeBinaryFromReader(message: UninstallAlgoReply, reader: jspb.BinaryReader): UninstallAlgoReply;
}

export namespace UninstallAlgoReply {
  export type AsObject = {
    status?: Status.AsObject,
  }
}

export class RollbackAlgoRequest extends jspb.Message {
  getAlgoName(): string;
  setAlgoName(value: string): void;

  hasWithServer(): boolean;
  clearWithServer(): void;
  getWithServer(): WithServer | undefined;
  setWithServer(value?: WithServer): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): RollbackAlgoRequest.AsObject;
  static toObject(includeInstance: boolean, msg: RollbackAlgoRequest): RollbackAlgoRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: RollbackAlgoRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): RollbackAlgoRequest;
  static deserializeBinaryFromReader(message: RollbackAlgoRequest, reader: jspb.BinaryReader): RollbackAlgoRequest;
}

export namespace RollbackAlgoRequest {
  export type AsObject = {
    algoName: string,
    withServer?: WithServer.AsObject,
  }
}

export class RollbackAlgoReply extends jspb.Message {
  hasStatus(): boolean;
  clearStatus(): void;
  getStatus(): Status | undefined;
  setStatus(value?: Status): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): RollbackAlgoReply.AsObject;
  static toObject(includeInstance: boolean, msg: RollbackAlgoReply): RollbackAlgoReply.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: RollbackAlgoReply, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): RollbackAlgoReply;
  static deserializeBinaryFromReader(message: RollbackAlgoReply, reader: jspb.BinaryReader): RollbackAlgoReply;
}

export namespace RollbackAlgoReply {
  export type AsObject = {
    status?: Status.AsObject,
  }
}

export class Status extends jspb.Message {
  getErrorCode(): ErrorCodeMap[keyof ErrorCodeMap];
  setErrorCode(value: ErrorCodeMap[keyof ErrorCodeMap]): void;

  getMsg(): string;
  setMsg(value: string): void;

  hasClusterInfo(): boolean;
  clearClusterInfo(): void;
  getClusterInfo(): ClusterInfo | undefined;
  setClusterInfo(value?: ClusterInfo): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Status.AsObject;
  static toObject(includeInstance: boolean, msg: Status): Status.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: Status, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Status;
  static deserializeBinaryFromReader(message: Status, reader: jspb.BinaryReader): Status;
}

export namespace Status {
  export type AsObject = {
    errorCode: ErrorCodeMap[keyof ErrorCodeMap],
    msg: string,
    clusterInfo?: ClusterInfo.AsObject,
  }
}

export class RaftFollower extends jspb.Message {
  getAddress(): string;
  setAddress(value: string): void;

  getRole(): number;
  setRole(value: number): void;

  getStatus(): ServerStatusMap[keyof ServerStatusMap];
  setStatus(value: ServerStatusMap[keyof ServerStatusMap]): void;

  getStreamAddress(): string;
  setStreamAddress(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): RaftFollower.AsObject;
  static toObject(includeInstance: boolean, msg: RaftFollower): RaftFollower.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: RaftFollower, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): RaftFollower;
  static deserializeBinaryFromReader(message: RaftFollower, reader: jspb.BinaryReader): RaftFollower;
}

export namespace RaftFollower {
  export type AsObject = {
    address: string,
    role: number,
    status: ServerStatusMap[keyof ServerStatusMap],
    streamAddress: string,
  }
}

export class ClusterInfo extends jspb.Message {
  getRedirect(): string;
  setRedirect(value: string): void;

  getLeaderAddress(): string;
  setLeaderAddress(value: string): void;

  clearFollowersList(): void;
  getFollowersList(): Array<RaftFollower>;
  setFollowersList(value: Array<RaftFollower>): void;
  addFollowers(value?: RaftFollower, index?: number): RaftFollower;

  getLeaderStreamAddress(): string;
  setLeaderStreamAddress(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ClusterInfo.AsObject;
  static toObject(includeInstance: boolean, msg: ClusterInfo): ClusterInfo.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: ClusterInfo, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ClusterInfo;
  static deserializeBinaryFromReader(message: ClusterInfo, reader: jspb.BinaryReader): ClusterInfo;
}

export namespace ClusterInfo {
  export type AsObject = {
    redirect: string,
    leaderAddress: string,
    followersList: Array<RaftFollower.AsObject>,
    leaderStreamAddress: string,
  }
}

export class Path extends jspb.Message {
  hasNodeTable(): boolean;
  clearNodeTable(): void;
  getNodeTable(): EntityTable | undefined;
  setNodeTable(value?: EntityTable): void;

  hasEdgeTable(): boolean;
  clearEdgeTable(): void;
  getEdgeTable(): EntityTable | undefined;
  setEdgeTable(value?: EntityTable): void;

  getIsNull(): boolean;
  setIsNull(value: boolean): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Path.AsObject;
  static toObject(includeInstance: boolean, msg: Path): Path.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: Path, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Path;
  static deserializeBinaryFromReader(message: Path, reader: jspb.BinaryReader): Path;
}

export namespace Path {
  export type AsObject = {
    nodeTable?: EntityTable.AsObject,
    edgeTable?: EntityTable.AsObject,
    isNull: boolean,
  }
}

export class Table extends jspb.Message {
  getTableName(): string;
  setTableName(value: string): void;

  clearHeadersList(): void;
  getHeadersList(): Array<Header>;
  setHeadersList(value: Array<Header>): void;
  addHeaders(value?: Header, index?: number): Header;

  clearTableRowsList(): void;
  getTableRowsList(): Array<TableRow>;
  setTableRowsList(value: Array<TableRow>): void;
  addTableRows(value?: TableRow, index?: number): TableRow;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Table.AsObject;
  static toObject(includeInstance: boolean, msg: Table): Table.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: Table, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Table;
  static deserializeBinaryFromReader(message: Table, reader: jspb.BinaryReader): Table;
}

export namespace Table {
  export type AsObject = {
    tableName: string,
    headersList: Array<Header.AsObject>,
    tableRowsList: Array<TableRow.AsObject>,
  }
}

export class TableRow extends jspb.Message {
  clearValuesList(): void;
  getValuesList(): Array<Uint8Array | string>;
  getValuesList_asU8(): Array<Uint8Array>;
  getValuesList_asB64(): Array<string>;
  setValuesList(value: Array<Uint8Array | string>): void;
  addValues(value: Uint8Array | string, index?: number): Uint8Array | string;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): TableRow.AsObject;
  static toObject(includeInstance: boolean, msg: TableRow): TableRow.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: TableRow, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): TableRow;
  static deserializeBinaryFromReader(message: TableRow, reader: jspb.BinaryReader): TableRow;
}

export namespace TableRow {
  export type AsObject = {
    valuesList: Array<Uint8Array | string>,
  }
}

export class EntityTable extends jspb.Message {
  clearSchemasList(): void;
  getSchemasList(): Array<Schema>;
  setSchemasList(value: Array<Schema>): void;
  addSchemas(value?: Schema, index?: number): Schema;

  clearEntityRowsList(): void;
  getEntityRowsList(): Array<EntityRow>;
  setEntityRowsList(value: Array<EntityRow>): void;
  addEntityRows(value?: EntityRow, index?: number): EntityRow;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): EntityTable.AsObject;
  static toObject(includeInstance: boolean, msg: EntityTable): EntityTable.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: EntityTable, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): EntityTable;
  static deserializeBinaryFromReader(message: EntityTable, reader: jspb.BinaryReader): EntityTable;
}

export namespace EntityTable {
  export type AsObject = {
    schemasList: Array<Schema.AsObject>,
    entityRowsList: Array<EntityRow.AsObject>,
  }
}

export class EntityRow extends jspb.Message {
  getUuid(): string;
  setUuid(value: string): void;

  getId(): string;
  setId(value: string): void;

  getSchemaName(): string;
  setSchemaName(value: string): void;

  getFromUuid(): string;
  setFromUuid(value: string): void;

  getToUuid(): string;
  setToUuid(value: string): void;

  getFromId(): string;
  setFromId(value: string): void;

  getToId(): string;
  setToId(value: string): void;

  clearValuesList(): void;
  getValuesList(): Array<Uint8Array | string>;
  getValuesList_asU8(): Array<Uint8Array>;
  getValuesList_asB64(): Array<string>;
  setValuesList(value: Array<Uint8Array | string>): void;
  addValues(value: Uint8Array | string, index?: number): Uint8Array | string;

  getIsNull(): boolean;
  setIsNull(value: boolean): void;

  getSchemaId(): number;
  setSchemaId(value: number): void;

  getFromSchemaId(): number;
  setFromSchemaId(value: number): void;

  getToSchemaId(): number;
  setToSchemaId(value: number): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): EntityRow.AsObject;
  static toObject(includeInstance: boolean, msg: EntityRow): EntityRow.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: EntityRow, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): EntityRow;
  static deserializeBinaryFromReader(message: EntityRow, reader: jspb.BinaryReader): EntityRow;
}

export namespace EntityRow {
  export type AsObject = {
    uuid: string,
    id: string,
    schemaName: string,
    fromUuid: string,
    toUuid: string,
    fromId: string,
    toId: string,
    valuesList: Array<Uint8Array | string>,
    isNull: boolean,
    schemaId: number,
    fromSchemaId: number,
    toSchemaId: number,
  }
}

export class Schema extends jspb.Message {
  getSchemaName(): string;
  setSchemaName(value: string): void;

  clearPropertiesList(): void;
  getPropertiesList(): Array<Property>;
  setPropertiesList(value: Array<Property>): void;
  addProperties(value?: Property, index?: number): Property;

  getSchemaId(): number;
  setSchemaId(value: number): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Schema.AsObject;
  static toObject(includeInstance: boolean, msg: Schema): Schema.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: Schema, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Schema;
  static deserializeBinaryFromReader(message: Schema, reader: jspb.BinaryReader): Schema;
}

export namespace Schema {
  export type AsObject = {
    schemaName: string,
    propertiesList: Array<Property.AsObject>,
    schemaId: number,
  }
}

export class Property extends jspb.Message {
  getPropertyName(): string;
  setPropertyName(value: string): void;

  getPropertyType(): PropertyTypeMap[keyof PropertyTypeMap];
  setPropertyType(value: PropertyTypeMap[keyof PropertyTypeMap]): void;

  clearSubTypesList(): void;
  getSubTypesList(): Array<PropertyTypeMap[keyof PropertyTypeMap]>;
  setSubTypesList(value: Array<PropertyTypeMap[keyof PropertyTypeMap]>): void;
  addSubTypes(value: PropertyTypeMap[keyof PropertyTypeMap], index?: number): PropertyTypeMap[keyof PropertyTypeMap];

  getPropertyId(): number;
  setPropertyId(value: number): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Property.AsObject;
  static toObject(includeInstance: boolean, msg: Property): Property.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: Property, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Property;
  static deserializeBinaryFromReader(message: Property, reader: jspb.BinaryReader): Property;
}

export namespace Property {
  export type AsObject = {
    propertyName: string,
    propertyType: PropertyTypeMap[keyof PropertyTypeMap],
    subTypesList: Array<PropertyTypeMap[keyof PropertyTypeMap]>,
    propertyId: number,
  }
}

export class Header extends jspb.Message {
  getPropertyName(): string;
  setPropertyName(value: string): void;

  getPropertyType(): PropertyTypeMap[keyof PropertyTypeMap];
  setPropertyType(value: PropertyTypeMap[keyof PropertyTypeMap]): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Header.AsObject;
  static toObject(includeInstance: boolean, msg: Header): Header.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: Header, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Header;
  static deserializeBinaryFromReader(message: Header, reader: jspb.BinaryReader): Header;
}

export namespace Header {
  export type AsObject = {
    propertyName: string,
    propertyType: PropertyTypeMap[keyof PropertyTypeMap],
  }
}

export class Value extends jspb.Message {
  getKey(): string;
  setKey(value: string): void;

  getValue(): string;
  setValue(value: string): void;

  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 = {
    key: string,
    value: string,
  }
}

export class ListData extends jspb.Message {
  clearValuesList(): void;
  getValuesList(): Array<Uint8Array | string>;
  getValuesList_asU8(): Array<Uint8Array>;
  getValuesList_asB64(): Array<string>;
  setValuesList(value: Array<Uint8Array | string>): void;
  addValues(value: Uint8Array | string, index?: number): Uint8Array | string;

  getIsNull(): boolean;
  setIsNull(value: boolean): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ListData.AsObject;
  static toObject(includeInstance: boolean, msg: ListData): ListData.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: ListData, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ListData;
  static deserializeBinaryFromReader(message: ListData, reader: jspb.BinaryReader): ListData;
}

export namespace ListData {
  export type AsObject = {
    valuesList: Array<Uint8Array | string>,
    isNull: boolean,
  }
}

export class SetData extends jspb.Message {
  clearValuesList(): void;
  getValuesList(): Array<Uint8Array | string>;
  getValuesList_asU8(): Array<Uint8Array>;
  getValuesList_asB64(): Array<string>;
  setValuesList(value: Array<Uint8Array | string>): void;
  addValues(value: Uint8Array | string, index?: number): Uint8Array | string;

  getIsNull(): boolean;
  setIsNull(value: boolean): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): SetData.AsObject;
  static toObject(includeInstance: boolean, msg: SetData): SetData.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: SetData, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): SetData;
  static deserializeBinaryFromReader(message: SetData, reader: jspb.BinaryReader): SetData;
}

export namespace SetData {
  export type AsObject = {
    valuesList: Array<Uint8Array | string>,
    isNull: boolean,
  }
}

export class MapValue extends jspb.Message {
  getKey(): Uint8Array | string;
  getKey_asU8(): Uint8Array;
  getKey_asB64(): string;
  setKey(value: Uint8Array | string): void;

  getValue(): Uint8Array | string;
  getValue_asU8(): Uint8Array;
  getValue_asB64(): string;
  setValue(value: Uint8Array | string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): MapValue.AsObject;
  static toObject(includeInstance: boolean, msg: MapValue): MapValue.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: MapValue, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): MapValue;
  static deserializeBinaryFromReader(message: MapValue, reader: jspb.BinaryReader): MapValue;
}

export namespace MapValue {
  export type AsObject = {
    key: Uint8Array | string,
    value: Uint8Array | string,
  }
}

export class MapData extends jspb.Message {
  clearValuesList(): void;
  getValuesList(): Array<MapValue>;
  setValuesList(value: Array<MapValue>): void;
  addValues(value?: MapValue, index?: number): MapValue;

  getIsNull(): boolean;
  setIsNull(value: boolean): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): MapData.AsObject;
  static toObject(includeInstance: boolean, msg: MapData): MapData.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: MapData, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): MapData;
  static deserializeBinaryFromReader(message: MapData, reader: jspb.BinaryReader): MapData;
}

export namespace MapData {
  export type AsObject = {
    valuesList: Array<MapValue.AsObject>,
    isNull: boolean,
  }
}

export class ExplainPlan extends jspb.Message {
  clearPlanNodesList(): void;
  getPlanNodesList(): Array<PlanNode>;
  setPlanNodesList(value: Array<PlanNode>): void;
  addPlanNodes(value?: PlanNode, index?: number): PlanNode;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ExplainPlan.AsObject;
  static toObject(includeInstance: boolean, msg: ExplainPlan): ExplainPlan.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: ExplainPlan, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ExplainPlan;
  static deserializeBinaryFromReader(message: ExplainPlan, reader: jspb.BinaryReader): ExplainPlan;
}

export namespace ExplainPlan {
  export type AsObject = {
    planNodesList: Array<PlanNode.AsObject>,
  }
}

export class PlanNode extends jspb.Message {
  getAlias(): string;
  setAlias(value: string): void;

  getChildrenNum(): number;
  setChildrenNum(value: number): void;

  getQueryText(): string;
  setQueryText(value: string): void;

  getInfos(): string;
  setInfos(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): PlanNode.AsObject;
  static toObject(includeInstance: boolean, msg: PlanNode): PlanNode.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: PlanNode, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): PlanNode;
  static deserializeBinaryFromReader(message: PlanNode, reader: jspb.BinaryReader): PlanNode;
}

export namespace PlanNode {
  export type AsObject = {
    alias: string,
    childrenNum: number,
    queryText: string,
    infos: string,
  }
}

export class AuthenticateRequest extends jspb.Message {
  getType(): AuthenticateTypeMap[keyof AuthenticateTypeMap];
  setType(value: AuthenticateTypeMap[keyof AuthenticateTypeMap]): void;

  getQueryText(): string;
  setQueryText(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): AuthenticateRequest.AsObject;
  static toObject(includeInstance: boolean, msg: AuthenticateRequest): AuthenticateRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: AuthenticateRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): AuthenticateRequest;
  static deserializeBinaryFromReader(message: AuthenticateRequest, reader: jspb.BinaryReader): AuthenticateRequest;
}

export namespace AuthenticateRequest {
  export type AsObject = {
    type: AuthenticateTypeMap[keyof AuthenticateTypeMap],
    queryText: string,
  }
}

export class AuthenticateReply extends jspb.Message {
  hasStatus(): boolean;
  clearStatus(): void;
  getStatus(): Status | undefined;
  setStatus(value?: Status): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): AuthenticateReply.AsObject;
  static toObject(includeInstance: boolean, msg: AuthenticateReply): AuthenticateReply.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: AuthenticateReply, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): AuthenticateReply;
  static deserializeBinaryFromReader(message: AuthenticateReply, reader: jspb.BinaryReader): AuthenticateReply;
}

export namespace AuthenticateReply {
  export type AsObject = {
    status?: Status.AsObject,
  }
}

export class MigrationData extends jspb.Message {
  getKey(): Uint8Array | string;
  getKey_asU8(): Uint8Array;
  getKey_asB64(): string;
  setKey(value: Uint8Array | string): void;

  getValue(): Uint8Array | string;
  getValue_asU8(): Uint8Array;
  getValue_asB64(): string;
  setValue(value: Uint8Array | string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): MigrationData.AsObject;
  static toObject(includeInstance: boolean, msg: MigrationData): MigrationData.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: MigrationData, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): MigrationData;
  static deserializeBinaryFromReader(message: MigrationData, reader: jspb.BinaryReader): MigrationData;
}

export namespace MigrationData {
  export type AsObject = {
    key: Uint8Array | string,
    value: Uint8Array | string,
  }
}

export class MigrationDataArray extends jspb.Message {
  clearDatasList(): void;
  getDatasList(): Array<MigrationData>;
  setDatasList(value: Array<MigrationData>): void;
  addDatas(value?: MigrationData, index?: number): MigrationData;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): MigrationDataArray.AsObject;
  static toObject(includeInstance: boolean, msg: MigrationDataArray): MigrationDataArray.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: MigrationDataArray, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): MigrationDataArray;
  static deserializeBinaryFromReader(message: MigrationDataArray, reader: jspb.BinaryReader): MigrationDataArray;
}

export namespace MigrationDataArray {
  export type AsObject = {
    datasList: Array<MigrationData.AsObject>,
  }
}

export class GetLeaderRequest extends jspb.Message {
  getGraphName(): string;
  setGraphName(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetLeaderRequest.AsObject;
  static toObject(includeInstance: boolean, msg: GetLeaderRequest): GetLeaderRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GetLeaderRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetLeaderRequest;
  static deserializeBinaryFromReader(message: GetLeaderRequest, reader: jspb.BinaryReader): GetLeaderRequest;
}

export namespace GetLeaderRequest {
  export type AsObject = {
    graphName: string,
  }
}

export class GetLeaderReply extends jspb.Message {
  hasStatus(): boolean;
  clearStatus(): void;
  getStatus(): Status | undefined;
  setStatus(value?: Status): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetLeaderReply.AsObject;
  static toObject(includeInstance: boolean, msg: GetLeaderReply): GetLeaderReply.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GetLeaderReply, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetLeaderReply;
  static deserializeBinaryFromReader(message: GetLeaderReply, reader: jspb.BinaryReader): GetLeaderReply;
}

export namespace GetLeaderReply {
  export type AsObject = {
    status?: Status.AsObject,
  }
}

export interface QueryTypeMap {
  QUERY_UNSET: 0;
  UQL: 1;
  GQL: 2;
}

export const QueryType: QueryTypeMap;

export interface ResultTypeMap {
  RESULT_TYPE_UNSET: 0;
  RESULT_TYPE_PATH: 1;
  RESULT_TYPE_NODE: 2;
  RESULT_TYPE_EDGE: 3;
  RESULT_TYPE_ATTR: 4;
  RESULT_TYPE_TABLE: 5;
}

export const ResultType: ResultTypeMap;

export interface InsertTypeMap {
  NORMAL: 0;
  OVERWRITE: 1;
  UPSERT: 2;
}

export const InsertType: InsertTypeMap;

export interface PropertyTypeMap {
  UNSET: 0;
  INT32: 1;
  UINT32: 2;
  INT64: 3;
  UINT64: 4;
  FLOAT: 5;
  DOUBLE: 6;
  STRING: 7;
  DATETIME: 8;
  TIMESTAMP: 9;
  TEXT: 10;
  BLOB: 11;
  POINT: 12;
  DECIMAL: 13;
  LIST: 14;
  SET: 15;
  MAP: 16;
  NULL_: 17;
  BOOL: 18;
}

export const PropertyType: PropertyTypeMap;

export interface ErrorCodeMap {
  SUCCESS: 0;
  FAILED: 1;
  PARAM_ERROR: 2;
  BASE_DB_ERROR: 3;
  ENGINE_ERROR: 4;
  SYSTEM_ERROR: 5;
  SYNTAX_ERROR: 6;
  PERMISSION_DENIED: 7;
  DUPLICATE_ID: 8;
  RAFT_REDIRECT: 10001;
  RAFT_LEADER_NOT_YET_ELECTED: 10002;
  RAFT_LOG_ERROR: 10003;
  NOT_RAFT_MODE: 10004;
  RAFT_NO_AVAILABLE_FOLLOWERS: 10005;
  RAFT_NO_AVAILABLE_ALGO_SERVERS: 10006;
}

export const ErrorCode: ErrorCodeMap;

export interface FollowerRoleMap {
  ROLE_UNSET: 0;
  ROLE_READABLE: 1;
  ROLE_ALGO_EXECUTABLE: 2;
  ROLE_LEARNER: 4;
}

export const FollowerRole: FollowerRoleMap;

export interface ServerStatusMap {
  SERVER_STATUS_UNSET: 0;
  ALIVE: 1;
  DEAD: 2;
}

export const ServerStatus: ServerStatusMap;

export interface DBTypeMap {
  DBNODE: 0;
  DBEDGE: 1;
  DBGLOBAL: 2;
}

export const DBType: DBTypeMap;

export interface JOB_STATUSMap {
  JOB_PENDING: 0;
  JOB_COMPUTING: 1;
  JOB_WRITING: 2;
  JOB_DONE: 3;
  JOB_FAILED: 4;
  JOB_STOPPED: 5;
}

export const JOB_STATUS: JOB_STATUSMap;

export interface AuthenticateTypeMap {
  PERMISSION_TYPE_UNSET: 0;
  PERMISSION_TYPE_UQL: 1;
  PERMISSION_TYPE_GQL: 2;
  PERMISSION_TYPE_INSERTNODES: 3;
  PERMISSION_TYPE_INSERTEDGES: 4;
  PERMISSION_TYPE_EXPORT: 5;
  PERMISSION_TYPE_DOWNLOADFILE: 6;
  PERMISSION_TYPE_INSTALLALGO: 7;
  PERMISSION_TYPE_UNINSTALLALGO: 8;
  PERMISSION_TYPE_ROLLBACKALGO: 9;
}

export const AuthenticateType: AuthenticateTypeMap;