@artel/artc 0.6.25191

package/build/types/services/DocumentHighlightsService.d.ts

@@ -0,0 +1,18 @@
+import { Analyzer } from '../analysis/index.js';
+import { Range, CancellationToken } from '../common/index.js';
+import { SourceFile } from '../project/index.js';
+export declare class DocumentHighlightsService {
+    private readonly _referencesService;
+    getDocumentHighlights(analyzer: Analyzer, sourceFile: SourceFile, offset: number, cancellationToken: CancellationToken | undefined): Promise<Highlight[]>;
+    private static referenceKindToHighlightKind;
+}
+export declare class Highlight {
+    readonly range: Range;
+    readonly kind: HighlightKind;
+    constructor(range: Range, kind: HighlightKind);
+}
+export declare const enum HighlightKind {
+    Text = 1,
+    Read = 2,
+    Write = 3
+}

package/build/types/services/EvaluatableExpressionService.d.ts

@@ -0,0 +1,15 @@
+import { Analyzer } from '../analysis/index.js';
+import { Range } from '../common/index.js';
+import { SourceFile } from '../project/index.js';
+export declare class EvaluatableExpression {
+    readonly range: Range;
+    readonly value: string;
+    constructor(range: Range, value: string);
+}
+export declare class EvaluatableExpressionService {
+    getEvaluatableExpression(analyzer: Analyzer, sourceFile: SourceFile, offset: number): EvaluatableExpression | undefined;
+    private convertEvaluatableExpressionToString;
+    private getEvaluatableExpressionForIdentifier;
+    private isEvaluatableReceiver;
+    private isNamedDeclaration;
+}

package/build/types/services/FileSystemTreeDisplayService.d.ts

@@ -0,0 +1,7 @@
+import { Directory } from '../project/FileSystemTree.js';
+export declare class FileSystemTreeDisplayService {
+    static readonly indentation = 2;
+    static readonly ignoredFolderNameSet: Set<string>;
+    displayFileSystemTree(rootDirectories: readonly Directory[]): string;
+    private displayDirectoryRecursively;
+}

package/build/types/services/HoverService.d.ts

@@ -0,0 +1,17 @@
+import { Analyzer } from '../analysis/index.js';
+import { Range } from '../common/index.js';
+import { SourceFile } from '../project/index.js';
+export declare class HoverService {
+    private _displayService;
+    getHover(analyzer: Analyzer, sourceFile: SourceFile, offset: number): Hover | undefined;
+    private createHoverForEntity;
+    private createHoverAtReference;
+    private createHoverAtAccessedMethod;
+}
+export declare class Hover {
+    private readonly _contents;
+    private readonly _rawContents;
+    readonly range: Range;
+    get contents(): string;
+    constructor(rawContents: string, range: Range);
+}

package/build/types/services/LanguageServer.d.ts

@@ -0,0 +1,125 @@
+import * as ls from 'vscode-languageserver';
+import { CancellationToken } from '../common/index.js';
+import { TypeScriptLibrariesProvider } from '../ts-interop/TsLibrariesProvider.js';
+import { WorkspaceFileSystem } from './workspace/index.js';
+export declare class LanguageServer {
+    static readonly DefaultCancellationTokenThrottleTime = 50;
+    private readonly _connection;
+    private readonly _config;
+    private readonly _disposables;
+    private _clientCapabilities;
+    private _workspace;
+    private _isInitialized;
+    private _enableRequestCancellation;
+    private _sendRefreshDiagnosticsRequestDebounced;
+    private _workspaceDiagnosticsPartialResultToken;
+    private _fileSystemUpdateNotificationsPublisher;
+    private _manuallyUpdatedFileSystemTreeProvider;
+    private readonly _sourceFileItemsService;
+    private readonly _workspaceItemsService;
+    private _definitionService;
+    private _sourceGenerationService;
+    private readonly _referencesService;
+    private readonly _documentHighlightService;
+    private readonly _renameService;
+    private readonly _hoverService;
+    private readonly _evaluatableExpressionService;
+    private readonly _completionService;
+    private readonly _semanticTokensService;
+    private readonly _semanticTokenTypeIndexBySemanticTokenKind;
+    private readonly _protocolSemanticTokenModifierFlagByIndex;
+    private readonly _signatureHelpService;
+    private readonly _fileSystemTreeDisplayService;
+    private readonly _selectionRangeService;
+    private readonly _addPropertyAssignmentService;
+    constructor(config: LanguageServerConfig);
+    start(): void;
+    dispose(): void;
+    private onInitialize;
+    private onInitialized;
+    private onDidChangeConfiguration;
+    private onDidOpenTextDocument;
+    private onDidChangeTextDocument;
+    private onDidSaveTextDocument;
+    private onDidCloseTextDocument;
+    private onDidChangeWorkspaceFolders;
+    private onDidChangeWatchedFiles;
+    private onDocumentDiagnostic;
+    private onWorkspaceDiagnostic;
+    private reportDiagnostics;
+    private onDocumentSymbol;
+    private onWorkspaceSymbol;
+    private onDefinition;
+    private onReferences;
+    private onDocumentHighlight;
+    private onPrepareRename;
+    private onRename;
+    private onHover;
+    private convertSourceFileItemKind;
+    private convertDiagnostic;
+    private onExecuteCommand;
+    private onAddPropertyAssignment;
+    private convertSourceFileEdit;
+    private onGetNodeRage;
+    private onCreateOrUpdateSourceFile;
+    private onDeleteSourceFile;
+    private onDisplayFileSystemTree;
+    private onEmitCodeToString;
+    private onProvideInMemoryDocumentContent;
+    private onProvideEvaluatableExpression;
+    private onCompletion;
+    private onCompletionResolve;
+    private convertCompletionItem;
+    private convertCompletionItemKind;
+    private onSemanticTokens;
+    private onSemanticTokensRange;
+    private convertSemanticTokens;
+    private convertSemanticTokenModifiers;
+    private createSemanticTokenTypeIndexBySemanticTokenKind;
+    private getSupportedSemanticTokenTypes;
+    private convertSemanticTokenKind;
+    private createProtocolSemanticTokenModifierFlagByIndex;
+    private getSupportedSemanticTokenModifiers;
+    private convertSemanticTokenModifierFlag;
+    private onSignatureHelp;
+    private onSelectionRanges;
+    private convertSelectionRange;
+    private onRawPackageConfigurationsChanged;
+    private convertSourceFileRange;
+    private getSourceFileContext;
+    private convertUriToVscodeUri;
+    private convertVscodeUriToUri;
+    private createCancellationToken;
+    private withCancellation;
+}
+export interface LanguageServerConfig {
+    readonly connection: ls.Connection;
+    readonly fileSystemSynchronizationMode: FileSystemSynchronizationMode;
+    readonly tsLibrariesProvider: TypeScriptLibrariesProvider;
+}
+export type FileSystemSynchronizationMode = FileSystemSynchronizationMode.ClientSideFSWatcher | FileSystemSynchronizationMode.ClientToServerRequests;
+export declare namespace FileSystemSynchronizationMode {
+    class ClientSideFSWatcher {
+        readonly fileSystem: WorkspaceFileSystem;
+        readonly kind = "client-side-fs-watcher";
+        constructor(fileSystem: WorkspaceFileSystem);
+    }
+    class ClientToServerRequests {
+        readonly kind = "client-to-server-requests";
+    }
+}
+export interface ArtelServerInitializeParams extends ls.InitializeParams {
+    initializationOptions?: ArtelServerInitializationOptions;
+}
+export interface ArtelServerInitializationOptions {
+    initiallyOpenedFileUris?: ls.URI[];
+    workspaceFoldersOverride?: ls.WorkspaceFolder[];
+    localeOverride?: string;
+    standardPackagesUri?: ls.URI;
+}
+export declare class ClientCancellationToken implements CancellationToken {
+    private readonly _token;
+    get isCancellationRequested(): boolean;
+    constructor(_token: ls.CancellationToken);
+    throwIfCancellationRequested(): void;
+}

package/build/types/services/NodeSemanticInfo.d.ts

@@ -0,0 +1,132 @@
+import { AccessedMethod } from '../analysis/AccessedMethod.js';
+import { MatchResultValueParameter } from '../analysis/CallArgumentToParameterMatchResult.js';
+import { Translation, WithLocalization } from '../analysis/Localization.js';
+import { TypeIndexedAccessorDeclaration } from '../analysis/NodeTypeUtils.js';
+import { Analyzer } from '../analysis/index.js';
+import { ReadonlyNonEmptyArray } from '../common/index.js';
+import { AliasTypeEntity, Entity, MethodEntity, MethodTypeEntity, PackageAliasEntity, PackageEntity, StructuredTypeEntity, TypeParameterEntity, VariableEntity, VariantEntity, VariantTypeEntity } from '../entities/index.js';
+import * as tree from '../tree/index.js';
+import * as types from '../types/index.js';
+import { TokenOrKeyword } from './TreeUtils.js';
+export declare class NodeSemanticInfoService {
+    static ofTokenOrKeyword(analyzer: Analyzer, tokenOrKeyword: TokenOrKeyword, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofDefaultMatchExpression(analyzer: Analyzer, node: tree.DefaultMatchExpression): NodeSemanticInfo | undefined;
+    static ofNonKeywordIdentifier(analyzer: Analyzer, node: tree.Identifier, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofProperty(analyzer: Analyzer, node: tree.PropertyAccessExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofQualifiedNameQualifier(analyzer: Analyzer, node: tree.QualifiedName, qualifier: tree.Identifier, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofIdentifierExpression(analyzer: Analyzer, node: tree.IdentifierExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofTypeConstructorDeclaration(analyzer: Analyzer, node: tree.TypeConstructorDeclaration): NodeSemanticInfo;
+    static ofTypeIndexerDeclaration(analyzer: Analyzer, node: TypeIndexedAccessorDeclaration): NodeSemanticInfo;
+    static ofIndexedAccessExpressionOperator(analyzer: Analyzer, node: tree.IndexedAccessExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofAssignmentStatementOperator(analyzer: Analyzer, node: tree.AssignmentStatement, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofBinaryExpressionOperator(analyzer: Analyzer, node: tree.BinaryExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofNotExpressionNotKeyword(analyzer: Analyzer, node: tree.NotExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofPrefixUnaryExpressionOperator(analyzer: Analyzer, node: tree.PrefixUnaryExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofDereferenceOperatorDeclaration(analyzer: Analyzer, node: tree.TypeDereferencedVariableGetterDeclaration | tree.TypeDereferencedVariableSetterDeclaration): NodeSemanticInfo | undefined;
+    static ofDereferenceExpressionOperator(analyzer: Analyzer, node: tree.DereferenceExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofAutotypeCallExpression(analyzer: Analyzer, node: tree.AutotypeCallExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofObjectExpression(analyzer: Analyzer, node: tree.ObjectExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofBaseExpression(analyzer: Analyzer, node: tree.BaseExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    private static ofPackageNameSegmentAccess;
+    private static ofMaybeConstructorCall;
+    private static getBetterReferenceTargetsOrPreserve;
+    private static getBetterReferenceTarget;
+    private static getContainingTranslationPackage;
+}
+export type NodeSemanticInfoServiceOptions = {
+    readonly preferredTargetOfExplicitConstructorCall: 'type-declaration' | 'constructor-declaration';
+    readonly includeBetterReferenceTargets: boolean;
+};
+export type NodeSemanticInfo = DefinitionNodeSemanticInfo | ReferenceNodeSemanticInfo | NameTranslationNodeSemanticInfo | DefaultSwitchMatchNodeSemanticInfo;
+export declare class DefinitionNodeSemanticInfo {
+    readonly entity: Entity;
+    readonly kind = "definition";
+    constructor(entity: Entity);
+}
+export declare class ReferenceNodeSemanticInfo {
+    readonly targets: ReadonlyNonEmptyArray<WithLocalization<ReferenceTarget>>;
+    readonly isAmbiguous: boolean;
+    readonly betterTargets?: ReadonlyNonEmptyArray<WithLocalization<ReferenceTarget>> | undefined;
+    readonly kind = "reference";
+    get firstTarget(): WithLocalization<ReferenceTarget>;
+    get firstBetterTargetWithFallback(): WithLocalization<ReferenceTarget>;
+    constructor(targets: ReadonlyNonEmptyArray<WithLocalization<ReferenceTarget>>, isAmbiguous: boolean, betterTargets?: ReadonlyNonEmptyArray<WithLocalization<ReferenceTarget>> | undefined);
+}
+export type ReferenceTarget = EntityReferenceTarget | TypeVariableReferenceTarget | TypeValueParameterReferenceTarget | TypeConstructorReferenceTarget | TypeUnaryOperatorReferenceTarget | TypeBinaryOperatorReferenceTarget | TypeDereferenceOperatorReferenceTarget | AccessedMethodReferenceTarget | TypeIndexerReferenceTarget | MatchResultValueParameterReferenceTarget | PackageReferenceTarget | TypeContextReferenceTarget;
+export declare class EntityReferenceTarget {
+    readonly entity: ReferencedEntity;
+    readonly kind = "entity";
+    constructor(entity: ReferencedEntity);
+}
+export type ReferencedEntity = VariableEntity | VariantEntity | VariantTypeEntity | MethodEntity | TypeParameterEntity | MethodTypeEntity | StructuredTypeEntity | PackageAliasEntity | AliasTypeEntity;
+export declare class TypeVariableReferenceTarget {
+    readonly variable: types.Variable;
+    readonly kind = "type-variable";
+    constructor(variable: types.Variable);
+}
+export declare class TypeValueParameterReferenceTarget {
+    readonly parameter: types.ValueParameter;
+    readonly kind = "type-value-parameter";
+    constructor(parameter: types.ValueParameter);
+}
+export declare class TypeConstructorReferenceTarget {
+    readonly constructor_: types.Constructor;
+    readonly kind = "type-constructor";
+    constructor(constructor_: types.Constructor);
+}
+export declare class TypeUnaryOperatorReferenceTarget {
+    readonly operator: types.UnaryOperator;
+    readonly kind = "type-unary-operator";
+    constructor(operator: types.UnaryOperator);
+}
+export declare class TypeBinaryOperatorReferenceTarget {
+    readonly operator: types.BinaryOperator;
+    readonly kind = "type-binary-operator";
+    constructor(operator: types.BinaryOperator);
+}
+export declare class TypeDereferenceOperatorReferenceTarget {
+    readonly operator: types.DereferenceOperator;
+    readonly kind = "type-dereference-operator";
+    constructor(operator: types.DereferenceOperator);
+}
+export declare class AccessedMethodReferenceTarget {
+    readonly method: AccessedMethod;
+    readonly kind = "accessed-method";
+    constructor(method: AccessedMethod);
+}
+export declare class MatchResultValueParameterReferenceTarget {
+    readonly parameter: MatchResultValueParameter;
+    readonly kind = "match-result-value-parameter";
+    constructor(parameter: MatchResultValueParameter);
+}
+export declare class PackageReferenceTarget {
+    readonly package_: PackageEntity;
+    readonly kind = "package";
+    constructor(package_: PackageEntity);
+}
+export declare class TypeContextReferenceTarget {
+    readonly type: types.Type;
+    readonly typeContextKind: 'object' | 'base';
+    readonly kind = "type-context";
+    constructor(type: types.Type, typeContextKind: 'object' | 'base');
+}
+export declare class TypeIndexerReferenceTarget {
+    readonly indexer: types.Indexer;
+    readonly kind = "type-indexer";
+    constructor(indexer: types.Indexer);
+}
+export declare class NameTranslationNodeSemanticInfo {
+    readonly targets: ReadonlyNonEmptyArray<TranslationTargetEntity>;
+    readonly isAmbiguous: boolean;
+    readonly translation: Translation;
+    readonly kind = "name-translation";
+    get firstTarget(): TranslationTargetEntity;
+    constructor(targets: ReadonlyNonEmptyArray<TranslationTargetEntity>, isAmbiguous: boolean, translation: Translation);
+}
+type TranslationTargetEntity = VariableEntity | VariantEntity | VariantTypeEntity | MethodEntity | TypeParameterEntity | MethodTypeEntity | StructuredTypeEntity | AliasTypeEntity;
+export declare class DefaultSwitchMatchNodeSemanticInfo {
+    readonly type: types.Type;
+    readonly kind = "default-switch-match";
+    constructor(type: types.Type);
+}
+export {};

package/build/types/services/ProjectItemsService.d.ts

@@ -0,0 +1,6 @@
+import { Compilation } from '../project/index.js';
+import { Item } from './SourceFileItemsService.js';
+export declare class WorkspaceItemsService {
+    private readonly _sourceFileItemsService;
+    getItems(compilations: readonly Compilation[]): Item[];
+}

package/build/types/services/ReferencesService.d.ts

@@ -0,0 +1,30 @@
+import { Analyzer } from '../analysis/index.js';
+import { CancellationToken, Range } from '../common/index.js';
+import { SourceFile } from '../project/index.js';
+export declare class ReferencesService {
+    getReferencesInCompilation(analyzer: Analyzer, sourceFile: SourceFile, offset: number, options: ReferencesSearchOptions, cancellationToken: CancellationToken | undefined): Promise<Reference[]>;
+    getReferencesInFiles(analyzer: Analyzer, sourceFile: SourceFile, offset: number, sourceFiles: Iterable<SourceFile>, options: ReferencesSearchOptions, cancellationToken: CancellationToken | undefined): Promise<Reference[]>;
+    private getDefinitionAndReferenceInfoAtOffset;
+    private getDefinitionFromNodeSemanticInfo;
+    private getReferenceRestrictions;
+    private isReferenceToDefinition;
+    private determineReferenceKind;
+    private accessKindToReferenceKind;
+    private isEntityWithRegularName;
+}
+export declare class Reference {
+    readonly sourceFile: SourceFile;
+    readonly range: Range;
+    readonly kind: ReferenceKind;
+    constructor(sourceFile: SourceFile, range: Range, kind: ReferenceKind);
+}
+export declare const enum ReferenceKind {
+    Read = 0,
+    Write = 1,
+    Declaration = 2
+}
+export type ReferencesSearchOptions = {
+    readonly onlyWithSameAlias: boolean;
+    readonly onlyNamed: boolean;
+    readonly allowAmbiguous: boolean;
+};

package/build/types/services/RenameService.d.ts

@@ -0,0 +1,16 @@
+import { Analyzer } from '../analysis/index.js';
+import { CancellationToken, Range } from '../common/index.js';
+import { SourceFile } from '../project/index.js';
+export declare class RenameService {
+    private readonly _referencesService;
+    prepareRename(analyzer: Analyzer, sourceFile: SourceFile, offset: number): Range | undefined;
+    rename(analyzer: Analyzer, sourceFile: SourceFile, offset: number, newText: string, cancellationToken: CancellationToken | undefined): Promise<Rename[]>;
+    private canRename;
+    private entityCanBeRenamed;
+}
+export declare class Rename {
+    readonly sourceFile: SourceFile;
+    readonly range: Range;
+    readonly text: string;
+    constructor(sourceFile: SourceFile, range: Range, text: string);
+}

package/build/types/services/SelectionRangeService.d.ts

@@ -0,0 +1,12 @@
+import { Range } from '../common/index.js';
+import { SourceFile } from '../project/SourceFile.js';
+export declare class SelectionRangeService {
+    getSelectionRange(sourceFile: SourceFile, offset: number): SelectionRange | undefined;
+    private nodeContainsOffset;
+    private nodeShouldBeSkipped;
+}
+export declare class SelectionRange {
+    readonly range: Range;
+    readonly parent: SelectionRange | undefined;
+    constructor(range: Range, parent: SelectionRange | undefined);
+}

package/build/types/services/SemanticTokensService.d.ts

@@ -0,0 +1,40 @@
+import { Analyzer } from '../analysis/index.js';
+import { CancellationToken, Range } from '../common/index.js';
+import { SourceFile } from '../project/index.js';
+export declare class SemanticTokensService {
+    getSemanticTokens(analyzer: Analyzer, sourceFile: SourceFile, cancellationToken: CancellationToken | undefined): Promise<SemanticToken[]>;
+    getSemanticTokensInRange(analyzer: Analyzer, sourceFile: SourceFile, range: Range, cancellationToken: CancellationToken | undefined): Promise<SemanticToken[]>;
+    private rangesOverlap;
+    private getSemanticTokenKindForMethodEntity;
+    private isCapitalizedName;
+}
+export declare class SemanticToken {
+    readonly range: Range;
+    readonly kind: SemanticTokenKind;
+    readonly modifiers: SemanticTokenModifiers;
+    constructor(range: Range, kind: SemanticTokenKind, modifiers: SemanticTokenModifiers);
+}
+export declare class SemanticTokenModifiers {
+    private _flags;
+    get flags(): number;
+    makeConst(): this;
+    makeDeclaration(): this;
+    makeCapitalized(): this;
+    setCapitalized(value: boolean): this;
+}
+export declare const enum SemanticTokenKind {
+    MethodBlockLiteralParameter = 0,
+    SpecialVariable = 1,
+    SpecialMethod = 2,
+    Variant = 3,
+    PackageMethod = 4,
+    NestedMethod = 5,
+    TypeMethod = 6
+}
+export declare const supportedSemanticTokens: SemanticTokenKind[];
+export declare const enum SemanticTokenModifierFlag {
+    Const = 1,
+    Declaration = 2,
+    Capitalized = 4
+}
+export declare const supportedSemanticTokenModifiers: SemanticTokenModifierFlag[];

package/build/types/services/SourceFileItemsService.d.ts

@@ -0,0 +1,42 @@
+import { Range } from '../common/index.js';
+import { SourceFile } from '../project/index.js';
+export declare class SourceFileItemsService {
+    private _sourceFile;
+    getItems(sourceFile: SourceFile): Item[];
+    private get locale();
+    private get dialect();
+    private getChildItems;
+    private createItem;
+    private getNameOrStubIfEmpty;
+}
+export declare class Item {
+    readonly kind: ItemKind;
+    readonly name: string;
+    readonly range: Range;
+    readonly selectionRange: Range;
+    readonly items: readonly Item[];
+    readonly sourceFile: SourceFile;
+    constructor(kind: ItemKind, name: string, range: Range, selectionRange: Range, items: readonly Item[], sourceFile: SourceFile);
+}
+export declare const enum ItemKind {
+    PackageAlias = 0,
+    PackageVariable = 1,
+    PackageVariableGetter = 2,
+    PackageVariableSetter = 3,
+    PackageMethod = 4,
+    StructuredType = 5,
+    MethodType = 6,
+    VariantType = 7,
+    InvalidType = 8,
+    Variant = 9,
+    TypeConstructor = 10,
+    TypeDestructor = 11,
+    TypeVariable = 12,
+    TypeVariableGetter = 13,
+    TypeVariableSetter = 14,
+    TypeMethod = 15,
+    TypeIndexedGetter = 16,
+    TypeIndexedSetter = 17,
+    TypeParameter = 18,
+    NestedMethod = 19
+}

package/build/types/services/TranslationService.d.ts

@@ -0,0 +1,23 @@
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { Analyzer } from '../analysis/index.js';
+import { Range } from '../common/index.js';
+import { SourceFile } from '../project/index.js';
+export declare class TranslationService {
+    private readonly _translationCache;
+    constructor();
+    translateSourceFile(analyzer: Analyzer, sourceFile: SourceFile, localeText: string): Translation;
+    clearTranslationCache(): void;
+    private translateIdentifier;
+    private translateKeywords;
+    private translateReservedIdentifier;
+    private createRangeMaps;
+    private getTranslationId;
+}
+export type Translation = {
+    translatedDocument: TextDocument;
+    rangeMaps: RangeMap[];
+};
+export type RangeMap = {
+    sourceRange: Range;
+    translationRange: Range;
+};

package/build/types/services/TreeUtils.d.ts

@@ -0,0 +1,58 @@
+import * as tree from '../tree/index.js';
+/**
+ * Получить самый правый токен, для которого `rangeWithoutTrivia.end <= offset`.
+ */
+export declare function getPrecedingToken(sourceFile: tree.SourceFile, offset: number): tree.Token | undefined;
+/**
+ * Возвращает токен, для которого `offset >= range.start` и `offset < range.end`,
+ * или токен конца файла (`TokenKind.EndOfFile`) если смещение находится в конце файла.
+ */
+export declare function getTokenAtOffset(sourceFile: tree.SourceFile, offset: number, searchInTrivia: boolean): tree.Token | undefined;
+/**
+ * Возвращает не пустой токен или ключевое слово, для которых `offset >= rangeWithoutTrivia.start` и `offset <= rangeWithoutTrivia.end`.
+ *
+ * Если смещение находится между двумя токенами / ключевыми словами (например а|.б), то возвращаются оба.
+ */
+export declare function getTokenOrKeywordsTouchingOffset(sourceFile: tree.SourceFile, offset: number): TokenOrKeywordsTouchingOffset;
+export declare class TokenOrKeyword {
+    readonly value: tree.Token | tree.Keyword;
+    get parent(): tree.Node;
+    constructor(value: tree.Token | tree.Keyword);
+    isToken<T extends tree.TokenKind>(kind?: T): this is TokenOrKeyword & {
+        value: tree.Token<T>;
+    };
+    isKeyword<T extends tree.KeywordKind>(kind?: tree.KeywordKind): this is TokenOrKeyword & {
+        value: tree.Keyword<T>;
+    };
+    equals(other: TokenOrKeyword): boolean;
+}
+export type TokenOrKeywordsTouchingOffset = TokenOrKeywordsTouchingOffset_none | TokenOrKeywordsTouchingOffset_single | TokenOrKeywordsTouchingOffset_two;
+export declare class TokenOrKeywordsTouchingOffset_none implements ITokenOrKeywordsTouchingOffset {
+    readonly kind = "none";
+    getSinglePrioritizingNamed(): TokenOrKeyword | undefined;
+    getSingleWithHighestPriority(_getPriority: (token: TokenOrKeyword) => number): TokenOrKeyword | undefined;
+}
+export declare class TokenOrKeywordsTouchingOffset_single implements ITokenOrKeywordsTouchingOffset {
+    readonly value: TokenOrKeyword;
+    readonly kind = "single";
+    constructor(value: TokenOrKeyword);
+    getSinglePrioritizingNamed(): TokenOrKeyword | undefined;
+    getSingleWithHighestPriority(_getPriority: (token: TokenOrKeyword) => number): TokenOrKeyword | undefined;
+}
+export declare class TokenOrKeywordsTouchingOffset_two implements ITokenOrKeywordsTouchingOffset {
+    readonly left: TokenOrKeyword;
+    readonly right: TokenOrKeyword;
+    readonly kind = "two";
+    constructor(left: TokenOrKeyword, right: TokenOrKeyword);
+    getSinglePrioritizingNamed(): TokenOrKeyword | undefined;
+    getSingleWithHighestPriority(getPriority: (token: TokenOrKeyword) => number): TokenOrKeyword | undefined;
+}
+interface ITokenOrKeywordsTouchingOffset {
+    getSinglePrioritizingNamed(): TokenOrKeyword | undefined;
+    getSingleWithHighestPriority(getPriority: (token: TokenOrKeyword) => number): TokenOrKeyword | undefined;
+}
+/**
+ * Возвращает trivia, для которого `offset >= range.start` и `offset < range.end`.
+ */
+export declare function getTriviaAtOffset(sourceFile: tree.SourceFile, offset: number): tree.Trivia | undefined;
+export {};

package/build/types/services/TypeDefinitionService.d.ts

@@ -0,0 +1,9 @@
+import { Analyzer } from '../analysis/index.js';
+import { SourceFile } from '../project/index.js';
+import { AnonymousMethodTypeDeclaration, AnonymousStructuredTypeDeclaration, AnonymousVariantTypeDeclaration, PackageAliasTypeDeclaration, PackageMethodTypeDeclaration, PackageStructuredTypeDeclaration, PackageVariantTypeDeclaration, TypeParameterDeclaration } from '../tree/index.js';
+import { RangeLocation } from './Types.js';
+export declare class TypeDefinitionService {
+    getTypeDefinition(analyzer: Analyzer, sourceFile: SourceFile, offset: number): RangeLocation | undefined;
+    private getTypeDefinitionAtIdentifier;
+}
+export type TypeDeclaration = PackageStructuredTypeDeclaration | AnonymousStructuredTypeDeclaration | PackageMethodTypeDeclaration | AnonymousMethodTypeDeclaration | PackageVariantTypeDeclaration | AnonymousVariantTypeDeclaration | PackageAliasTypeDeclaration | TypeParameterDeclaration;

package/build/types/services/Types.d.ts

@@ -0,0 +1,22 @@
+import { Range, Uri } from '../common/index.js';
+import { SourceFile } from '../project/index.js';
+export type RangeLocation = {
+    uri: Uri;
+    range: Range;
+};
+export declare class SourceLocation {
+    readonly sourceFile: SourceFile;
+    readonly range: Range;
+    constructor(sourceFile: SourceFile, range: Range);
+}
+export type CompletionItemData = {
+    cacheId: number;
+    indexInCache: number;
+};
+export declare function isCompletionItemData(value: unknown): value is CompletionItemData;
+export declare class SourceFileEdit {
+    readonly sourceFile: SourceFile;
+    readonly range: Range;
+    readonly text: string;
+    constructor(sourceFile: SourceFile, range: Range, text: string);
+}

package/build/types/services/Utils.d.ts

@@ -0,0 +1,5 @@
+import { Analyzer } from '../analysis/index.js';
+import { Entity } from '../entities/index.js';
+import { SourceLocation } from './Types.js';
+export declare function getEntitySourceLocations(analyzer: Analyzer, entity: Entity): SourceLocation[] | undefined;
+export declare function debounce(timeMs: number, action: () => void): () => void;

package/build/types/services/signature-help/SignatureHelpService.d.ts

@@ -0,0 +1,17 @@
+import { Analyzer } from '../../analysis/index.js';
+import { Range } from '../../common/index.js';
+import { SourceFile } from '../../project/index.js';
+export declare class SignatureHelpService {
+    getSignatureHelp(analyzer: Analyzer, sourceFile: SourceFile, offset: number): SignatureHelp | undefined;
+}
+export declare class SignatureHelp {
+    readonly signatures: readonly SignatureInfo[];
+    readonly activeSignatureIndex: number;
+    constructor(signatures: readonly SignatureInfo[], activeSignatureIndex: number);
+}
+export declare class SignatureInfo {
+    readonly label: string;
+    readonly parameterRanges: readonly Range[];
+    readonly activeParameterIndex: number;
+    constructor(label: string, parameterRanges: readonly Range[], activeParameterIndex: number);
+}