protocol.d.ts - Sourcetree

import * as lsp from 'vscode-languageserver-protocol';
/**
 * An `Id` to identify a vertex or an edge.
 */
export declare type Id = number | string;
/**
 * An element in the graph.
 */
export interface Element {
    id: Id;
    type: ElementTypes;
}
export declare enum ElementTypes {
    vertex = "vertex",
    edge = "edge"
}
/**
 * All know vertices label values.
 */
export declare enum VertexLabels {
    metaData = "metaData",
    event = "$event",
    project = "project",
    range = "range",
    location = "location",
    document = "document",
    moniker = "moniker",
    packageInformation = "packageInformation",
    resultSet = "resultSet",
    documentSymbolResult = "documentSymbolResult",
    foldingRangeResult = "foldingRangeResult",
    documentLinkResult = "documentLinkResult",
    diagnosticResult = "diagnosticResult",
    declarationResult = "declarationResult",
    definitionResult = "definitionResult",
    typeDefinitionResult = "typeDefinitionResult",
    hoverResult = "hoverResult",
    referenceResult = "referenceResult",
    implementationResult = "implementationResult"
}
/**
 * Uris are currently stored as strings.
 */
export declare type Uri = string;
export interface V extends Element {
    type: ElementTypes.vertex;
    label: VertexLabels;
}
/**
 * The event kinds
 */
export declare enum EventKind {
    begin = "begin",
    end = "end"
}
/**
 * The event scopes
 */
export declare enum EventScope {
    project = "project",
    document = "document"
}
export interface Event extends V {
    label: VertexLabels.event;
    /**
     * The event kind.
     */
    kind: EventKind;
    /**
     * The event scope.
     */
    scope: EventScope;
}
export interface ProjectEvent extends Event {
    scope: EventScope.project;
    /**
     * The id of the project vertex.
     */
    data: Id;
}
export interface DocumentEvent extends Event {
    scope: EventScope.document;
    /**
     * The id of the document vertex.
     */
    data: Id;
}
/**
 * A result set acts as a hub to share n LSP request results
 * between different ranges.
 */
export interface ResultSet extends V {
    label: VertexLabels.resultSet;
}
/**
 * All know range tag literal types.
 */
export declare enum RangeTagTypes {
    declaration = "declaration",
    definition = "definition",
    reference = "reference",
    unknown = "unknown"
}
/**
 * The range represents a declaration.
 */
export interface DeclarationTag {
    /**
     * A type identifier for the declaration tag.
     */
    type: RangeTagTypes.declaration;
    /**
     * The text covered by the range.
     */
    text: string;
    /**
     * The symbol kind.
     */
    kind: lsp.SymbolKind;
    /**
     * Indicates if this symbol is deprecated.
     */
    deprecated?: boolean;
    /**
     * The full range of the declaration not including leading/trailing whitespace but everything else, e.g comments and code.
     * The range must be included in fullRange.
     */
    fullRange: lsp.Range;
    /**
     * Optional detail information for the declaration.
     */
    detail?: string;
}
/**
 * The range represents a definition
 */
export interface DefinitionTag {
    /**
     * A type identifier for the declaration tag.
     */
    type: RangeTagTypes.definition;
    /**
     * The text covered by the range
     */
    text: string;
    /**
     * The symbol kind.
     */
    kind: lsp.SymbolKind;
    /**
     * Indicates if this symbol is deprecated.
     */
    deprecated?: boolean;
    /**
     * The full range of the definition not including leading/trailing whitespace but everything else, e.g comments and code.
     * The range must be included in fullRange.
     */
    fullRange: lsp.Range;
    /**
     * Optional detail information for the definition.
     */
    detail?: string;
}
/**
 * The range represents a reference.
 */
export interface ReferenceTag {
    /**
     * A type identifier for the reference tag.
     */
    type: RangeTagTypes.reference;
    /**
     * The text covered by the range.
     */
    text: string;
}
/**
 * The type of the range is unknown.
 */
export interface UnknownTag {
    /**
     * A type identifier for the unknown tag.
     */
    type: RangeTagTypes.unknown;
    /**
     * The text covered by the range.
     */
    text: string;
}
/**
 * All available range tag types.
 */
export declare type RangeTag = DefinitionTag | DeclarationTag | ReferenceTag | UnknownTag;
/**
 * A vertex representing a range inside a document.
 */
export interface Range extends V, lsp.Range {
    label: VertexLabels.range;
    /**
     * Some optional meta data for the range.
     */
    tag?: RangeTag;
}
/**
 * The id type of the range is a normal id.
 */
export declare type RangeId = Id;
/**
 * A range representing a definition.
 */
export interface DefinitionRange extends Range {
    /**
     * The definition meta data.
     */
    tag: DefinitionTag;
}
/**
 * A range representing a declaration.
 */
export interface DeclarationRange extends Range {
    /**
     * The declaration meta data.
     */
    tag: DeclarationTag;
}
/**
 * A range representing a reference.
 */
export interface ReferenceRange extends Range {
    /**
     * The reference meta data.
     */
    tag: ReferenceTag;
}
/**
 * A location emittable in LSIF. It has no uri since
 * like ranges locations should be connected to a document
 * using a `contains`edge.
 */
export interface Location extends V {
    /**
     * The label property.
     */
    label: VertexLabels.location;
    /**
     * The location's range
     */
    range: lsp.Range;
}
/**
 * The meta data vertex.
 */
export interface MetaData extends V {
    /**
     * The label property.
     */
    label: VertexLabels.metaData;
    /**
     * The version of the LSIF format using semver notation. See https://semver.org/
     */
    version: string;
    /**
     * The project root (in form of a URI) used to compute this dump.
     */
    projectRoot: Uri;
    /**
     * The string encoding used to compute line and character values in
     * positions and ranges. Currently only 'utf-16' is support due to the
     * limitations in LSP.
     */
    positionEncoding: 'utf-16';
    /**
     * Information about the tool that created the dump
     */
    toolInfo?: {
        name: string;
        version?: string;
        args?: string[];
    };
}
/**
 * A project vertex.
 */
export interface Project extends V {
    /**
     * The label property.
     */
    label: VertexLabels.project;
    /**
     * The project kind like 'typescript' or 'csharp'. See also the language ids
     * in the [specification](https://microsoft.github.io/language-server-protocol/specification)
     */
    kind: string;
    /**
     * The resource URI of the project file.
     */
    resource?: Uri;
    /**
     * Optional the content of the project file, `base64` encoded.
     */
    contents?: string;
}
export declare type DocumentId = Id;
/**
 * A vertex representing a document in the project
 */
export interface Document extends V {
    /**
     * The label property.
     */
    label: VertexLabels.document;
    /**
     * The Uri of the document.
     */
    uri: Uri;
    /**
     * The document's language Id as defined in the LSP
     * (https://microsoft.github.io/language-server-protocol/specification)
     */
    languageId: string;
    /**
     * Optional the content of the document, `based64` encoded
     */
    contents?: string;
}
/**
 * The moniker kind.
 */
export declare enum MonikerKind {
    /**
     * The moniker represent a symbol that is imported into a project
     */
    import = "import",
    /**
     * The moniker represents a symbol that is exported from a project
     */
    export = "export",
    /**
     * The moniker represents a symbol that is local to a project (e.g. a local
     * variable of a function, a class not visible outside the project, ...)
     */
    local = "local"
}
export interface Moniker extends V {
    label: VertexLabels.moniker;
    /**
     * The scheme of the moniker. For example tsc or .Net
     */
    scheme: string;
    /**
     * The identifier of the moniker. The value is opaque in LSIF however
     * schema owners are allowed to define the structure if they want.
     */
    identifier: string;
    /**
     * The moniker kind if known.
     */
    kind?: MonikerKind;
}
export interface PackageInformation extends V {
    label: VertexLabels.packageInformation;
    /**
     * The package name
     */
    name: string;
    /**
     * The package manager
     */
    manager: string;
    /**
     * A uri pointing to the location of the file describing the package.
     */
    uri?: Uri;
    /**
     * Optional the content of the document, `based64` encoded
     */
    contents?: string;
    /**
     * The package version if available
     */
    version?: string;
    /**
     * Otional information about the repository containing the source of the package
     */
    repository?: {
        /**
         * The repository type. For example GIT
         */
        type: string;
        /**
         * The URL to the repository
         */
        url: string;
        /**
         * A commitId if available.
         */
        commitId?: string;
    };
}
/**
 * A range based document symbol. This allows to reuse already
 * emitted ranges with a `declaration` tag in a document symbol
 * result.
 */
export interface RangeBasedDocumentSymbol {
    /**
     * The range to reference.
     */
    id: RangeId;
    /**
     * The child symbols.
     */
    children?: RangeBasedDocumentSymbol[];
}
/**
 * A vertex representing the document symbol result.
 */
export interface DocumentSymbolResult extends V {
    label: VertexLabels.documentSymbolResult;
    result: lsp.DocumentSymbol[] | RangeBasedDocumentSymbol[];
}
/**
 * A vertex representing a diagnostic result.
 */
export interface DiagnosticResult extends V {
    /**
     * The label property.
     */
    label: VertexLabels.diagnosticResult;
    /**
     * The diagnostics.
     */
    result: lsp.Diagnostic[];
}
/**
 * A vertex representing a folding range result.
 */
export interface FoldingRangeResult extends V {
    /**
     * The label property.
     */
    label: VertexLabels.foldingRangeResult;
    /**
     * The actual folding ranges.
     */
    result: lsp.FoldingRange[];
}
/**
 * A vertex representing a document link result.
 */
export interface DocumentLinkResult extends V {
    /**
     * The label property.
     */
    label: VertexLabels.documentLinkResult;
    /**
     * The actual document links.
     */
    result: lsp.DocumentLink[];
}
export interface DeclarationResult extends V {
    /**
     * The label property.
     */
    label: VertexLabels.declarationResult;
}
/**
 * A vertex representing a definition result.
 */
export interface DefinitionResult extends V {
    /**
     * The label property.
     */
    label: VertexLabels.definitionResult;
}
/**
 * A vertex representing a type definition result.
 */
export interface TypeDefinitionResult extends V {
    /**
     * The label property.
     */
    label: VertexLabels.typeDefinitionResult;
}
/**
 * A vertex representing a reference result.
 */
export interface ReferenceResult extends V {
    /**
     * The label property.
     */
    label: VertexLabels.referenceResult;
}
/**
 * A vertex representing an implementation result.
 */
export interface ImplementationResult extends V {
    /**
     * The label property.
     */
    label: VertexLabels.implementationResult;
}
/**
 * A vertex representing a Hover.
 *
 * Extends the `Hover` type defined in LSP.
 */
export interface HoverResult extends V {
    /**
     * The label property.
     */
    label: VertexLabels.hoverResult;
    /**
     * The hover result. This is the normal LSP hover result.
     */
    result: lsp.Hover;
}
/**
 * All available vertex types
 */
export declare type Vertex = MetaData | ProjectEvent | DocumentEvent | Project | Document | Moniker | PackageInformation | ResultSet | Range | DocumentSymbolResult | FoldingRangeResult | DocumentLinkResult | DiagnosticResult | DefinitionResult | DeclarationResult | TypeDefinitionResult | HoverResult | ReferenceResult | ImplementationResult;
export declare enum EdgeLabels {
    contains = "contains",
    item = "item",
    next = "next",
    moniker = "moniker",
    nextMoniker = "nextMoniker",
    packageInformation = "packageInformation",
    textDocument_documentSymbol = "textDocument/documentSymbol",
    textDocument_foldingRange = "textDocument/foldingRange",
    textDocument_documentLink = "textDocument/documentLink",
    textDocument_diagnostic = "textDocument/diagnostic",
    textDocument_definition = "textDocument/definition",
    textDocument_declaration = "textDocument/declaration",
    textDocument_typeDefinition = "textDocument/typeDefinition",
    textDocument_hover = "textDocument/hover",
    textDocument_references = "textDocument/references",
    textDocument_implementation = "textDocument/implementation"
}
/**
 * A common base type of all edge types. The type parameters `S` and `T` are for typing and
 * documentation purpose only. An edge never holds a direct reference to a vertex. They are
 * referenced by `Id`.
 */
export interface E11<S extends V, T extends V, K extends EdgeLabels> extends Element {
    _?: [S, T];
    id: Id;
    type: ElementTypes.edge;
    label: K;
    /**
     * The id of the from Vertex.
     */
    outV: Id;
    /**
     * The id of the to Vertex.
     */
    inV: Id;
}
export interface E1N<S extends V, T extends V, K extends EdgeLabels> extends Element {
    _?: [S, T];
    id: Id;
    type: ElementTypes.edge;
    label: K;
    /**
     * The id of the from vertex.
     */
    outV: Id;
    /**
     * The ids of the to vertices.
     */
    inVs: Id[];
}
export declare type E<S extends V, T extends V, K extends EdgeLabels> = E11<S, T, K> | E1N<S, T, K>;
export declare enum ItemEdgeProperties {
    declarations = "declarations",
    definitions = "definitions",
    references = "references",
    referenceResults = "referenceResults",
    implementationResults = "implementationResults"
}
export interface ItemEdge<S extends V, T extends V> extends E1N<S, T, EdgeLabels.item> {
    document: Id;
    property?: ItemEdgeProperties;
}
/**
 * An edge expressing containment relationship. The relationship exist between:
 *
 * - `Project` -> `Document`
 * - `Package` -> `Document`
 * - `Document` -> `Range`
 */
export declare type contains = E1N<Project, Document, EdgeLabels.contains> | E1N<Document, Range, EdgeLabels.contains>;
/**
 * An edge associating a range with a result set. The relationship exists between:
 *
 * - `Range` -> `ResultSet`
 * - `ResultSet` -> `ResultSet`
 */
export declare type next = E11<Range, ResultSet, EdgeLabels.next>;
/**
 * An edge representing a item in a result set. The relationship exists between:
 *
 * - `ReferenceResult` -> `Range[]`
 * - `ReferenceResult` -> `ReferenceResult[]`
 */
export declare type item = ItemEdge<DeclarationResult, Range> | ItemEdge<DefinitionResult, Range> | ItemEdge<TypeDefinitionResult, Range> | ItemEdge<ReferenceResult, Range> | ItemEdge<ReferenceResult, ReferenceResult> | ItemEdge<ImplementationResult, Range> | ItemEdge<ImplementationResult, ImplementationResult>;
/**
 * An edge associating a range with a moniker. The relationship exists between:
 *
 * - `Range` -> `Moniker`
 * - `ResultSet` -> `Moniker`
 * - `DeclarationResult` -> `Moniker`
 * - `DefinitionResult` -> `Moniker`
 * - `TypeDefinitionResult` -> `Moniker`
 * - `ReferenceResult` -> `Moniker`
 * - `ImplementationResult` -> `Moniker`
 */
export declare type moniker = E11<Range, Moniker, EdgeLabels.moniker> | E11<ResultSet, Moniker, EdgeLabels.moniker> | E11<DeclarationResult, Moniker, EdgeLabels.moniker> | E11<DefinitionResult, Moniker, EdgeLabels.moniker> | E11<TypeDefinitionResult, Moniker, EdgeLabels.moniker> | E11<ReferenceResult, Moniker, EdgeLabels.moniker> | E11<ImplementationResult, Moniker, EdgeLabels.moniker>;
/**
 * An edge associating a moniker with another moniker. The relationship exists between:
 *
 * - `Moniker` -> `Moniker`
 */
export declare type nextMoniker = E11<Moniker, Moniker, EdgeLabels.nextMoniker>;
/**
 * An edge associating a moniker with a package information. The relationship exists between:
 *
 * - `Moniker` -> `PackageInformation`
 */
export declare type packageInformation = E11<Moniker, PackageInformation, EdgeLabels.packageInformation>;
/**
 * An edge representing a `textDocument/documentSymbol` relationship. The relationship exists between:
 *
 * - `Document` -> `DocumentSymbolResult`
 */
export declare type textDocument_documentSymbol = E11<Document, DocumentSymbolResult, EdgeLabels.textDocument_documentSymbol>;
/**
 * An edge representing a `textDocument/foldingRange` relationship. The relationship exists between:
 *
 * - `Document` -> `FoldingRangeResult`
 */
export declare type textDocument_foldingRange = E11<Document, FoldingRangeResult, EdgeLabels.textDocument_foldingRange>;
/**
 * An edge representing a `textDocument/documentLink` relationship. The relationship exists between:
 *
 * - `Document` -> `DocumentLinkResult`
 */
export declare type textDocument_documentLink = E11<Document, DocumentLinkResult, EdgeLabels.textDocument_documentLink>;
/**
 * An edge representing a `textDocument/diagnostic` relationship. The relationship exists between:
 *
 * - `Project` -> `DiagnosticResult`
 * - `Document` -> `DiagnosticResult`
 */
export declare type textDocument_diagnostic = E11<Project, DiagnosticResult, EdgeLabels.textDocument_diagnostic> | E11<Document, DiagnosticResult, EdgeLabels.textDocument_diagnostic>;
/**
 * An edge representing a declaration relationship. The relationship exists between:
 *
 * - `Range` -> `DefinitionResult`
 * - `ResultSet` -> `DefinitionResult`
 */
export declare type textDocument_declaration = E11<Range, DeclarationResult, EdgeLabels.textDocument_declaration> | E11<ResultSet, DeclarationResult, EdgeLabels.textDocument_declaration>;
/**
 * An edge representing a definition relationship. The relationship exists between:
 *
 * - `Range` -> `DefinitionResult`
 * - `ResultSet` -> `DefinitionResult`
 */
export declare type textDocument_definition = E11<Range, DefinitionResult, EdgeLabels.textDocument_definition> | E11<ResultSet, DefinitionResult, EdgeLabels.textDocument_definition>;
/**
 * An edge representing a type definition relations ship. The relationship exists between:
 *
 * - `Range` -> `TypeDefinitionResult`
 * - `ResultSet` -> `TypeDefinitionResult`
 */
export declare type textDocument_typeDefinition = E11<Range, TypeDefinitionResult, EdgeLabels.textDocument_typeDefinition> | E11<ResultSet, TypeDefinitionResult, EdgeLabels.textDocument_typeDefinition>;
/**
 * An edge representing a hover relationship. The relationship exists between:
 *
 * - `Range` -> `HoverResult`
 * - `ResultSet` -> `HoverResult`
 */
export declare type textDocument_hover = E11<Range, HoverResult, EdgeLabels.textDocument_hover> | E11<ResultSet, HoverResult, EdgeLabels.textDocument_hover>;
/**
 * An edge representing a references relationship. The relationship exists between:
 *
 * - `Range` -> `ReferenceResult`
 * - `ResultSet` -> `ReferenceResult`
 */
export declare type textDocument_references = E11<Range, ReferenceResult, EdgeLabels.textDocument_references> | E11<ResultSet, ReferenceResult, EdgeLabels.textDocument_references>;
/**
 * An edge representing a implementation relationship. The relationship exists between:
 *
 * - `Range` -> `ImplementationResult`
 * - `ResultSet` -> `ImplementationResult`
 */
export declare type textDocument_implementation = E11<Range, ImplementationResult, EdgeLabels.textDocument_implementation> | E11<ResultSet, ImplementationResult, EdgeLabels.textDocument_implementation>;
/**
 *
 * All available Edge types.
 */
export declare type Edge = contains | item | next | moniker | nextMoniker | packageInformation | textDocument_documentSymbol | textDocument_foldingRange | textDocument_documentLink | textDocument_diagnostic | textDocument_declaration | textDocument_definition | textDocument_typeDefinition | textDocument_hover | textDocument_references | textDocument_implementation;
export declare namespace Edge {
    function is11(edge: Edge): edge is (Edge & {
        inV: Id;
    });
    function is1N(edge: Edge): edge is (Edge & {
        inVs: Id[];
    });
}