@artel/artc 0.6.26017 → 0.6.26019

package/build/types/services/{DisplayService.d.ts → common/display/Types.d.ts}

@@ -1,84 +1,9 @@
-import { AccessedFunction } from '../analysis/AccessedFunction.js';
-import { PackageNameTreeNode } from '../analysis/ImportedPackageNameTree.js';
-import { SubstitutedFunction } from '../analysis/SubstitutedFunction.js';
-import { Analyzer } from '../analysis/index.js';
-import { HelperPhraseKind, Name, PackageDialect, PackageLocale } from '../common/index.js';
-import * as e from '../entities/index.js';
-import { NamedEntity, StructuredTypeKind } from '../entities/index.js';
-import { SourceFile } from '../project/index.js';
-import { KeywordKind } from '../tree/index.js';
-import * as types from '../types/index.js';
-export declare class DisplayService {
-    private readonly analyzer;
-    private readonly locale;
-    private readonly dialect;
-    private readonly contextualSourceFile?;
-    private packageNameShorteningMap;
-    constructor(analyzer: Analyzer | undefined, locale: PackageLocale, dialect: PackageDialect, contextualSourceFile?: SourceFile | undefined);
-    displayVariableDeclaration(variable: VariableDeclaration): string;
-    displayType(type: types.Type): string;
-    getFunctionTypeBodyDisplayParts(type: types.FunctionType): FunctionTypeBodyDisplayParts;
-    getNamedTypeDisplayParts(type: NamedType): NamedTypeDisplayParts;
-    displayPackageAliasEntity(entity: e.PackageAliasEntity): string;
-    displayPackage(package_: e.PackageEntity): string;
-    displayPackageNameTreeNode(node: PackageNameTreeNode): string;
-    displayParameterDeclaration(parameter: ParameterDeclaration, options?: TypeDisplayOptions): string;
-    getParameterDeclarationDisplayParts(parameter: ParameterDeclaration, options?: TypeDisplayOptions): ParameterDeclarationDisplayParts;
-    displayFunctionDeclaration(func: FunctionDeclaration): string;
-    getFunctionDeclarationDisplayParts(func: FunctionDeclaration): FunctionDeclarationDisplayParts;
-    displayAnonymousFunctionDeclaration(func: AnonymousFunctionDeclaration): string;
-    displayOperatorKind(kind: e.OperatorKind): string;
-    displayConstructorDeclaration(constructor: ConstructorDeclaration): string;
-    getConstructorDeclarationDisplayParts(constructor: ConstructorDeclaration): ConstructorDeclarationDisplayParts;
-    displayDestructorDeclaration(constructor: DestructorDeclaration): string;
-    displayIndexerDeclaration(indexer: IndexerDeclaration): string;
-    getIndexerDeclarationDisplayParts(indexer: IndexerDeclaration): IndexerDeclarationDisplayParts;
-    displayDereferenceOperatorDeclaration(referenceOperator: DereferenceOperatorDeclaration): string;
-    getDereferenceOperatorDeclarationDisplayParts(dereferenceOperator: DereferenceOperatorDeclaration): DereferenceOperatorDeclarationDisplayParts;
-    displayTypeDeclaration(type: TypeDeclaration): string;
-    displayTypeDeclarationEntity(entity: e.TypeEntity): string;
-    displayTypeParameterValue(value: TypeParameterValue): string;
-    displayGetterEntity(entity: e.GetterEntity): string;
-    displaySetterEntity(entity: e.SetterEntity): string;
-    displayTypeExtensionEntity(entity: e.TypeExtensionEntity): string;
-    displayLocalizableTextEntity(entity: e.TextTranslationEntity): string;
-    displayEntity(entity: e.Entity): string;
-    displayTypeEntity(entity: e.TypeEntity): string;
-    displayTypeMember(member: types.TypeMember): string;
-    displayKeyword(kind: KeywordKind): string;
-    displayHelperPhrase(kind: HelperPhraseKind): string;
-    displayEntityName(entity: NamedEntity): string;
-    displayName(name: Name): string;
-    private displayTypeEntityAsUsage;
-    private displayStructuredTypeUsage;
-    private displayVariantTypeUsage;
-    private displayFunctionTypeUsage;
-    private displayParameterTypeUsage;
-    private displayAliasTypeUsage;
-    private displayReducedTypeUsage;
-    private displayUnionOrIntersectionTypeUsage;
-    private displayUnresolvedTypeUsage;
-    private displaySubstitutionStubTypeUsage;
-    private displayTypeInternal;
-    private displayTypeUsageInternal;
-    private displayUnionOrIntersectionTypeTypes;
-    private displayDeclarationContainer;
-    private displayDeclarationContainerWithEndingDot;
-    private getPackageNameShorteningMap;
-}
-interface TypeDisplayOptions {
-    readonly unionAndAliasTypeDisplayKind: UnionAndAliasTypeDisplayKind;
-    readonly functionTypeDisplayKind: FunctionTypeDisplayKind;
-    readonly displayContainer: boolean;
-}
-declare const enum UnionAndAliasTypeDisplayKind {
-    Full = 0,
-    OnlyOriginalType = 1
-}
-declare const enum FunctionTypeDisplayKind {
-    Full = 0,
-    OnlyOriginalType = 1
-}
+import { AccessedFunction } from '../../../analysis/AccessedFunction.js';
+import { Analyzer } from '../../../analysis/Analyzer.js';
+import { SubstitutedFunction } from '../../../analysis/SubstitutedFunction.js';
+import { Name } from '../../../common/Name.js';
+import type * as e from '../../../entities/index.js';
+import type * as types from '../../../types/index.js';
 export type VariableDeclaration = VariableDeclaration_entity | VariableDeclaration_typeMember;
 export declare class VariableDeclaration_entity implements IVariableDeclaration {
     readonly value: e.VariableEntity;
@@ -339,7 +264,7 @@ export declare class TypeDeclarationStructured_entity implements ITypeDeclaratio
     constructor(entity: e.StructuredTypeEntity);
     ifNamedThenEntity(): e.NamedTypeEntity | undefined;
     getTypeParameterValues(): readonly TypeParameterValue[];
-    getStructuredTypeKind(): StructuredTypeKind;
+    getStructuredTypeKind(): e.StructuredTypeKind;
     getContainer(): DeclarationContainer | undefined;
 }
 export declare class TypeDeclarationStructured_type implements ITypeDeclarationStructured {
@@ -348,13 +273,13 @@ export declare class TypeDeclarationStructured_type implements ITypeDeclarationS
     constructor(type: types.StructuredType);
     ifNamedThenEntity(): e.NamedTypeEntity | undefined;
     getTypeParameterValues(): readonly TypeParameterValue[];
-    getStructuredTypeKind(): StructuredTypeKind;
+    getStructuredTypeKind(): e.StructuredTypeKind;
     getContainer(): DeclarationContainer | undefined;
 }
 interface ITypeDeclarationStructured {
     ifNamedThenEntity(): e.NamedTypeEntity | undefined;
     getTypeParameterValues(): readonly TypeParameterValue[];
-    getStructuredTypeKind(): StructuredTypeKind;
+    getStructuredTypeKind(): e.StructuredTypeKind;
     getContainer(): DeclarationContainer | undefined;
 }
 export declare class TypeDeclaration_function implements ITypeDeclaration {
@@ -511,7 +436,7 @@ interface ITypeDeclaration {
     getTypeParameterValues(): readonly TypeParameterValue[];
     getContainer(): DeclarationContainer | undefined;
 }
-type NamedType = NamedType_structured | NamedType_typeParameter | NamedType_variant | NamedType_alias | NamedType_reduced;
+export type NamedType = NamedType_structured | NamedType_typeParameter | NamedType_variant | NamedType_alias | NamedType_reduced;
 export declare class NamedType_structured implements INamedType {
     readonly value: e.PackageStructuredTypeEntity;
     readonly kind = "structured";
@@ -558,7 +483,7 @@ export declare class StructuredTypeUsage_type implements IStructuredTypeUsage {
     readonly kind = "structured";
     constructor(type: types.StructuredType);
     ifNamedThenEntity(): e.NamedTypeEntity | undefined;
-    getStructuredTypeKind(): StructuredTypeKind;
+    getStructuredTypeKind(): e.StructuredTypeKind;
     getTypeParameterValues(): readonly TypeParameterValue[];
     getContainer(): DeclarationContainer | undefined;
 }
@@ -567,14 +492,14 @@ export declare class StructuredTypeUsage_entity implements IStructuredTypeUsage
     readonly kind = "structured";
     constructor(entity: e.StructuredTypeEntity);
     ifNamedThenEntity(): e.NamedTypeEntity | undefined;
-    getStructuredTypeKind(): StructuredTypeKind;
+    getStructuredTypeKind(): e.StructuredTypeKind;
     getTypeParameterValues(): readonly TypeParameterValue[];
     getContainer(): DeclarationContainer | undefined;
 }
 interface IStructuredTypeUsage {
     readonly kind: 'structured';
     ifNamedThenEntity(): e.NamedTypeEntity | undefined;
-    getStructuredTypeKind(): StructuredTypeKind;
+    getStructuredTypeKind(): e.StructuredTypeKind;
     getTypeParameterValues(): readonly TypeParameterValue[];
     getContainer(): DeclarationContainer | undefined;
 }
@@ -702,8 +627,8 @@ interface IParameterTypeUsage {
     getEntity(): e.NamedTypeEntity;
     isNullExcluded(): boolean;
 }
-type UnionOrIntersectionTypeUsage = UnionOrIntersectionTypeUsage_type;
-declare class UnionOrIntersectionTypeUsage_type {
+export type UnionOrIntersectionTypeUsage = UnionOrIntersectionTypeUsage_type;
+export declare class UnionOrIntersectionTypeUsage_type {
     readonly type: types.UnionType | types.IntersectionType;
     readonly kind = "union-or-intersection";
     constructor(type: types.UnionType | types.IntersectionType);
@@ -712,19 +637,19 @@ declare class UnionOrIntersectionTypeUsage_type {
     getUnaliasedFlattenedTypes(): readonly types.Type[];
 }
 type UnresolvedTypeUsage = UnresolvedTypeUsage_type;
-declare class UnresolvedTypeUsage_type {
+export declare class UnresolvedTypeUsage_type {
     readonly kind = "unresolved";
 }
-type SubstitutionStubTypeUsage = SubstitutionStubTypeUsage_type;
-declare class SubstitutionStubTypeUsage_type {
+export type SubstitutionStubTypeUsage = SubstitutionStubTypeUsage_type;
+export declare class SubstitutionStubTypeUsage_type {
     readonly type: types.SubstitutionStubType;
     readonly kind = "substitution-stub";
     constructor(type: types.SubstitutionStubType);
     getIndex(): number;
 }
-type TypeMemberDeclarationContainer = DeclarationContainer.Type | DeclarationContainer.TypeExtension;
-type DeclarationContainer = DeclarationContainer.Type | DeclarationContainer.TypeExtension | DeclarationContainer.Package;
-declare namespace DeclarationContainer {
+export type TypeMemberDeclarationContainer = DeclarationContainer.Type | DeclarationContainer.TypeExtension;
+export type DeclarationContainer = DeclarationContainer.Type | DeclarationContainer.TypeExtension | DeclarationContainer.Package;
+export declare namespace DeclarationContainer {
     class Type {
         readonly typeUsage: TypeUsage;
         readonly parent: Package | undefined;
@@ -744,106 +669,64 @@ declare namespace DeclarationContainer {
     }
 }
 export declare class FunctionDeclarationDisplayParts {
-    readonly asyncKeywordWithWhitespace: string;
-    readonly functionKeyword: string;
-    readonly whitespaceAfterFunctionKeyword: string;
-    readonly container: string;
-    readonly name: string;
-    readonly typeParametersStart: string;
+    readonly beforeTypeParameters: string;
     readonly typeParameters: readonly string[];
     readonly typeParameterSeparator: string;
-    readonly typeParametersEnd: string;
-    readonly parametersStart: string;
-    readonly parameters: readonly ParameterDeclarationDisplayParts[];
-    readonly parameterSeparator: string;
-    readonly parametersEnd: string;
-    readonly returnTypeAnnotationColon: string;
-    readonly returnType: string;
-    constructor(asyncKeywordWithWhitespace: string, functionKeyword: string, whitespaceAfterFunctionKeyword: string, container: string, name: string, typeParametersStart: string, typeParameters: readonly string[], typeParameterSeparator: string, typeParametersEnd: string, parametersStart: string, parameters: readonly ParameterDeclarationDisplayParts[], parameterSeparator: string, parametersEnd: string, returnTypeAnnotationColon: string, returnType: string);
-    toString(): string;
-}
-export declare class OperatorDeclarationDisplayParts {
-    readonly functionKeyword: string;
-    readonly whitespaceAfterFunctionKeyword: string;
-    readonly container: string;
-    readonly name: string;
-    readonly parametersStart: string;
-    readonly parameters: readonly ParameterDeclarationDisplayParts[];
+    readonly afterTypeParametersBeforeParameters: string;
+    readonly parameters: readonly string[];
     readonly parameterSeparator: string;
-    readonly parametersEnd: string;
-    readonly returnTypeAnnotationColon: string;
-    readonly returnType: string;
-    constructor(functionKeyword: string, whitespaceAfterFunctionKeyword: string, container: string, name: string, parametersStart: string, parameters: readonly ParameterDeclarationDisplayParts[], parameterSeparator: string, parametersEnd: string, returnTypeAnnotationColon: string, returnType: string);
-    toString(): string;
-}
-export declare class ParameterDeclarationDisplayParts {
-    readonly name: string;
-    readonly optionalityText: string;
-    readonly colonWithWhitespace: string;
-    readonly type: string;
-    constructor(name: string, optionalityText: string, colonWithWhitespace: string, type: string);
-    toString(): string;
-}
-export declare class TypeDeclarationDisplayParts {
-    readonly typeKeyword: string;
-    readonly whitespaceAfterTypeKeyword: string;
-    readonly container: string;
-    readonly name: string;
-    readonly constraint: string;
-    readonly typeParametersStart: string;
-    readonly typeParameters: readonly string[];
-    readonly typeParameterSeparator: string;
-    readonly typeParametersEnd: string;
-    readonly equalsSignWithWhitespace: string;
-    readonly typeBody: string;
-    constructor(typeKeyword: string, whitespaceAfterTypeKeyword: string, container: string, name: string, constraint: string, typeParametersStart: string, typeParameters: readonly string[], typeParameterSeparator: string, typeParametersEnd: string, equalsSignWithWhitespace: string, typeBody: string);
+    readonly afterParameters: string;
+    constructor(beforeTypeParameters: string, typeParameters: readonly string[], typeParameterSeparator: string, afterTypeParametersBeforeParameters: string, parameters: readonly string[], parameterSeparator: string, afterParameters: string);
     toString(): string;
 }
 export declare class ConstructorDeclarationDisplayParts {
-    readonly typeText: string;
-    readonly parametersStart: string;
-    readonly parameters: readonly ParameterDeclarationDisplayParts[];
+    readonly beforeParameters: string;
+    readonly parameters: readonly string[];
     readonly parameterSeparator: string;
-    readonly parametersEnd: string;
-    constructor(typeText: string, parametersStart: string, parameters: readonly ParameterDeclarationDisplayParts[], parameterSeparator: string, parametersEnd: string);
+    readonly afterParameters: string;
+    constructor(beforeParameters: string, parameters: readonly string[], parameterSeparator: string, afterParameters: string);
     toString(): string;
 }
 export declare class IndexerDeclarationDisplayParts {
-    readonly container: string;
-    readonly parametersStart: string;
-    readonly parameters: readonly ParameterDeclarationDisplayParts[];
+    readonly beforeParameters: string;
+    readonly parameters: readonly string[];
     readonly parameterSeparator: string;
-    readonly parametersEnd: string;
-    readonly typeAnnotationColon: string;
-    readonly type: string;
-    constructor(container: string, parametersStart: string, parameters: readonly ParameterDeclarationDisplayParts[], parameterSeparator: string, parametersEnd: string, typeAnnotationColon: string, type: string);
-    toString(): string;
-}
-export declare class DereferenceOperatorDeclarationDisplayParts {
-    readonly container: string;
-    readonly operatorToken: string;
-    readonly typeAnnotationColon: string;
-    readonly type: string;
-    constructor(container: string, operatorToken: string, typeAnnotationColon: string, type: string);
+    readonly afterParameters: string;
+    constructor(beforeParameters: string, parameters: readonly string[], parameterSeparator: string, afterParameters: string);
     toString(): string;
 }
 export declare class NamedTypeDisplayParts {
-    readonly prefix: string;
+    readonly beforeTypeParameters: string;
     readonly typeParameters: readonly string[];
     readonly typeParameterSeparator: string;
-    readonly postfix: string;
-    constructor(prefix: string, typeParameters: readonly string[], typeParameterSeparator: string, postfix: string);
+    readonly afterTypeParameters: string;
+    constructor(beforeTypeParameters: string, typeParameters: readonly string[], typeParameterSeparator: string, afterTypeParameters: string);
 }
 export declare class FunctionTypeBodyDisplayParts {
-    readonly asyncKeywordWithWhitespace: string;
-    readonly functionKeyword: string;
-    readonly parametersStart: string;
-    readonly parameters: readonly ParameterDeclarationDisplayParts[];
+    readonly beforeParameters: string;
+    readonly parameters: readonly string[];
     readonly parameterSeparator: string;
-    readonly parametersEnd: string;
-    readonly returnTypeAnnotationColon: string;
-    readonly returnType: string;
-    constructor(asyncKeywordWithWhitespace: string, functionKeyword: string, parametersStart: string, parameters: readonly ParameterDeclarationDisplayParts[], parameterSeparator: string, parametersEnd: string, returnTypeAnnotationColon: string, returnType: string);
+    readonly afterParameters: string;
+    constructor(beforeParameters: string, parameters: readonly string[], parameterSeparator: string, afterParameters: string);
     toString(): string;
 }
+export interface TypeDisplayOptions {
+    readonly unionAndAliasTypeDisplayKind: UnionAndAliasTypeDisplayKind;
+    readonly functionTypeDisplayKind: FunctionTypeDisplayKind;
+    readonly displayContainer: boolean;
+}
+export declare const enum UnionAndAliasTypeDisplayKind {
+    Full = 0,
+    OnlyOriginalType = 1
+}
+export declare const enum FunctionTypeDisplayKind {
+    Full = 0,
+    OnlyOriginalType = 1
+}
+export declare function typeToTypeUsage(type: types.Type): TypeUsage;
+export declare function typeEntityToTypeUsage(entity: e.TypeEntity): TypeUsage;
+export declare function createTypeMemberContainer(member: types.TypeMember, analyzer: Analyzer | undefined): TypeMemberDeclarationContainer;
+export declare function createPackageMemberEntityContainer(entity: e.PackageMemberEntity): DeclarationContainer.Package;
+export declare function createTypeMemberEntityContainer(entity: e.TypeMemberEntity): TypeMemberDeclarationContainer;
+export declare function createTypeEntityContainer(entity: e.TypeEntity): DeclarationContainer.Package | undefined;
 export {};

package/build/types/services/common/display/index.d.ts

@@ -0,0 +1,2 @@
+export * from './DisplayService.js';
+export * from './Types.js';

package/build/types/services/common/document-highlights/DocumentHighlightsService.d.ts

@@ -0,0 +1,9 @@
+import { Analyzer } from '../../../analysis/Analyzer.js';
+import { TaskController } from '../../../common/index.js';
+import { SourceFile } from '../../../project/index.js';
+import { Highlight } from './Types.js';
+export declare class DocumentHighlightsService {
+    private readonly referencesService;
+    getDocumentHighlights(analyzer: Analyzer, sourceFile: SourceFile, offset: number, taskController: TaskController): Promise<Highlight[]>;
+    private referenceKindToHighlightKind;
+}

package/build/types/services/common/document-highlights/Types.d.ts

@@ -0,0 +1,11 @@
+import { Range } from '../../../common/index.js';
+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/common/evaluatable-expression/Types.d.ts

@@ -0,0 +1,6 @@
+import { Range } from '../../../common/index.js';
+export declare class EvaluatableExpression {
+    readonly range: Range;
+    readonly value: string;
+    constructor(range: Range, value: string);
+}

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

@@ -0,0 +1,16 @@
+import { Analyzer } from '../../../analysis/Analyzer.js';
+import { Range } from '../../../common/index.js';
+import { SourceFile } from '../../../project/index.js';
+import { NodeSemanticInfo } from '../node-semantic-info/Types.js';
+import { Hover } from './Types.js';
+export declare abstract class HoverService<TSourceFile extends SourceFile> {
+    private displayService;
+    getHover(analyzer: Analyzer, sourceFile: TSourceFile, offset: number): Hover | undefined;
+    protected abstract getSemanticInfoAndRangeAtOffset(analyzer: Analyzer, sourceFile: TSourceFile, offset: number): {
+        semanticInfo: NodeSemanticInfo;
+        range: Range;
+    } | undefined;
+    private createHoverForEntity;
+    private createHoverAtReference;
+    private createHoverAtAccessedFunction;
+}

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

@@ -0,0 +1,8 @@
+import { Range } from '../../../common/index.js';
+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/common/node-semantic-info/Types.d.ts

@@ -0,0 +1,101 @@
+import { MatchResultParameter } from '../../../analysis/a/ArgumentToParameterMatchResult.js';
+import { AccessedFunction } from '../../../analysis/AccessedFunction.js';
+import { PackageNameTreeNode } from '../../../analysis/ImportedPackageNameTree.js';
+import { AccessKind, ReadonlyNonEmptyArray } from '../../../common/index.js';
+import { AliasTypeEntity, Entity, FunctionEntity, FunctionTypeEntity, PackageEntity, StructuredTypeEntity, Translation, TypeParameterEntity, VariableEntity, VariantTypeEntity } from '../../../entities/index.js';
+import * as types from '../../../types/index.js';
+export type NodeSemanticInfo = DefinitionNodeSemanticInfo | ReferenceNodeSemanticInfo | DefaultSwitchMatchNodeSemanticInfo;
+export declare class DefinitionNodeSemanticInfo {
+    readonly entity: Entity;
+    readonly kind = "definition";
+    constructor(entity: Entity);
+}
+export declare class ReferenceNodeSemanticInfo {
+    readonly targets: ReadonlyNonEmptyArray<ReferenceTarget>;
+    readonly isAmbiguous: boolean;
+    readonly betterTargets?: ReadonlyNonEmptyArray<ReferenceTarget> | undefined;
+    readonly kind = "reference";
+    get firstTarget(): ReferenceTarget;
+    get firstBetterTargetWithFallback(): ReferenceTarget;
+    constructor(targets: ReadonlyNonEmptyArray<ReferenceTarget>, isAmbiguous: boolean, betterTargets?: ReadonlyNonEmptyArray<ReferenceTarget> | undefined);
+}
+export type ReferenceTarget = EntityReferenceTarget | FieldReferenceTarget | TypeParameterReferenceTarget | ConstructorReferenceTarget | DereferenceOperatorReferenceTarget | AccessedFunctionReferenceTarget | IndexerReferenceTarget | MatchResultParameterReferenceTarget | PackageReferenceTarget | PackageNameTreeNodeReferenceTarget | TypeContextReferenceTarget;
+export declare class EntityReferenceTarget {
+    readonly entity: Entity;
+    readonly accessKind: AccessKind;
+    readonly narrowedType?: types.Type | undefined;
+    readonly kind = "entity";
+    constructor(entity: Entity, accessKind: AccessKind, narrowedType?: types.Type | undefined);
+}
+export declare class FieldReferenceTarget {
+    readonly field: types.Field;
+    readonly accessKind: AccessKind;
+    readonly narrowedType: types.Type | undefined;
+    readonly kind = "field";
+    constructor(field: types.Field, accessKind: AccessKind, narrowedType: types.Type | undefined);
+}
+export declare class TypeParameterReferenceTarget {
+    readonly parameter: types.Parameter;
+    readonly accessKind: AccessKind;
+    readonly kind = "type-value-parameter";
+    constructor(parameter: types.Parameter, accessKind: AccessKind);
+}
+export declare class ConstructorReferenceTarget {
+    readonly constructor_: types.Constructor;
+    readonly kind = "type-constructor";
+    constructor(constructor_: types.Constructor);
+}
+export declare class DereferenceOperatorReferenceTarget {
+    readonly operator: types.DereferenceOperator;
+    readonly accessKind: AccessKind;
+    readonly kind = "type-dereference-operator";
+    constructor(operator: types.DereferenceOperator, accessKind: AccessKind);
+}
+export declare class AccessedFunctionReferenceTarget {
+    readonly func: AccessedFunction;
+    readonly kind = "accessed-function";
+    constructor(func: AccessedFunction);
+}
+export declare class MatchResultParameterReferenceTarget {
+    readonly parameter: MatchResultParameter;
+    readonly accessKind: AccessKind;
+    readonly kind = "match-result-value-parameter";
+    constructor(parameter: MatchResultParameter, accessKind: AccessKind);
+}
+export declare class PackageReferenceTarget {
+    readonly package_: PackageEntity;
+    readonly kind = "package";
+    constructor(package_: PackageEntity);
+}
+export declare class PackageNameTreeNodeReferenceTarget {
+    readonly node: PackageNameTreeNode;
+    readonly kind = "package-name-tree-node";
+    constructor(node: PackageNameTreeNode);
+}
+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 IndexerReferenceTarget {
+    readonly indexer: types.Indexer;
+    readonly accessKind: AccessKind;
+    readonly kind = "type-indexer";
+    constructor(indexer: types.Indexer, accessKind: AccessKind);
+}
+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 | VariantTypeEntity | FunctionEntity | TypeParameterEntity | FunctionTypeEntity | StructuredTypeEntity | AliasTypeEntity;
+export declare class DefaultSwitchMatchNodeSemanticInfo {
+    readonly type: types.Type;
+    readonly kind = "default-switch-match";
+    constructor(type: types.Type);
+}
+export {};

package/build/types/services/common/references/ReferencesFinder.d.ts

@@ -0,0 +1,14 @@
+import { Analyzer } from '../../../analysis/Analyzer.js';
+import { Entity } from '../../../entities/index.js';
+import { NodeSemanticInfo } from '../node-semantic-info/Types.js';
+import { DefinitionInfo, ReferenceKind, ReferenceRestrictions, ReferencesSearchOptions } from './Types.js';
+export declare abstract class ReferencesFinder {
+    protected readonly analyzer: Analyzer;
+    protected readonly definitions: readonly DefinitionInfo[];
+    protected readonly restrictions: ReferenceRestrictions;
+    protected readonly options: ReferencesSearchOptions;
+    private isForRename;
+    constructor(analyzer: Analyzer, definitions: readonly DefinitionInfo[], restrictions: ReferenceRestrictions, options: ReferencesSearchOptions);
+    protected ifReferenceToSomeOfDefinitionsThenKind(potentialReferenceSemanticInfo: NodeSemanticInfo | undefined): ReferenceKind | undefined;
+    protected areEntitiesWithSameDefinition(entity1: Entity, entity2: Entity): boolean;
+}

package/build/types/services/common/references/ReferencesSearchUtils.d.ts

@@ -0,0 +1,5 @@
+import { NodeSemanticInfo } from '../node-semantic-info/Types.js';
+import { DefinitionInfo } from './Types.js';
+export declare class ReferencesSearchUtils {
+    static getDefinitionsFromNodeSemanticInfo(info: NodeSemanticInfo): readonly DefinitionInfo[];
+}

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

@@ -0,0 +1,12 @@
+import { Analyzer } from '../../../analysis/Analyzer.js';
+import { TaskController } from '../../../common/index.js';
+import { SourceFile } from '../../../project/index.js';
+import { Reference, ReferencesSearchOptions } from './Types.js';
+export declare class ReferencesService {
+    getReferencesInCompilation(analyzer: Analyzer, sourceFile: SourceFile, offset: number, options: ReferencesSearchOptions, taskController: TaskController): Promise<Reference[]>;
+    getReferencesInFiles(analyzer: Analyzer, sourceFile: SourceFile, offset: number, sourceFiles: Iterable<SourceFile>, options: ReferencesSearchOptions, taskController: TaskController): Promise<Reference[]>;
+    private getReferencedDefinitionInfosAtOffset;
+    private getDefinitionsFromNodeSemanticInfo;
+    private getReferenceRestrictions;
+    private isEntityWithRegularName;
+}

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

@@ -0,0 +1,41 @@
+import { Name, Range } from '../../../common/index.js';
+import { Entity } from '../../../entities/index.js';
+import { SourceFile } from '../../../project/index.js';
+export type EntityWithRegularNameInfo = {
+    name: Name;
+};
+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;
+    readonly isForRename?: boolean;
+};
+export declare class DefinitionInfo {
+    readonly value: Entity;
+    readonly referenceKind: ReferenceKind;
+    constructor(value: Entity, referenceKind: ReferenceKind);
+}
+export declare class ReferenceRestrictions {
+    canBeIdentifier: boolean;
+    canBeAutotypeCall: boolean;
+    canBePrefixUnaryOperator: boolean;
+    canBeBinaryExpressionOperator: boolean;
+    canBeDereferenceOperator: boolean;
+    canBeAssignmentStatementOperator: boolean;
+    canBeObjectParameter: boolean;
+    canBeConstructorDeclaration: boolean;
+    canBeOwnOrBaseConstructorCall: boolean;
+    canBeBaseExpression: boolean;
+    canBeIndexer: boolean;
+}

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

@@ -0,0 +1,17 @@
+import { Analyzer } from '../../../analysis/Analyzer.js';
+import { Range, TaskController } from '../../../common/index.js';
+import { SourceFile } from '../../../project/index.js';
+import { NodeSemanticInfo } from '../node-semantic-info/Types.js';
+import { Rename } from './Types.js';
+export declare abstract class RenameService<TSourceFile extends SourceFile> {
+    private readonly referencesService;
+    prepareRename(analyzer: Analyzer, sourceFile: TSourceFile, offset: number): Range | undefined;
+    rename(analyzer: Analyzer, sourceFile: TSourceFile, offset: number, newText: string, taskController: TaskController): Promise<Rename[]>;
+    protected abstract getSemanticInfoAndRangeOffset(analyzer: Analyzer, sourceFile: TSourceFile, offset: number): {
+        semanticInfo: NodeSemanticInfo;
+        range: Range;
+    } | undefined;
+    private canRename;
+    private declarationWithSemanticInfoCanBeRenamed;
+    private entityCanBeRenamed;
+}

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

@@ -0,0 +1,8 @@
+import { Range } from '../../../common/index.js';
+import { SourceFile } from '../../../project/index.js';
+export declare class Rename {
+    readonly sourceFile: SourceFile;
+    readonly range: Range;
+    readonly text: string;
+    constructor(sourceFile: SourceFile, range: Range, text: string);
+}

package/build/types/services/common/script-editing/ScriptEditingService.d.ts

@@ -0,0 +1,9 @@
+import { Name } from '../../../common/index.js';
+import { AddedScriptBlockInfo } from './Types.js';
+export declare abstract class ScriptEditingService {
+    protected static readonly indentationStep = "  ";
+    protected static readonly elementParameterNameText = "o";
+    protected static readonly elementParameterName: Name;
+    protected createScriptBlockText(blockInfo: AddedScriptBlockInfo, indentation: string, newLine: string): string;
+    protected detectNewLine(text: string): string;
+}

package/build/types/services/common/script-editing/Types.d.ts

@@ -0,0 +1,9 @@
+export interface AddedScriptBlockInfo {
+    readonly name: string;
+    readonly key: string;
+    readonly areaIndex: string | undefined;
+    readonly elementProperties: {
+        readonly [T in string]: string;
+    };
+    readonly nestedBlocks: readonly AddedScriptBlockInfo[];
+}

package/build/types/services/common/selection-rage/Types.d.ts

@@ -0,0 +1,6 @@
+import { Range } from '../../../common/index.js';
+export declare class SelectionRange {
+    readonly range: Range;
+    readonly parent: SelectionRange | undefined;
+    constructor(range: Range, parent: SelectionRange | undefined);
+}

package/build/types/services/{SemanticTokensService.d.ts → common/semantic-tokens/Types.d.ts}

@@ -1,13 +1,4 @@
-import { Analyzer } from '../analysis/index.js';
-import { Range, TaskController } from '../common/index.js';
-import { SourceFile } from '../project/index.js';
-export declare class SemanticTokensService {
-    getSemanticTokens(analyzer: Analyzer, sourceFile: SourceFile, taskController: TaskController): Promise<SemanticToken[]>;
-    getSemanticTokensInRange(analyzer: Analyzer, sourceFile: SourceFile, range: Range, taskController: TaskController): Promise<SemanticToken[]>;
-    private rangesOverlap;
-    private getSemanticTokenKindForNamedFunctionEntity;
-    private isCapitalizedName;
-}
+import { Range } from '../../../common/index.js';
 export declare class SemanticToken {
     readonly range: Range;
     readonly kind: SemanticTokenKind;