/**
 * Generated by the protoc-gen-ts.  DO NOT EDIT!
 * compiler version: 3.17.3
 * source: lib/codeintel/lsiftyped/lsif.proto
 * git: https://github.com/thesayyn/protoc-gen-ts
 *  */
 import * as pb_1 from "google-protobuf";
 export namespace lib.codeintel.lsiftyped {
     export enum ProtocolVersion {
         UnspecifiedProtocolVersion = 0
     }
     export enum TextEncoding {
         UnspecifiedTextEncoding = 0,
         UTF8 = 1,
         UTF16 = 2
     }
     export enum SymbolRole {
         UnspecifiedSymbolRole = 0,
         Definition = 1,
         Import = 2,
         WriteAccess = 4,
         ReadAccess = 8,
         Generated = 16,
         Test = 32
     }
     export enum SyntaxKind {
         UnspecifiedSyntaxKind = 0,
         Operator = 1,
         Comment = 2,
         PunctuationDelimiter = 3,
         PunctuationBracket = 4,
         PunctuationSpecial = 5,
         Keyword = 6,
         Identifier = 7,
         BuiltinIdentifier = 8,
         NullIdentifier = 9,
         ConstantIdentifier = 10,
         MutableGlobalIdentifier = 11,
         ParameterIdentifier = 12,
         LocalIdentifier = 13,
         ShadowedIdentifier = 14,
         ModuleIdentifier = 15,
         MacroIdentifier = 16,
         StringLiteral = 17,
         StringLiteralRegex = 18,
         StringLiteralEscape = 19,
         StringLiteralSpecial = 20,
         StringLiteralKey = 21,
         CharacterLiteral = 22,
         NumericLiteral = 23,
         BooleanLiteral = 24,
         FunctionDefinition = 25,
         MacroDefinition = 26,
         TypeIdentifier = 27,
         BuiltinTypeIdentifier = 28,
         AttributeIdentifier = 29,
         Tag = 30,
         TagAttribute = 31,
         TagDelimiter = 32
     }
     export enum Severity {
         UnspecifiedSeverity = 0,
         Error = 1,
         Warning = 2,
         Information = 3,
         Hint = 4
     }
     export enum DiagnosticTag {
         UnspecifiedDiagnosticTag = 0,
         Unnecessary = 1,
         Deprecated = 2
     }
     export class Index extends pb_1.Message {
         constructor(data?: any[] | {
             metadata?: Metadata;
             documents?: Document[];
             external_symbols?: SymbolInformation[];
         }) {
             super();
             pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [2, 3], []);
             if (!Array.isArray(data) && typeof data == "object") {
                 if ("metadata" in data && data.metadata != undefined) {
                     this.metadata = data.metadata;
                 }
                 if ("documents" in data && data.documents != undefined) {
                     this.documents = data.documents;
                 }
                 if ("external_symbols" in data && data.external_symbols != undefined) {
                     this.external_symbols = data.external_symbols;
                 }
             }
         }
         get metadata() {
             return pb_1.Message.getWrapperField(this, Metadata, 1) as Metadata;
         }
         set metadata(value: Metadata) {
             pb_1.Message.setWrapperField(this, 1, value);
         }
         get documents() {
             return pb_1.Message.getRepeatedWrapperField(this, Document, 2) as Document[];
         }
         set documents(value: Document[]) {
             pb_1.Message.setRepeatedWrapperField(this, 2, value);
         }
         get external_symbols() {
             return pb_1.Message.getRepeatedWrapperField(this, SymbolInformation, 3) as SymbolInformation[];
         }
         set external_symbols(value: SymbolInformation[]) {
             pb_1.Message.setRepeatedWrapperField(this, 3, value);
         }
         static fromObject(data: {
             metadata?: ReturnType<typeof Metadata.prototype.toObject>;
             documents?: ReturnType<typeof Document.prototype.toObject>[];
             external_symbols?: ReturnType<typeof SymbolInformation.prototype.toObject>[];
         }) {
             const message = new Index({});
             if (data.metadata != null) {
                 message.metadata = Metadata.fromObject(data.metadata);
             }
             if (data.documents != null) {
                 message.documents = data.documents.map(item => Document.fromObject(item));
             }
             if (data.external_symbols != null) {
                 message.external_symbols = data.external_symbols.map(item => SymbolInformation.fromObject(item));
             }
             return message;
         }
         toObject() {
             const data: {
                 metadata?: ReturnType<typeof Metadata.prototype.toObject>;
                 documents?: ReturnType<typeof Document.prototype.toObject>[];
                 external_symbols?: ReturnType<typeof SymbolInformation.prototype.toObject>[];
             } = {};
             if (this.metadata != null) {
                 data.metadata = this.metadata.toObject();
             }
             if (this.documents != null) {
                 data.documents = this.documents.map((item: Document) => item.toObject());
             }
             if (this.external_symbols != null) {
                 data.external_symbols = this.external_symbols.map((item: SymbolInformation) => item.toObject());
             }
             return data;
         }
         serialize(): Uint8Array;
         serialize(w: pb_1.BinaryWriter): void;
         serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
             const writer = w || new pb_1.BinaryWriter();
             if (this.metadata !== undefined)
                 writer.writeMessage(1, this.metadata, () => this.metadata.serialize(writer));
             if (this.documents !== undefined)
                 writer.writeRepeatedMessage(2, this.documents, (item: Document) => item.serialize(writer));
             if (this.external_symbols !== undefined)
                 writer.writeRepeatedMessage(3, this.external_symbols, (item: SymbolInformation) => item.serialize(writer));
             if (!w)
                 return writer.getResultBuffer();
         }
         static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Index {
             const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Index();
             while (reader.nextField()) {
                 if (reader.isEndGroup())
                     break;
                 switch (reader.getFieldNumber()) {
                     case 1:
                         reader.readMessage(message.metadata, () => message.metadata = Metadata.deserialize(reader));
                         break;
                     case 2:
                         reader.readMessage(message.documents, () => pb_1.Message.addToRepeatedWrapperField(message, 2, Document.deserialize(reader), Document));
                         break;
                     case 3:
                         reader.readMessage(message.external_symbols, () => pb_1.Message.addToRepeatedWrapperField(message, 3, SymbolInformation.deserialize(reader), SymbolInformation));
                         break;
                     default: reader.skipField();
                 }
             }
             return message;
         }
         serializeBinary(): Uint8Array {
             return this.serialize();
         }
         static deserializeBinary(bytes: Uint8Array): Index {
             return Index.deserialize(bytes);
         }
     }
     export class Metadata extends pb_1.Message {
         constructor(data?: any[] | {
             version?: ProtocolVersion;
             tool_info?: ToolInfo;
             project_root?: string;
             text_document_encoding?: TextEncoding;
         }) {
             super();
             pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []);
             if (!Array.isArray(data) && typeof data == "object") {
                 if ("version" in data && data.version != undefined) {
                     this.version = data.version;
                 }
                 if ("tool_info" in data && data.tool_info != undefined) {
                     this.tool_info = data.tool_info;
                 }
                 if ("project_root" in data && data.project_root != undefined) {
                     this.project_root = data.project_root;
                 }
                 if ("text_document_encoding" in data && data.text_document_encoding != undefined) {
                     this.text_document_encoding = data.text_document_encoding;
                 }
             }
         }
         get version() {
             return pb_1.Message.getField(this, 1) as ProtocolVersion;
         }
         set version(value: ProtocolVersion) {
             pb_1.Message.setField(this, 1, value);
         }
         get tool_info() {
             return pb_1.Message.getWrapperField(this, ToolInfo, 2) as ToolInfo;
         }
         set tool_info(value: ToolInfo) {
             pb_1.Message.setWrapperField(this, 2, value);
         }
         get project_root() {
             return pb_1.Message.getField(this, 3) as string;
         }
         set project_root(value: string) {
             pb_1.Message.setField(this, 3, value);
         }
         get text_document_encoding() {
             return pb_1.Message.getField(this, 4) as TextEncoding;
         }
         set text_document_encoding(value: TextEncoding) {
             pb_1.Message.setField(this, 4, value);
         }
         static fromObject(data: {
             version?: ProtocolVersion;
             tool_info?: ReturnType<typeof ToolInfo.prototype.toObject>;
             project_root?: string;
             text_document_encoding?: TextEncoding;
         }) {
             const message = new Metadata({});
             if (data.version != null) {
                 message.version = data.version;
             }
             if (data.tool_info != null) {
                 message.tool_info = ToolInfo.fromObject(data.tool_info);
             }
             if (data.project_root != null) {
                 message.project_root = data.project_root;
             }
             if (data.text_document_encoding != null) {
                 message.text_document_encoding = data.text_document_encoding;
             }
             return message;
         }
         toObject() {
             const data: {
                 version?: ProtocolVersion;
                 tool_info?: ReturnType<typeof ToolInfo.prototype.toObject>;
                 project_root?: string;
                 text_document_encoding?: TextEncoding;
             } = {};
             if (this.version != null) {
                 data.version = this.version;
             }
             if (this.tool_info != null) {
                 data.tool_info = this.tool_info.toObject();
             }
             if (this.project_root != null) {
                 data.project_root = this.project_root;
             }
             if (this.text_document_encoding != null) {
                 data.text_document_encoding = this.text_document_encoding;
             }
             return data;
         }
         serialize(): Uint8Array;
         serialize(w: pb_1.BinaryWriter): void;
         serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
             const writer = w || new pb_1.BinaryWriter();
             if (this.version !== undefined)
                 writer.writeEnum(1, this.version);
             if (this.tool_info !== undefined)
                 writer.writeMessage(2, this.tool_info, () => this.tool_info.serialize(writer));
             if (typeof this.project_root === "string" && this.project_root.length)
                 writer.writeString(3, this.project_root);
             if (this.text_document_encoding !== undefined)
                 writer.writeEnum(4, this.text_document_encoding);
             if (!w)
                 return writer.getResultBuffer();
         }
         static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Metadata {
             const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Metadata();
             while (reader.nextField()) {
                 if (reader.isEndGroup())
                     break;
                 switch (reader.getFieldNumber()) {
                     case 1:
                         message.version = reader.readEnum();
                         break;
                     case 2:
                         reader.readMessage(message.tool_info, () => message.tool_info = ToolInfo.deserialize(reader));
                         break;
                     case 3:
                         message.project_root = reader.readString();
                         break;
                     case 4:
                         message.text_document_encoding = reader.readEnum();
                         break;
                     default: reader.skipField();
                 }
             }
             return message;
         }
         serializeBinary(): Uint8Array {
             return this.serialize();
         }
         static deserializeBinary(bytes: Uint8Array): Metadata {
             return Metadata.deserialize(bytes);
         }
     }
     export class ToolInfo extends pb_1.Message {
         constructor(data?: any[] | {
             name?: string;
             version?: string;
             arguments?: string[];
         }) {
             super();
             pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [3], []);
             if (!Array.isArray(data) && typeof data == "object") {
                 if ("name" in data && data.name != undefined) {
                     this.name = data.name;
                 }
                 if ("version" in data && data.version != undefined) {
                     this.version = data.version;
                 }
                 if ("arguments" in data && data.arguments != undefined) {
                     this.arguments = data.arguments;
                 }
             }
         }
         get name() {
             return pb_1.Message.getField(this, 1) as string;
         }
         set name(value: string) {
             pb_1.Message.setField(this, 1, value);
         }
         get version() {
             return pb_1.Message.getField(this, 2) as string;
         }
         set version(value: string) {
             pb_1.Message.setField(this, 2, value);
         }
         get arguments() {
             return pb_1.Message.getField(this, 3) as string[];
         }
         set arguments(value: string[]) {
             pb_1.Message.setField(this, 3, value);
         }
         static fromObject(data: {
             name?: string;
             version?: string;
             arguments?: string[];
         }) {
             const message = new ToolInfo({});
             if (data.name != null) {
                 message.name = data.name;
             }
             if (data.version != null) {
                 message.version = data.version;
             }
             if (data.arguments != null) {
                 message.arguments = data.arguments;
             }
             return message;
         }
         toObject() {
             const data: {
                 name?: string;
                 version?: string;
                 arguments?: string[];
             } = {};
             if (this.name != null) {
                 data.name = this.name;
             }
             if (this.version != null) {
                 data.version = this.version;
             }
             if (this.arguments != null) {
                 data.arguments = this.arguments;
             }
             return data;
         }
         serialize(): Uint8Array;
         serialize(w: pb_1.BinaryWriter): void;
         serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
             const writer = w || new pb_1.BinaryWriter();
             if (typeof this.name === "string" && this.name.length)
                 writer.writeString(1, this.name);
             if (typeof this.version === "string" && this.version.length)
                 writer.writeString(2, this.version);
             if (this.arguments !== undefined)
                 writer.writeRepeatedString(3, this.arguments);
             if (!w)
                 return writer.getResultBuffer();
         }
         static deserialize(bytes: Uint8Array | pb_1.BinaryReader): ToolInfo {
             const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new ToolInfo();
             while (reader.nextField()) {
                 if (reader.isEndGroup())
                     break;
                 switch (reader.getFieldNumber()) {
                     case 1:
                         message.name = reader.readString();
                         break;
                     case 2:
                         message.version = reader.readString();
                         break;
                     case 3:
                         pb_1.Message.addToRepeatedField(message, 3, reader.readString());
                         break;
                     default: reader.skipField();
                 }
             }
             return message;
         }
         serializeBinary(): Uint8Array {
             return this.serialize();
         }
         static deserializeBinary(bytes: Uint8Array): ToolInfo {
             return ToolInfo.deserialize(bytes);
         }
     }
     export class Document extends pb_1.Message {
         constructor(data?: any[] | {
             relative_path?: string;
             occurrences?: Occurrence[];
             symbols?: SymbolInformation[];
         }) {
             super();
             pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [2, 3], []);
             if (!Array.isArray(data) && typeof data == "object") {
                 if ("relative_path" in data && data.relative_path != undefined) {
                     this.relative_path = data.relative_path;
                 }
                 if ("occurrences" in data && data.occurrences != undefined) {
                     this.occurrences = data.occurrences;
                 }
                 if ("symbols" in data && data.symbols != undefined) {
                     this.symbols = data.symbols;
                 }
             }
         }
         get relative_path() {
             return pb_1.Message.getField(this, 1) as string;
         }
         set relative_path(value: string) {
             pb_1.Message.setField(this, 1, value);
         }
         get occurrences() {
             return pb_1.Message.getRepeatedWrapperField(this, Occurrence, 2) as Occurrence[];
         }
         set occurrences(value: Occurrence[]) {
             pb_1.Message.setRepeatedWrapperField(this, 2, value);
         }
         get symbols() {
             return pb_1.Message.getRepeatedWrapperField(this, SymbolInformation, 3) as SymbolInformation[];
         }
         set symbols(value: SymbolInformation[]) {
             pb_1.Message.setRepeatedWrapperField(this, 3, value);
         }
         static fromObject(data: {
             relative_path?: string;
             occurrences?: ReturnType<typeof Occurrence.prototype.toObject>[];
             symbols?: ReturnType<typeof SymbolInformation.prototype.toObject>[];
         }) {
             const message = new Document({});
             if (data.relative_path != null) {
                 message.relative_path = data.relative_path;
             }
             if (data.occurrences != null) {
                 message.occurrences = data.occurrences.map(item => Occurrence.fromObject(item));
             }
             if (data.symbols != null) {
                 message.symbols = data.symbols.map(item => SymbolInformation.fromObject(item));
             }
             return message;
         }
         toObject() {
             const data: {
                 relative_path?: string;
                 occurrences?: ReturnType<typeof Occurrence.prototype.toObject>[];
                 symbols?: ReturnType<typeof SymbolInformation.prototype.toObject>[];
             } = {};
             if (this.relative_path != null) {
                 data.relative_path = this.relative_path;
             }
             if (this.occurrences != null) {
                 data.occurrences = this.occurrences.map((item: Occurrence) => item.toObject());
             }
             if (this.symbols != null) {
                 data.symbols = this.symbols.map((item: SymbolInformation) => item.toObject());
             }
             return data;
         }
         serialize(): Uint8Array;
         serialize(w: pb_1.BinaryWriter): void;
         serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
             const writer = w || new pb_1.BinaryWriter();
             if (typeof this.relative_path === "string" && this.relative_path.length)
                 writer.writeString(1, this.relative_path);
             if (this.occurrences !== undefined)
                 writer.writeRepeatedMessage(2, this.occurrences, (item: Occurrence) => item.serialize(writer));
             if (this.symbols !== undefined)
                 writer.writeRepeatedMessage(3, this.symbols, (item: SymbolInformation) => item.serialize(writer));
             if (!w)
                 return writer.getResultBuffer();
         }
         static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Document {
             const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Document();
             while (reader.nextField()) {
                 if (reader.isEndGroup())
                     break;
                 switch (reader.getFieldNumber()) {
                     case 1:
                         message.relative_path = reader.readString();
                         break;
                     case 2:
                         reader.readMessage(message.occurrences, () => pb_1.Message.addToRepeatedWrapperField(message, 2, Occurrence.deserialize(reader), Occurrence));
                         break;
                     case 3:
                         reader.readMessage(message.symbols, () => pb_1.Message.addToRepeatedWrapperField(message, 3, SymbolInformation.deserialize(reader), SymbolInformation));
                         break;
                     default: reader.skipField();
                 }
             }
             return message;
         }
         serializeBinary(): Uint8Array {
             return this.serialize();
         }
         static deserializeBinary(bytes: Uint8Array): Document {
             return Document.deserialize(bytes);
         }
     }
     export class Symbol extends pb_1.Message {
         constructor(data?: any[] | {
             scheme?: string;
             package?: Package;
             descriptors?: Descriptor[];
         }) {
             super();
             pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [3], []);
             if (!Array.isArray(data) && typeof data == "object") {
                 if ("scheme" in data && data.scheme != undefined) {
                     this.scheme = data.scheme;
                 }
                 if ("package" in data && data.package != undefined) {
                     this.package = data.package;
                 }
                 if ("descriptors" in data && data.descriptors != undefined) {
                     this.descriptors = data.descriptors;
                 }
             }
         }
         get scheme() {
             return pb_1.Message.getField(this, 1) as string;
         }
         set scheme(value: string) {
             pb_1.Message.setField(this, 1, value);
         }
         get package() {
             return pb_1.Message.getWrapperField(this, Package, 2) as Package;
         }
         set package(value: Package) {
             pb_1.Message.setWrapperField(this, 2, value);
         }
         get descriptors() {
             return pb_1.Message.getRepeatedWrapperField(this, Descriptor, 3) as Descriptor[];
         }
         set descriptors(value: Descriptor[]) {
             pb_1.Message.setRepeatedWrapperField(this, 3, value);
         }
         static fromObject(data: {
             scheme?: string;
             package?: ReturnType<typeof Package.prototype.toObject>;
             descriptors?: ReturnType<typeof Descriptor.prototype.toObject>[];
         }) {
             const message = new Symbol({});
             if (data.scheme != null) {
                 message.scheme = data.scheme;
             }
             if (data.package != null) {
                 message.package = Package.fromObject(data.package);
             }
             if (data.descriptors != null) {
                 message.descriptors = data.descriptors.map(item => Descriptor.fromObject(item));
             }
             return message;
         }
         toObject() {
             const data: {
                 scheme?: string;
                 package?: ReturnType<typeof Package.prototype.toObject>;
                 descriptors?: ReturnType<typeof Descriptor.prototype.toObject>[];
             } = {};
             if (this.scheme != null) {
                 data.scheme = this.scheme;
             }
             if (this.package != null) {
                 data.package = this.package.toObject();
             }
             if (this.descriptors != null) {
                 data.descriptors = this.descriptors.map((item: Descriptor) => item.toObject());
             }
             return data;
         }
         serialize(): Uint8Array;
         serialize(w: pb_1.BinaryWriter): void;
         serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
             const writer = w || new pb_1.BinaryWriter();
             if (typeof this.scheme === "string" && this.scheme.length)
                 writer.writeString(1, this.scheme);
             if (this.package !== undefined)
                 writer.writeMessage(2, this.package, () => this.package.serialize(writer));
             if (this.descriptors !== undefined)
                 writer.writeRepeatedMessage(3, this.descriptors, (item: Descriptor) => item.serialize(writer));
             if (!w)
                 return writer.getResultBuffer();
         }
         static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Symbol {
             const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Symbol();
             while (reader.nextField()) {
                 if (reader.isEndGroup())
                     break;
                 switch (reader.getFieldNumber()) {
                     case 1:
                         message.scheme = reader.readString();
                         break;
                     case 2:
                         reader.readMessage(message.package, () => message.package = Package.deserialize(reader));
                         break;
                     case 3:
                         reader.readMessage(message.descriptors, () => pb_1.Message.addToRepeatedWrapperField(message, 3, Descriptor.deserialize(reader), Descriptor));
                         break;
                     default: reader.skipField();
                 }
             }
             return message;
         }
         serializeBinary(): Uint8Array {
             return this.serialize();
         }
         static deserializeBinary(bytes: Uint8Array): Symbol {
             return Symbol.deserialize(bytes);
         }
     }
     export class Package extends pb_1.Message {
         constructor(data?: any[] | {
             manager?: string;
             name?: string;
             version?: string;
         }) {
             super();
             pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []);
             if (!Array.isArray(data) && typeof data == "object") {
                 if ("manager" in data && data.manager != undefined) {
                     this.manager = data.manager;
                 }
                 if ("name" in data && data.name != undefined) {
                     this.name = data.name;
                 }
                 if ("version" in data && data.version != undefined) {
                     this.version = data.version;
                 }
             }
         }
         get manager() {
             return pb_1.Message.getField(this, 1) as string;
         }
         set manager(value: string) {
             pb_1.Message.setField(this, 1, value);
         }
         get name() {
             return pb_1.Message.getField(this, 2) as string;
         }
         set name(value: string) {
             pb_1.Message.setField(this, 2, value);
         }
         get version() {
             return pb_1.Message.getField(this, 3) as string;
         }
         set version(value: string) {
             pb_1.Message.setField(this, 3, value);
         }
         static fromObject(data: {
             manager?: string;
             name?: string;
             version?: string;
         }) {
             const message = new Package({});
             if (data.manager != null) {
                 message.manager = data.manager;
             }
             if (data.name != null) {
                 message.name = data.name;
             }
             if (data.version != null) {
                 message.version = data.version;
             }
             return message;
         }
         toObject() {
             const data: {
                 manager?: string;
                 name?: string;
                 version?: string;
             } = {};
             if (this.manager != null) {
                 data.manager = this.manager;
             }
             if (this.name != null) {
                 data.name = this.name;
             }
             if (this.version != null) {
                 data.version = this.version;
             }
             return data;
         }
         serialize(): Uint8Array;
         serialize(w: pb_1.BinaryWriter): void;
         serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
             const writer = w || new pb_1.BinaryWriter();
             if (typeof this.manager === "string" && this.manager.length)
                 writer.writeString(1, this.manager);
             if (typeof this.name === "string" && this.name.length)
                 writer.writeString(2, this.name);
             if (typeof this.version === "string" && this.version.length)
                 writer.writeString(3, this.version);
             if (!w)
                 return writer.getResultBuffer();
         }
         static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Package {
             const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Package();
             while (reader.nextField()) {
                 if (reader.isEndGroup())
                     break;
                 switch (reader.getFieldNumber()) {
                     case 1:
                         message.manager = reader.readString();
                         break;
                     case 2:
                         message.name = reader.readString();
                         break;
                     case 3:
                         message.version = reader.readString();
                         break;
                     default: reader.skipField();
                 }
             }
             return message;
         }
         serializeBinary(): Uint8Array {
             return this.serialize();
         }
         static deserializeBinary(bytes: Uint8Array): Package {
             return Package.deserialize(bytes);
         }
     }
     export class Descriptor extends pb_1.Message {
         constructor(data?: any[] | {
             name?: string;
             disambiguator?: string;
             suffix?: Descriptor.Suffix;
         }) {
             super();
             pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []);
             if (!Array.isArray(data) && typeof data == "object") {
                 if ("name" in data && data.name != undefined) {
                     this.name = data.name;
                 }
                 if ("disambiguator" in data && data.disambiguator != undefined) {
                     this.disambiguator = data.disambiguator;
                 }
                 if ("suffix" in data && data.suffix != undefined) {
                     this.suffix = data.suffix;
                 }
             }
         }
         get name() {
             return pb_1.Message.getField(this, 1) as string;
         }
         set name(value: string) {
             pb_1.Message.setField(this, 1, value);
         }
         get disambiguator() {
             return pb_1.Message.getField(this, 2) as string;
         }
         set disambiguator(value: string) {
             pb_1.Message.setField(this, 2, value);
         }
         get suffix() {
             return pb_1.Message.getField(this, 3) as Descriptor.Suffix;
         }
         set suffix(value: Descriptor.Suffix) {
             pb_1.Message.setField(this, 3, value);
         }
         static fromObject(data: {
             name?: string;
             disambiguator?: string;
             suffix?: Descriptor.Suffix;
         }) {
             const message = new Descriptor({});
             if (data.name != null) {
                 message.name = data.name;
             }
             if (data.disambiguator != null) {
                 message.disambiguator = data.disambiguator;
             }
             if (data.suffix != null) {
                 message.suffix = data.suffix;
             }
             return message;
         }
         toObject() {
             const data: {
                 name?: string;
                 disambiguator?: string;
                 suffix?: Descriptor.Suffix;
             } = {};
             if (this.name != null) {
                 data.name = this.name;
             }
             if (this.disambiguator != null) {
                 data.disambiguator = this.disambiguator;
             }
             if (this.suffix != null) {
                 data.suffix = this.suffix;
             }
             return data;
         }
         serialize(): Uint8Array;
         serialize(w: pb_1.BinaryWriter): void;
         serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
             const writer = w || new pb_1.BinaryWriter();
             if (typeof this.name === "string" && this.name.length)
                 writer.writeString(1, this.name);
             if (typeof this.disambiguator === "string" && this.disambiguator.length)
                 writer.writeString(2, this.disambiguator);
             if (this.suffix !== undefined)
                 writer.writeEnum(3, this.suffix);
             if (!w)
                 return writer.getResultBuffer();
         }
         static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Descriptor {
             const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Descriptor();
             while (reader.nextField()) {
                 if (reader.isEndGroup())
                     break;
                 switch (reader.getFieldNumber()) {
                     case 1:
                         message.name = reader.readString();
                         break;
                     case 2:
                         message.disambiguator = reader.readString();
                         break;
                     case 3:
                         message.suffix = reader.readEnum();
                         break;
                     default: reader.skipField();
                 }
             }
             return message;
         }
         serializeBinary(): Uint8Array {
             return this.serialize();
         }
         static deserializeBinary(bytes: Uint8Array): Descriptor {
             return Descriptor.deserialize(bytes);
         }
     }
     export namespace Descriptor {
         export enum Suffix {
             UnspecifiedSuffix = 0,
             Package = 1,
             Type = 2,
             Term = 3,
             Method = 4,
             TypeParameter = 5,
             Parameter = 6,
             Meta = 7,
             Local = 8
         }
     }
     export class SymbolInformation extends pb_1.Message {
         constructor(data?: any[] | {
             symbol?: string;
             documentation?: string[];
             relationships?: Relationship[];
         }) {
             super();
             pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [3, 4], []);
             if (!Array.isArray(data) && typeof data == "object") {
                 if ("symbol" in data && data.symbol != undefined) {
                     this.symbol = data.symbol;
                 }
                 if ("documentation" in data && data.documentation != undefined) {
                     this.documentation = data.documentation;
                 }
                 if ("relationships" in data && data.relationships != undefined) {
                     this.relationships = data.relationships;
                 }
             }
         }
         get symbol() {
             return pb_1.Message.getField(this, 1) as string;
         }
         set symbol(value: string) {
             pb_1.Message.setField(this, 1, value);
         }
         get documentation() {
             return pb_1.Message.getField(this, 3) as string[];
         }
         set documentation(value: string[]) {
             pb_1.Message.setField(this, 3, value);
         }
         get relationships() {
             return pb_1.Message.getRepeatedWrapperField(this, Relationship, 4) as Relationship[];
         }
         set relationships(value: Relationship[]) {
             pb_1.Message.setRepeatedWrapperField(this, 4, value);
         }
         static fromObject(data: {
             symbol?: string;
             documentation?: string[];
             relationships?: ReturnType<typeof Relationship.prototype.toObject>[];
         }) {
             const message = new SymbolInformation({});
             if (data.symbol != null) {
                 message.symbol = data.symbol;
             }
             if (data.documentation != null) {
                 message.documentation = data.documentation;
             }
             if (data.relationships != null) {
                 message.relationships = data.relationships.map(item => Relationship.fromObject(item));
             }
             return message;
         }
         toObject() {
             const data: {
                 symbol?: string;
                 documentation?: string[];
                 relationships?: ReturnType<typeof Relationship.prototype.toObject>[];
             } = {};
             if (this.symbol != null) {
                 data.symbol = this.symbol;
             }
             if (this.documentation != null) {
                 data.documentation = this.documentation;
             }
             if (this.relationships != null) {
                 data.relationships = this.relationships.map((item: Relationship) => item.toObject());
             }
             return data;
         }
         serialize(): Uint8Array;
         serialize(w: pb_1.BinaryWriter): void;
         serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
             const writer = w || new pb_1.BinaryWriter();
             if (typeof this.symbol === "string" && this.symbol.length)
                 writer.writeString(1, this.symbol);
             if (this.documentation !== undefined)
                 writer.writeRepeatedString(3, this.documentation);
             if (this.relationships !== undefined)
                 writer.writeRepeatedMessage(4, this.relationships, (item: Relationship) => item.serialize(writer));
             if (!w)
                 return writer.getResultBuffer();
         }
         static deserialize(bytes: Uint8Array | pb_1.BinaryReader): SymbolInformation {
             const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new SymbolInformation();
             while (reader.nextField()) {
                 if (reader.isEndGroup())
                     break;
                 switch (reader.getFieldNumber()) {
                     case 1:
                         message.symbol = reader.readString();
                         break;
                     case 3:
                         pb_1.Message.addToRepeatedField(message, 3, reader.readString());
                         break;
                     case 4:
                         reader.readMessage(message.relationships, () => pb_1.Message.addToRepeatedWrapperField(message, 4, Relationship.deserialize(reader), Relationship));
                         break;
                     default: reader.skipField();
                 }
             }
             return message;
         }
         serializeBinary(): Uint8Array {
             return this.serialize();
         }
         static deserializeBinary(bytes: Uint8Array): SymbolInformation {
             return SymbolInformation.deserialize(bytes);
         }
     }
     export class Relationship extends pb_1.Message {
         constructor(data?: any[] | {
             symbol?: string;
             is_reference?: boolean;
             is_implementation?: boolean;
             is_type_definition?: boolean;
         }) {
             super();
             pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []);
             if (!Array.isArray(data) && typeof data == "object") {
                 if ("symbol" in data && data.symbol != undefined) {
                     this.symbol = data.symbol;
                 }
                 if ("is_reference" in data && data.is_reference != undefined) {
                     this.is_reference = data.is_reference;
                 }
                 if ("is_implementation" in data && data.is_implementation != undefined) {
                     this.is_implementation = data.is_implementation;
                 }
                 if ("is_type_definition" in data && data.is_type_definition != undefined) {
                     this.is_type_definition = data.is_type_definition;
                 }
             }
         }
         get symbol() {
             return pb_1.Message.getField(this, 1) as string;
         }
         set symbol(value: string) {
             pb_1.Message.setField(this, 1, value);
         }
         get is_reference() {
             return pb_1.Message.getField(this, 2) as boolean;
         }
         set is_reference(value: boolean) {
             pb_1.Message.setField(this, 2, value);
         }
         get is_implementation() {
             return pb_1.Message.getField(this, 3) as boolean;
         }
         set is_implementation(value: boolean) {
             pb_1.Message.setField(this, 3, value);
         }
         get is_type_definition() {
             return pb_1.Message.getField(this, 4) as boolean;
         }
         set is_type_definition(value: boolean) {
             pb_1.Message.setField(this, 4, value);
         }
         static fromObject(data: {
             symbol?: string;
             is_reference?: boolean;
             is_implementation?: boolean;
             is_type_definition?: boolean;
         }) {
             const message = new Relationship({});
             if (data.symbol != null) {
                 message.symbol = data.symbol;
             }
             if (data.is_reference != null) {
                 message.is_reference = data.is_reference;
             }
             if (data.is_implementation != null) {
                 message.is_implementation = data.is_implementation;
             }
             if (data.is_type_definition != null) {
                 message.is_type_definition = data.is_type_definition;
             }
             return message;
         }
         toObject() {
             const data: {
                 symbol?: string;
                 is_reference?: boolean;
                 is_implementation?: boolean;
                 is_type_definition?: boolean;
             } = {};
             if (this.symbol != null) {
                 data.symbol = this.symbol;
             }
             if (this.is_reference != null) {
                 data.is_reference = this.is_reference;
             }
             if (this.is_implementation != null) {
                 data.is_implementation = this.is_implementation;
             }
             if (this.is_type_definition != null) {
                 data.is_type_definition = this.is_type_definition;
             }
             return data;
         }
         serialize(): Uint8Array;
         serialize(w: pb_1.BinaryWriter): void;
         serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
             const writer = w || new pb_1.BinaryWriter();
             if (typeof this.symbol === "string" && this.symbol.length)
                 writer.writeString(1, this.symbol);
             if (this.is_reference !== undefined)
                 writer.writeBool(2, this.is_reference);
             if (this.is_implementation !== undefined)
                 writer.writeBool(3, this.is_implementation);
             if (this.is_type_definition !== undefined)
                 writer.writeBool(4, this.is_type_definition);
             if (!w)
                 return writer.getResultBuffer();
         }
         static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Relationship {
             const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Relationship();
             while (reader.nextField()) {
                 if (reader.isEndGroup())
                     break;
                 switch (reader.getFieldNumber()) {
                     case 1:
                         message.symbol = reader.readString();
                         break;
                     case 2:
                         message.is_reference = reader.readBool();
                         break;
                     case 3:
                         message.is_implementation = reader.readBool();
                         break;
                     case 4:
                         message.is_type_definition = reader.readBool();
                         break;
                     default: reader.skipField();
                 }
             }
             return message;
         }
         serializeBinary(): Uint8Array {
             return this.serialize();
         }
         static deserializeBinary(bytes: Uint8Array): Relationship {
             return Relationship.deserialize(bytes);
         }
     }
     export class Occurrence extends pb_1.Message {
         constructor(data?: any[] | {
             range?: number[];
             symbol?: string;
             symbol_roles?: number;
             override_documentation?: string[];
             syntax_kind?: SyntaxKind;
             diagnostics?: Diagnostic[];
         }) {
             super();
             pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [1, 4, 6], []);
             if (!Array.isArray(data) && typeof data == "object") {
                 if ("range" in data && data.range != undefined) {
                     this.range = data.range;
                 }
                 if ("symbol" in data && data.symbol != undefined) {
                     this.symbol = data.symbol;
                 }
                 if ("symbol_roles" in data && data.symbol_roles != undefined) {
                     this.symbol_roles = data.symbol_roles;
                 }
                 if ("override_documentation" in data && data.override_documentation != undefined) {
                     this.override_documentation = data.override_documentation;
                 }
                 if ("syntax_kind" in data && data.syntax_kind != undefined) {
                     this.syntax_kind = data.syntax_kind;
                 }
                 if ("diagnostics" in data && data.diagnostics != undefined) {
                     this.diagnostics = data.diagnostics;
                 }
             }
         }
         get range() {
             return pb_1.Message.getField(this, 1) as number[];
         }
         set range(value: number[]) {
             pb_1.Message.setField(this, 1, value);
         }
         get symbol() {
             return pb_1.Message.getField(this, 2) as string;
         }
         set symbol(value: string) {
             pb_1.Message.setField(this, 2, value);
         }
         get symbol_roles() {
             return pb_1.Message.getField(this, 3) as number;
         }
         set symbol_roles(value: number) {
             pb_1.Message.setField(this, 3, value);
         }
         get override_documentation() {
             return pb_1.Message.getField(this, 4) as string[];
         }
         set override_documentation(value: string[]) {
             pb_1.Message.setField(this, 4, value);
         }
         get syntax_kind() {
             return pb_1.Message.getField(this, 5) as SyntaxKind;
         }
         set syntax_kind(value: SyntaxKind) {
             pb_1.Message.setField(this, 5, value);
         }
         get diagnostics() {
             return pb_1.Message.getRepeatedWrapperField(this, Diagnostic, 6) as Diagnostic[];
         }
         set diagnostics(value: Diagnostic[]) {
             pb_1.Message.setRepeatedWrapperField(this, 6, value);
         }
         static fromObject(data: {
             range?: number[];
             symbol?: string;
             symbol_roles?: number;
             override_documentation?: string[];
             syntax_kind?: SyntaxKind;
             diagnostics?: ReturnType<typeof Diagnostic.prototype.toObject>[];
         }) {
             const message = new Occurrence({});
             if (data.range != null) {
                 message.range = data.range;
             }
             if (data.symbol != null) {
                 message.symbol = data.symbol;
             }
             if (data.symbol_roles != null) {
                 message.symbol_roles = data.symbol_roles;
             }
             if (data.override_documentation != null) {
                 message.override_documentation = data.override_documentation;
             }
             if (data.syntax_kind != null) {
                 message.syntax_kind = data.syntax_kind;
             }
             if (data.diagnostics != null) {
                 message.diagnostics = data.diagnostics.map(item => Diagnostic.fromObject(item));
             }
             return message;
         }
         toObject() {
             const data: {
                 range?: number[];
                 symbol?: string;
                 symbol_roles?: number;
                 override_documentation?: string[];
                 syntax_kind?: SyntaxKind;
                 diagnostics?: ReturnType<typeof Diagnostic.prototype.toObject>[];
             } = {};
             if (this.range != null) {
                 data.range = this.range;
             }
             if (this.symbol != null) {
                 data.symbol = this.symbol;
             }
             if (this.symbol_roles != null) {
                 data.symbol_roles = this.symbol_roles;
             }
             if (this.override_documentation != null) {
                 data.override_documentation = this.override_documentation;
             }
             if (this.syntax_kind != null) {
                 data.syntax_kind = this.syntax_kind;
             }
             if (this.diagnostics != null) {
                 data.diagnostics = this.diagnostics.map((item: Diagnostic) => item.toObject());
             }
             return data;
         }
         serialize(): Uint8Array;
         serialize(w: pb_1.BinaryWriter): void;
         serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
             const writer = w || new pb_1.BinaryWriter();
             if (this.range !== undefined)
                 writer.writePackedInt32(1, this.range);
             if (typeof this.symbol === "string" && this.symbol.length)
                 writer.writeString(2, this.symbol);
             if (this.symbol_roles !== undefined)
                 writer.writeInt32(3, this.symbol_roles);
             if (this.override_documentation !== undefined)
                 writer.writeRepeatedString(4, this.override_documentation);
             if (this.syntax_kind !== undefined)
                 writer.writeEnum(5, this.syntax_kind);
             if (this.diagnostics !== undefined)
                 writer.writeRepeatedMessage(6, this.diagnostics, (item: Diagnostic) => item.serialize(writer));
             if (!w)
                 return writer.getResultBuffer();
         }
         static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Occurrence {
             const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Occurrence();
             while (reader.nextField()) {
                 if (reader.isEndGroup())
                     break;
                 switch (reader.getFieldNumber()) {
                     case 1:
                         message.range = reader.readPackedInt32();
                         break;
                     case 2:
                         message.symbol = reader.readString();
                         break;
                     case 3:
                         message.symbol_roles = reader.readInt32();
                         break;
                     case 4:
                         pb_1.Message.addToRepeatedField(message, 4, reader.readString());
                         break;
                     case 5:
                         message.syntax_kind = reader.readEnum();
                         break;
                     case 6:
                         reader.readMessage(message.diagnostics, () => pb_1.Message.addToRepeatedWrapperField(message, 6, Diagnostic.deserialize(reader), Diagnostic));
                         break;
                     default: reader.skipField();
                 }
             }
             return message;
         }
         serializeBinary(): Uint8Array {
             return this.serialize();
         }
         static deserializeBinary(bytes: Uint8Array): Occurrence {
             return Occurrence.deserialize(bytes);
         }
     }
     export class Diagnostic extends pb_1.Message {
         constructor(data?: any[] | {
             severity?: Severity;
             code?: string;
             message?: string;
             source?: string;
             tags?: DiagnosticTag[];
         }) {
             super();
             pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [5], []);
             if (!Array.isArray(data) && typeof data == "object") {
                 if ("severity" in data && data.severity != undefined) {
                     this.severity = data.severity;
                 }
                 if ("code" in data && data.code != undefined) {
                     this.code = data.code;
                 }
                 if ("message" in data && data.message != undefined) {
                     this.message = data.message;
                 }
                 if ("source" in data && data.source != undefined) {
                     this.source = data.source;
                 }
                 if ("tags" in data && data.tags != undefined) {
                     this.tags = data.tags;
                 }
             }
         }
         get severity() {
             return pb_1.Message.getField(this, 1) as Severity;
         }
         set severity(value: Severity) {
             pb_1.Message.setField(this, 1, value);
         }
         get code() {
             return pb_1.Message.getField(this, 2) as string;
         }
         set code(value: string) {
             pb_1.Message.setField(this, 2, value);
         }
         get message() {
             return pb_1.Message.getField(this, 3) as string;
         }
         set message(value: string) {
             pb_1.Message.setField(this, 3, value);
         }
         get source() {
             return pb_1.Message.getField(this, 4) as string;
         }
         set source(value: string) {
             pb_1.Message.setField(this, 4, value);
         }
         get tags() {
             return pb_1.Message.getField(this, 5) as DiagnosticTag[];
         }
         set tags(value: DiagnosticTag[]) {
             pb_1.Message.setField(this, 5, value);
         }
         static fromObject(data: {
             severity?: Severity;
             code?: string;
             message?: string;
             source?: string;
             tags?: DiagnosticTag[];
         }) {
             const message = new Diagnostic({});
             if (data.severity != null) {
                 message.severity = data.severity;
             }
             if (data.code != null) {
                 message.code = data.code;
             }
             if (data.message != null) {
                 message.message = data.message;
             }
             if (data.source != null) {
                 message.source = data.source;
             }
             if (data.tags != null) {
                 message.tags = data.tags;
             }
             return message;
         }
         toObject() {
             const data: {
                 severity?: Severity;
                 code?: string;
                 message?: string;
                 source?: string;
                 tags?: DiagnosticTag[];
             } = {};
             if (this.severity != null) {
                 data.severity = this.severity;
             }
             if (this.code != null) {
                 data.code = this.code;
             }
             if (this.message != null) {
                 data.message = this.message;
             }
             if (this.source != null) {
                 data.source = this.source;
             }
             if (this.tags != null) {
                 data.tags = this.tags;
             }
             return data;
         }
         serialize(): Uint8Array;
         serialize(w: pb_1.BinaryWriter): void;
         serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
             const writer = w || new pb_1.BinaryWriter();
             if (this.severity !== undefined)
                 writer.writeEnum(1, this.severity);
             if (typeof this.code === "string" && this.code.length)
                 writer.writeString(2, this.code);
             if (typeof this.message === "string" && this.message.length)
                 writer.writeString(3, this.message);
             if (typeof this.source === "string" && this.source.length)
                 writer.writeString(4, this.source);
             if (this.tags !== undefined)
                 writer.writePackedEnum(5, this.tags);
             if (!w)
                 return writer.getResultBuffer();
         }
         static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Diagnostic {
             const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Diagnostic();
             while (reader.nextField()) {
                 if (reader.isEndGroup())
                     break;
                 switch (reader.getFieldNumber()) {
                     case 1:
                         message.severity = reader.readEnum();
                         break;
                     case 2:
                         message.code = reader.readString();
                         break;
                     case 3:
                         message.message = reader.readString();
                         break;
                     case 4:
                         message.source = reader.readString();
                         break;
                     case 5:
                         message.tags = reader.readPackedEnum();
                         break;
                     default: reader.skipField();
                 }
             }
             return message;
         }
         serializeBinary(): Uint8Array {
             return this.serialize();
         }
         static deserializeBinary(bytes: Uint8Array): Diagnostic {
             return Diagnostic.deserialize(bytes);
         }
     }
 }