@anysphere/scip-typescript/src/scip.ts

SCIP indexer for TypeScript and JavaScript

/**
 * Generated by the protoc-gen-ts.  DO NOT EDIT!
 * compiler version: 0.0.0
 * source: scip.proto
 * git: https://github.com/thesayyn/protoc-gen-ts
 *  */
import * as pb_1 from "google-protobuf";
export namespace scip {
    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,
        Comment = 1,
        PunctuationDelimiter = 2,
        PunctuationBracket = 3,
        Keyword = 4,
        IdentifierKeyword = 4,
        IdentifierOperator = 5,
        Identifier = 6,
        IdentifierBuiltin = 7,
        IdentifierNull = 8,
        IdentifierConstant = 9,
        IdentifierMutableGlobal = 10,
        IdentifierParameter = 11,
        IdentifierLocal = 12,
        IdentifierShadowed = 13,
        IdentifierNamespace = 14,
        IdentifierModule = 14,
        IdentifierFunction = 15,
        IdentifierFunctionDefinition = 16,
        IdentifierMacro = 17,
        IdentifierMacroDefinition = 18,
        IdentifierType = 19,
        IdentifierBuiltinType = 20,
        IdentifierAttribute = 21,
        RegexEscape = 22,
        RegexRepeated = 23,
        RegexWildcard = 24,
        RegexDelimiter = 25,
        RegexJoin = 26,
        StringLiteral = 27,
        StringLiteralEscape = 28,
        StringLiteralSpecial = 29,
        StringLiteralKey = 30,
        CharacterLiteral = 31,
        NumericLiteral = 32,
        BooleanLiteral = 33,
        Tag = 34,
        TagAttribute = 35,
        TagDelimiter = 36
    }
    export enum Severity {
        UnspecifiedSeverity = 0,
        Error = 1,
        Warning = 2,
        Information = 3,
        Hint = 4
    }
    export enum DiagnosticTag {
        UnspecifiedDiagnosticTag = 0,
        Unnecessary = 1,
        Deprecated = 2
    }
    export enum Language {
        UnspecifiedLanguage = 0,
        ABAP = 60,
        APL = 49,
        Ada = 39,
        Agda = 45,
        AsciiDoc = 86,
        Assembly = 58,
        Awk = 66,
        Bat = 68,
        BibTeX = 81,
        C = 34,
        COBOL = 59,
        CPP = 35,
        CSS = 26,
        CSharp = 1,
        Clojure = 8,
        Coffeescript = 21,
        CommonLisp = 9,
        Coq = 47,
        Dart = 3,
        Delphi = 57,
        Diff = 88,
        Dockerfile = 80,
        Dyalog = 50,
        Elixir = 17,
        Erlang = 18,
        FSharp = 42,
        Fish = 65,
        Flow = 24,
        Fortran = 56,
        Git_Commit = 91,
        Git_Config = 89,
        Git_Rebase = 92,
        Go = 33,
        Groovy = 7,
        HTML = 30,
        Hack = 20,
        Handlebars = 90,
        Haskell = 44,
        Idris = 46,
        Ini = 72,
        J = 51,
        JSON = 75,
        Java = 6,
        JavaScript = 22,
        JavaScriptReact = 93,
        Jsonnet = 76,
        Julia = 55,
        Kotlin = 4,
        LaTeX = 83,
        Lean = 48,
        Less = 27,
        Lua = 12,
        Makefile = 79,
        Markdown = 84,
        Matlab = 52,
        Nix = 77,
        OCaml = 41,
        Objective_C = 36,
        Objective_CPP = 37,
        PHP = 19,
        PLSQL = 70,
        Perl = 13,
        PowerShell = 67,
        Prolog = 71,
        Python = 15,
        R = 54,
        Racket = 11,
        Raku = 14,
        Razor = 62,
        ReST = 85,
        Ruby = 16,
        Rust = 40,
        SAS = 61,
        SCSS = 29,
        SML = 43,
        SQL = 69,
        Sass = 28,
        Scala = 5,
        Scheme = 10,
        ShellScript = 64,
        Skylark = 78,
        Swift = 2,
        TOML = 73,
        TeX = 82,
        TypeScript = 23,
        TypeScriptReact = 94,
        VisualBasic = 63,
        Vue = 25,
        Wolfram = 53,
        XML = 31,
        XSL = 32,
        YAML = 74,
        Zig = 38
    }
    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[] | {
            language?: string;
            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 ("language" in data && data.language != undefined) {
                    this.language = data.language;
                }
                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 language() {
            return pb_1.Message.getField(this, 4) as string;
        }
        set language(value: string) {
            pb_1.Message.setField(this, 4, value);
        }
        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: {
            language?: string;
            relative_path?: string;
            occurrences?: ReturnType<typeof Occurrence.prototype.toObject>[];
            symbols?: ReturnType<typeof SymbolInformation.prototype.toObject>[];
        }) {
            const message = new Document({});
            if (data.language != null) {
                message.language = data.language;
            }
            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: {
                language?: string;
                relative_path?: string;
                occurrences?: ReturnType<typeof Occurrence.prototype.toObject>[];
                symbols?: ReturnType<typeof SymbolInformation.prototype.toObject>[];
            } = {};
            if (this.language != null) {
                data.language = this.language;
            }
            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.language === "string" && this.language.length)
                writer.writeString(4, this.language);
            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 4:
                        message.language = reader.readString();
                        break;
                    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,
            Namespace = 1,
            Package = 1,
            Type = 2,
            Term = 3,
            Method = 4,
            TypeParameter = 5,
            Parameter = 6,
            Macro = 9,
            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;
            is_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;
                }
                if ("is_definition" in data && data.is_definition != undefined) {
                    this.is_definition = data.is_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);
        }
        get is_definition() {
            return pb_1.Message.getField(this, 5) as boolean;
        }
        set is_definition(value: boolean) {
            pb_1.Message.setField(this, 5, value);
        }
        static fromObject(data: {
            symbol?: string;
            is_reference?: boolean;
            is_implementation?: boolean;
            is_type_definition?: boolean;
            is_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;
            }
            if (data.is_definition != null) {
                message.is_definition = data.is_definition;
            }
            return message;
        }
        toObject() {
            const data: {
                symbol?: string;
                is_reference?: boolean;
                is_implementation?: boolean;
                is_type_definition?: boolean;
                is_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;
            }
            if (this.is_definition != null) {
                data.is_definition = this.is_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 (this.is_definition !== undefined)
                writer.writeBool(5, this.is_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;
                    case 5:
                        message.is_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_