@artel/artc 0.6.26017 → 0.6.26019

package/build/types/services/a/DisplayService.d.ts

@@ -0,0 +1,57 @@
+import { Analyzer } from '../../analysis/Analyzer.js';
+import { PackageNameTreeNode } from '../../analysis/ImportedPackageNameTree.js';
+import { PackageLocale } from '../../common/index.js';
+import { GetterEntity, PackageAliasEntity, PackageEntity, SetterEntity, TextTranslationEntity, TypeEntity, TypeExtensionEntity } from '../../entities/index.js';
+import { OperatorKind } from '../../entities/OperatorKind.js';
+import { SourceFile } from '../../project/index.js';
+import { KeywordKind } from '../../tree/a/index.js';
+import type * as types from '../../types/index.js';
+import { BaseDisplayService } from '../common/display/BaseDisplayService.js';
+import { DisplayService } from '../common/display/DisplayService.js';
+import * as t from '../common/display/Types.js';
+export declare class DisplayServiceA extends BaseDisplayService {
+    private readonly locale;
+    protected readonly contextualSourceFile: SourceFile | undefined;
+    constructor(common: DisplayService, analyzer: Analyzer | undefined, locale: PackageLocale, contextualSourceFile: SourceFile | undefined);
+    displayVariableDeclaration(variable: t.VariableDeclaration): string;
+    displayType(type: types.Type): string;
+    getFunctionTypeBodyDisplayParts(type: types.FunctionType): t.FunctionTypeBodyDisplayParts;
+    getNamedTypeDisplayParts(type: t.NamedType): t.NamedTypeDisplayParts;
+    displayPackageAliasEntity(entity: PackageAliasEntity): string;
+    displayPackage(package_: PackageEntity): string;
+    displayPackageNameTreeNode(node: PackageNameTreeNode): string;
+    displayParameterDeclaration(parameter: t.ParameterDeclaration, options?: t.TypeDisplayOptions): string;
+    displayFunctionDeclaration(func: t.FunctionDeclaration): string;
+    getFunctionDeclarationDisplayParts(func: t.FunctionDeclaration): t.FunctionDeclarationDisplayParts;
+    displayAnonymousFunctionDeclaration(func: t.AnonymousFunctionDeclaration): string;
+    displayOperatorKind(kind: OperatorKind): string;
+    displayConstructorDeclaration(constructor: t.ConstructorDeclaration): string;
+    getConstructorDeclarationDisplayParts(constructor: t.ConstructorDeclaration): t.ConstructorDeclarationDisplayParts;
+    displayDestructorDeclaration(destructor: t.DestructorDeclaration): string;
+    displayIndexerDeclaration(indexer: t.IndexerDeclaration): string;
+    getIndexerDeclarationDisplayParts(indexer: t.IndexerDeclaration): t.IndexerDeclarationDisplayParts;
+    displayDereferenceOperatorDeclaration(dereferenceOperator: t.DereferenceOperatorDeclaration): string;
+    displayTypeDeclaration(type: t.TypeDeclaration): string;
+    displayTypeDeclarationEntity(entity: TypeEntity): string;
+    displayTypeParameterValue(value: t.TypeParameterValue): string;
+    displayGetterEntity(entity: GetterEntity): string;
+    displaySetterEntity(entity: SetterEntity): string;
+    displayTypeExtensionEntity(entity: TypeExtensionEntity): string;
+    displayLocalizableTextEntity(entity: TextTranslationEntity): string;
+    displayKeyword(kind: KeywordKind): 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;
+}

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

@@ -0,0 +1,10 @@
+import { Analyzer } from '../../analysis/a/Analyzer.js';
+import { SourceFileA } from '../../project/index.js';
+import { EvaluatableExpression } from '../common/evaluatable-expression/Types.js';
+export declare class EvaluatableExpressionServiceA {
+    getEvaluatableExpression(analyzer: Analyzer, sourceFile: SourceFileA, offset: number): EvaluatableExpression | undefined;
+    private convertEvaluatableExpressionToString;
+    private getEvaluatableExpressionForIdentifier;
+    private isEvaluatableReceiver;
+    private ifNamedDeclarationThenName;
+}

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

@@ -0,0 +1,11 @@
+import { Analyzer } from '../../analysis/Analyzer.js';
+import { Range } from '../../common/index.js';
+import { SourceFileA } from '../../project/index.js';
+import { HoverService } from '../common/hover/HoverService.js';
+import { NodeSemanticInfo } from '../common/node-semantic-info/Types.js';
+export declare class HoverServiceA extends HoverService<SourceFileA> {
+    protected getSemanticInfoAndRangeAtOffset(analyzer: Analyzer, sourceFile: SourceFileA, offset: number): {
+        semanticInfo: NodeSemanticInfo;
+        range: Range;
+    } | undefined;
+}

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

@@ -0,0 +1,45 @@
+import { Analyzer } from '../../analysis/a/Analyzer.js';
+import * as tree from '../../tree/a/index.js';
+import { TokenOrKeyword } from '../a/TreeUtils.js';
+import { NodeSemanticInfo } from '../common/node-semantic-info/Types.js';
+export declare class NodeSemanticInfoServiceA {
+    static ofTokenOrKeyword(analyzer: Analyzer, tokenOrKeyword: TokenOrKeyword, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofRegularOrBlockFunctionLiteral(analyzer: Analyzer, node: tree.RegularOrBlockFunctionLiteral): NodeSemanticInfo | undefined;
+    static ofDefaultMatchExpression(analyzer: Analyzer, node: tree.DefaultMatchExpression): NodeSemanticInfo | undefined;
+    static ofNonKeywordIdentifier(analyzer: Analyzer, node: tree.Identifier, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofMember(analyzer: Analyzer, node: tree.MemberAccessExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofQualifiedNameQualifier(analyzer: Analyzer, node: tree.QualifiedName, qualifier: tree.Identifier, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofNamedTypeSpecifierNameQualifier(analyzer: Analyzer, node: tree.NamedTypeSpecifier, qualifier: tree.Identifier, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofTagNameQualifier(analyzer: Analyzer, node: tree.Tag, qualifier: tree.Identifier, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofIdentifierExpression(analyzer: Analyzer, node: tree.IdentifierExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofConstructorDeclaration(analyzer: Analyzer, node: tree.ConstructorDeclaration): NodeSemanticInfo;
+    static ofIndexedElementAccessorDeclaration(analyzer: Analyzer, node: tree.IndexedElementAccessorDeclaration): 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 ofPrefixUnaryExpressionOperator(analyzer: Analyzer, node: tree.PrefixUnaryExpression, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofDereferenceOperatorDeclaration(analyzer: Analyzer, node: tree.DereferencedVariableGetterDeclaration | tree.DereferencedVariableSetterDeclaration): 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 ofOwnConstructorCallExpression(analyzer: Analyzer, node: tree.OwnConstructorCallExpression, 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;
+    static ofConstructorTranslationSourceConstructor(analyzer: Analyzer, node: tree.ConstructorTranslation, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofConstructorTranslationTranslatedConstructor(analyzer: Analyzer, node: tree.ConstructorTranslation, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofIndexerTranslationSourceIndexer(analyzer: Analyzer, node: tree.IndexerTranslation, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofIndexerTranslationTranslatedIndexer(analyzer: Analyzer, node: tree.IndexerTranslation, options: NodeSemanticInfoServiceOptions): NodeSemanticInfo | undefined;
+    static ofOjectParameterDeclaration(analyzer: Analyzer, node: tree.ParameterDeclaration, _objectKeyword: tree.Keyword<tree.KeywordKind.Object>): NodeSemanticInfo;
+    private static ofPackageNameSegmentAccess;
+    private static ofConstructorCallWithTypeAccess;
+    private static ofTranslationTypeParameterListParameter;
+    private static ofTranslationParameterListParameter;
+    private static getBetterReferenceTargetsOrPreserve;
+    private static getBetterReferenceTarget;
+    private static getResolvedContainingTranslationPackage;
+    private static ofAccessedFunctions;
+    private static ofConstructors;
+}
+export type NodeSemanticInfoServiceOptions = {
+    readonly preferredTargetOfExplicitConstructorCall: 'type-declaration' | 'constructor-declaration';
+    readonly includeBetterReferenceTargets: boolean;
+};

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

@@ -0,0 +1,11 @@
+import { Analyzer } from '../../analysis/Analyzer.js';
+import { Range } from '../../common/index.js';
+import { SourceFileA } from '../../project/index.js';
+import { NodeSemanticInfo } from '../common/node-semantic-info/Types.js';
+import { RenameService } from '../common/rename/RenameService.js';
+export declare class RenameServiceA extends RenameService<SourceFileA> {
+    protected getSemanticInfoAndRangeOffset(analyzer: Analyzer, sourceFile: SourceFileA, offset: number): {
+        semanticInfo: NodeSemanticInfo;
+        range: Range;
+    } | undefined;
+}

package/build/types/services/a/ScriptEditingService.d.ts

@@ -0,0 +1,13 @@
+import { Analyzer } from '../../analysis/a/Analyzer.js';
+import { SourceFileA } from '../../project/index.js';
+import * as tree from '../../tree/a/index.js';
+import { ScriptEditingService } from '../common/script-editing/ScriptEditingService.js';
+import { AddedScriptBlockInfo } from '../common/script-editing/Types.js';
+import { NodeLocation, SourceFileEdit } from '../common/Types.js';
+export declare class ScriptEditingServiceA extends ScriptEditingService {
+    createEditWithFieldAssignment(analyzer: Analyzer, sourceFile: SourceFileA, scriptDeclaration: tree.SubprogramDeclarationOrLiteral, fieldName: string, value: string): SourceFileEdit | undefined;
+    createEditAddingBlocks(sourceFile: SourceFileA, scriptDeclaration: tree.SubprogramDeclarationOrLiteral, addedBlockInfos: readonly AddedScriptBlockInfo[]): SourceFileEdit | undefined;
+    canDeleteBlocks(outerScriptFunctionLocation: NodeLocation, scriptFunctionLocations: readonly NodeLocation[]): boolean;
+    createEditDeletingBlock(sourceFile: SourceFileA, scriptDeclaration: tree.SubprogramDeclarationOrLiteral): SourceFileEdit | undefined;
+    private findLastAssignmentToField;
+}

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

@@ -0,0 +1,7 @@
+import { SourceFileA } from '../../project/SourceFile.js';
+import { SelectionRange } from '../common/selection-rage/Types.js';
+export declare class SelectionRangeServiceA {
+    getSelectionRange(sourceFile: SourceFileA, offset: number): SelectionRange | undefined;
+    private nodeContainsOffset;
+    private nodeShouldBeSkipped;
+}

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

@@ -0,0 +1,11 @@
+import { Analyzer } from '../../analysis/a/Analyzer.js';
+import { Range, TaskController } from '../../common/index.js';
+import { SourceFileA } from '../../project/index.js';
+import { SemanticToken } from '../common/semantic-tokens/Types.js';
+export declare class SemanticTokensServiceA {
+    getSemanticTokens(analyzer: Analyzer, sourceFile: SourceFileA, taskController: TaskController): Promise<SemanticToken[]>;
+    getSemanticTokensInRange(analyzer: Analyzer, sourceFile: SourceFileA, range: Range, taskController: TaskController): Promise<SemanticToken[]>;
+    private rangesOverlap;
+    private getSemanticTokenKindForNamedFunctionEntity;
+    private isCapitalizedName;
+}

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

@@ -0,0 +1,11 @@
+import { SourceFileA } from '../../project/index.js';
+import { SourceFileItem } from '../common/source-file-items/Types.js';
+export declare class SourceFileItemsServiceA {
+    private sourceFile;
+    getItems(sourceFile: SourceFileA): SourceFileItem[];
+    private get locale();
+    private get dialect();
+    private getChildItems;
+    private createItem;
+    private getNameOrStubIfEmpty;
+}

package/build/types/services/{TranslationService.d.ts → a/TranslationService.d.ts}

@@ -1,11 +1,11 @@
 import { TextDocument } from 'vscode-languageserver-textdocument';
-import { Analyzer } from '../analysis/index.js';
-import { Range } from '../common/index.js';
-import { SourceFile } from '../project/index.js';
+import { Analyzer } from '../../analysis/a/Analyzer.js';
+import { Range } from '../../common/index.js';
+import { SourceFileA } from '../../project/index.js';
 export declare class TranslationService {
     private readonly translationCache;
     constructor();
-    translateSourceFile(analyzer: Analyzer, sourceFile: SourceFile, localeText: string): Translation;
+    translateSourceFile(analyzer: Analyzer, sourceFile: SourceFileA, localeText: string): Translation;
     clearTranslationCache(): void;
     private translateIdentifier;
     private translateKeywords;

package/build/types/services/a/TranslationsGenerationService.d.ts

@@ -0,0 +1,7 @@
+import { Analyzer } from '../../analysis/a/Analyzer.js';
+import { SourceFileA } from '../../project/SourceFile.js';
+import { SourceFileEdit } from '../common/Types.js';
+export declare class TranslationsGenerationServiceA {
+    generateMissingTranslations(analyzer: Analyzer, sourceFile: SourceFileA, offset: number, onlyTypeMembers: boolean): SourceFileEdit[] | undefined;
+    isOffsetAtTranslationsContainingPartiallyTranslatedTypes(analyzer: Analyzer, sourceFile: SourceFileA, offset: number): boolean;
+}

package/build/types/services/{TreeUtils.d.ts → a/TreeUtils.d.ts}

@@ -1,4 +1,4 @@
-import * as tree from '../tree/index.js';
+import * as tree from '../../tree/a/index.js';
 /**
  * Получить самый правый токен, для которого `rangeWithoutTrivia.end <= offset`.
  */

package/build/types/services/a/references/DefinitionInfoFinder.d.ts

@@ -0,0 +1,6 @@
+import { Analyzer } from '../../../analysis/Analyzer.js';
+import { SourceFileA } from '../../../project/index.js';
+import { DefinitionInfo, ReferencesSearchOptions } from '../../common/references/Types.js';
+export declare class DefinitionInfoFinderA {
+    static getReferencedDefinitionInfosAtOffsetA(analyzer: Analyzer, sourceFile: SourceFileA, offset: number, options: ReferencesSearchOptions): readonly DefinitionInfo[];
+}

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

@@ -0,0 +1,7 @@
+import { TaskController } from '../../../common/index.js';
+import { SourceFileA } from '../../../project/SourceFile.js';
+import { ReferencesFinder } from '../../common/references/ReferencesFinder.js';
+import { Reference } from '../../common/references/Types.js';
+export declare class ReferencesFinderA extends ReferencesFinder {
+    findReferencesInSourceFileA(sourceFile: SourceFileA, result: Reference[], taskController: TaskController): Promise<void>;
+}

package/build/types/services/{signature-help → a/signature-help}/ParametersSignatureHelpProvider.d.ts

@@ -1,13 +1,13 @@
-import { Analyzer } from '../../analysis/index.js';
-import { SourceFile } from '../../project/index.js';
-import { SignatureHelp } from './SignatureHelpService.js';
+import { Analyzer } from '../../../analysis/a/Analyzer.js';
+import { SourceFileA } from '../../../project/index.js';
+import { SignatureHelp } from '../../common/signature-help/Types.js';
 export declare class ParametersSignatureHelpProvider {
     private readonly signatureContext_;
     private readonly analyzer;
     private readonly sourceFile;
     private readonly offset;
     private get signatureContext();
-    constructor(analyzer: Analyzer, sourceFile: SourceFile, offset: number);
+    constructor(analyzer: Analyzer, sourceFile: SourceFileA, offset: number);
     provideSignatureHelp(): SignatureHelp | undefined;
     private getNodeWithArgumentsInfoAtOffset;
     private getArgumentIndexInList;

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

@@ -0,0 +1,6 @@
+import { Analyzer } from '../../../analysis/a/Analyzer.js';
+import { SourceFileA } from '../../../project/index.js';
+import { SignatureHelp } from '../../common/signature-help/Types.js';
+export declare class SignatureHelpServiceA {
+    getSignatureHelp(analyzer: Analyzer, sourceFile: SourceFileA, offset: number): SignatureHelp | undefined;
+}

package/build/types/services/{signature-help → a/signature-help}/SignatureWithParameters.d.ts

@@ -1,9 +1,9 @@
-import { AccessedFunction } from '../../analysis/AccessedFunction.js';
-import { Analyzer } from '../../analysis/index.js';
-import { Name } from '../../common/index.js';
-import { ParameterEntity } from '../../entities/index.js';
-import * as tree from '../../tree/index.js';
-import * as types from '../../types/index.js';
+import { AccessedFunction } from '../../../analysis/AccessedFunction.js';
+import { Analyzer } from '../../../analysis/a/Analyzer.js';
+import { Name } from '../../../common/index.js';
+import { ParameterEntity } from '../../../entities/index.js';
+import * as tree from '../../../tree/a/index.js';
+import * as types from '../../../types/index.js';
 export declare class ArgumentFactory {
     static createArgumentsOfCallExpression(node: tree.CallExpression): Argument[];
     static createArgumentsOfAutotypeCallExpression(node: tree.AutotypeCallExpression): Argument[];

package/build/types/services/{signature-help → a/signature-help}/TypeParameterSignatureHelpProvider.d.ts

@@ -1,13 +1,13 @@
-import { Analyzer } from '../../analysis/index.js';
-import { SourceFile } from '../../project/index.js';
-import { SignatureHelp } from './SignatureHelpService.js';
+import { Analyzer } from '../../../analysis/a/Analyzer.js';
+import { SourceFileA } from '../../../project/index.js';
+import { SignatureHelp } from '../../common/signature-help/Types.js';
 export declare class TypeParameterSignatureHelpProvider {
     private readonly signatureContext_;
     private readonly analyzer;
     private readonly sourceFile;
     private readonly offset;
     private get signatureContext();
-    constructor(analyzer: Analyzer, sourceFile: SourceFile, offset: number);
+    constructor(analyzer: Analyzer, sourceFile: SourceFileA, offset: number);
     provideSignatureHelp(): SignatureHelp | undefined;
     private getNodeWithTypeArgumentsInfoAtOffset;
     private getArgumentIndex;

package/build/types/services/{signature-help → a/signature-help}/utils.d.ts

@@ -1,4 +1,4 @@
-import { SignatureInfo } from './SignatureHelpService.js';
+import { SignatureInfo } from '../../common/signature-help/Types.js';
 export declare class SignatureDisplayParts {
     readonly prefix: string;
     readonly parameters: readonly string[];

package/build/types/services/{FileSystemTreeDisplayService.d.ts → common/FileSystemTreeDisplayService.d.ts}

@@ -1,4 +1,4 @@
-import { Directory } from '../project/FileSystemTree.js';
+import { Directory } from '../../project/FileSystemTree.js';
 export declare class FileSystemTreeDisplayService {
     static readonly indentation = 2;
     static readonly ignoredFolderNameSet: Set<string>;

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

@@ -1,7 +1,7 @@
 import * as ls from 'vscode-languageserver';
-import { Range, Uri } from '../common/index.js';
-import { SourceFile } from '../project/index.js';
-import * as tree from '../tree/index.js';
+import { Range, Uri } from '../../common/index.js';
+import { SourceFile } from '../../project/index.js';
+import { NodePath } from '../../tree/index.js';
 export type RangeLocation = {
     uri: Uri;
     range: Range;
@@ -33,6 +33,6 @@ export declare class SourceFileEdit {
 }
 export declare class NodeLocation {
     readonly sourceFile: SourceFile;
-    readonly path: tree.NodePath;
-    constructor(sourceFile: SourceFile, path: tree.NodePath);
+    readonly path: NodePath;
+    constructor(sourceFile: SourceFile, path: NodePath);
 }

package/build/types/services/{Utils.d.ts → common/Utils.d.ts}

@@ -1,5 +1,5 @@
-import { Analyzer } from '../analysis/index.js';
-import { Entity } from '../entities/index.js';
+import { Analyzer } from '../../analysis/Analyzer.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/common/WorkspaceItemsService.d.ts

@@ -0,0 +1,6 @@
+import { Compilation } from '../../project/index.js';
+import { SourceFileItem } from './source-file-items/Types.js';
+export declare class WorkspaceItemsService {
+    private readonly sourceFileItemsServiceA;
+    getItems(compilations: readonly Compilation[]): SourceFileItem[];
+}

package/build/types/services/{CodeActionsService.d.ts → common/code-action/Types.d.ts}

@@ -1,12 +1,4 @@
-import { Analyzer } from '../analysis/Analyzer.js';
-import { DiagnosticCode } from '../diagnostic/DiagnosticCode.js';
-import { SourceFile } from '../project/SourceFile.js';
-import { SourceFileEdit } from './Types.js';
-export declare class CodeActionsService {
-    private readonly translationsGeneratorService;
-    getCodeActions(analyzer: Analyzer, sourceFile: SourceFile, offset: number, diagnosticCodes: readonly DiagnosticCode[] | undefined): CodeAction[] | undefined;
-    resolveEdits(analyzer: Analyzer, sourceFile: SourceFile, offset: number, name: string, data: any): SourceFileEdit[] | undefined;
-}
+import { SourceFileEdit } from '../../common/Types.js';
 export declare class CodeAction {
     readonly title: string;
     readonly name: string;
@@ -20,3 +12,10 @@ export declare class CodeAction {
 export declare enum CodeActionKind {
     QuickFix = 0
 }
+export declare enum CodeActionName {
+    GenerateMissingTranslations = "GenerateMissingTranslations"
+}
+export interface GenerateMissingTranslationsCodeActionData {
+    onlyTypeMembers: boolean;
+}
+export declare function isGenerateMissingTranslationsCodeActionData(value: unknown): value is GenerateMissingTranslationsCodeActionData;

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

@@ -0,0 +1,49 @@
+import { Range } from '../../../common/index.js';
+import { SourceFile } from '../../../project/SourceFile.js';
+export declare class CompletionItem {
+    readonly label: string;
+    readonly kind: CompletionItemKind;
+    readonly details: string | undefined;
+    readonly insertText: string | undefined;
+    readonly editRange: Range | undefined;
+    readonly sortText: string | undefined;
+    readonly cacheId: number;
+    readonly indexInCache: number;
+    constructor(label: string, kind: CompletionItemKind, details: string | undefined, insertText: string | undefined, editRange: Range | undefined, sortText: string | undefined, cacheId: number, indexInCache: number);
+}
+export declare const enum CompletionItemKind {
+    PackageNameSegment = 0,
+    PackageAlias = 1,
+    Field = 2,
+    Method = 3,
+    Operator = 4,
+    Indexer = 5,
+    Constructor = 6,
+    PackageVariable = 7,
+    PackageFunction = 8,
+    LocalVariable = 9,
+    Parameter = 10,
+    NestedFunction = 11,
+    VariantValue = 12,
+    Class = 13,
+    Structure = 14,
+    Aspect = 15,
+    Variant = 16,
+    TypeParameter = 17,
+    AliasType = 18,
+    ReducedType = 19,
+    InvalidType = 20,
+    Keyword = 21,
+    TargetSignatureParameter = 22,
+    OperatorName = 23
+}
+export type ResolutionResult = ResolutionResult_item | ResolutionResult_notInCache;
+export declare class ResolutionResult_item {
+    readonly value: CompletionItem;
+    readonly sourceFile: SourceFile;
+    readonly kind = "item";
+    constructor(value: CompletionItem, sourceFile: SourceFile);
+}
+export declare class ResolutionResult_notInCache {
+    readonly kind = "not-in-cache";
+}

package/build/types/services/common/definition/DefinitionService.d.ts

@@ -0,0 +1,23 @@
+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 { SourceGenerationService } from '../source-generation/SourceGenerationService.js';
+import { DefinitionsAndReferenceInfo } from './Types.js';
+export declare abstract class DefinitionService<TSourceFile extends SourceFile> {
+    private readonly sourceGenerationService;
+    constructor(sourceGenerationService: SourceGenerationService | undefined);
+    getDefinition(analyzer: Analyzer, sourceFile: TSourceFile, offset: number, taskController: TaskController): Promise<DefinitionsAndReferenceInfo | undefined>;
+    getTypeDefinition(analyzer: Analyzer, sourceFile: TSourceFile, offset: number, taskController: TaskController): Promise<DefinitionsAndReferenceInfo | undefined>;
+    protected abstract getSemanticInfoAndRangeAtOffset(analyzer: Analyzer, sourceFile: TSourceFile, offset: number): {
+        semanticInfo: NodeSemanticInfo;
+        range: Range;
+    } | undefined;
+    private getDefinitionOfReference;
+    private getReferenceTargetSourceLocation;
+    private getReferenceTargetEntity;
+    private getSourceLocationsOfVariableEntity;
+    private getSourceLocationsOfSpecialVariable;
+    private getTypesOfReference;
+    private getEntitiesThatMakeUpTheType;
+}

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

@@ -0,0 +1,7 @@
+import { Range } from '../../../common/index.js';
+import { SourceLocation } from '../Types.js';
+export declare class DefinitionsAndReferenceInfo {
+    readonly definitionLocations: readonly SourceLocation[];
+    readonly referenceRange: Range;
+    constructor(definitionLocations: readonly SourceLocation[], referenceRange: Range);
+}

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

@@ -0,0 +1,41 @@
+import { Analyzer } from '../../../analysis/Analyzer.js';
+import { PackageNameTreeNode } from '../../../analysis/ImportedPackageNameTree.js';
+import { Name, Option } from '../../../common/index.js';
+import * as e from '../../../entities/index.js';
+import { SourceFile } from '../../../project/SourceFile.js';
+import * as types from '../../../types/index.js';
+import { DisplayService } from './DisplayService.js';
+import * as t from './Types.js';
+export declare abstract class BaseDisplayService {
+    protected readonly analyzer: Analyzer | undefined;
+    protected readonly common: DisplayService;
+    private packageNameShorteningMap;
+    protected abstract contextualSourceFile: SourceFile | undefined;
+    constructor(analyzer: Analyzer | undefined, common: DisplayService);
+    abstract displayVariableDeclaration(variable: t.VariableDeclaration): string;
+    abstract displayType(type: types.Type): string;
+    abstract getFunctionTypeBodyDisplayParts(type: types.FunctionType): t.FunctionTypeBodyDisplayParts;
+    abstract getNamedTypeDisplayParts(type: t.NamedType): t.NamedTypeDisplayParts;
+    abstract displayPackageAliasEntity(entity: e.PackageAliasEntity): string;
+    abstract displayPackage(package_: e.PackageEntity): string;
+    abstract displayPackageNameTreeNode(node: PackageNameTreeNode): string;
+    abstract displayParameterDeclaration(parameter: t.ParameterDeclaration, options: t.TypeDisplayOptions | undefined): string;
+    abstract displayFunctionDeclaration(func: t.FunctionDeclaration): string;
+    abstract getFunctionDeclarationDisplayParts(func: t.FunctionDeclaration): t.FunctionDeclarationDisplayParts;
+    abstract displayAnonymousFunctionDeclaration(func: t.AnonymousFunctionDeclaration): string;
+    abstract displayOperatorKind(kind: e.OperatorKind): string;
+    abstract displayConstructorDeclaration(constructor: t.ConstructorDeclaration): string;
+    abstract getConstructorDeclarationDisplayParts(constructor: t.ConstructorDeclaration): t.ConstructorDeclarationDisplayParts;
+    abstract displayDestructorDeclaration(destructor: t.DestructorDeclaration): string;
+    abstract displayIndexerDeclaration(indexer: t.IndexerDeclaration): string;
+    abstract getIndexerDeclarationDisplayParts(indexer: t.IndexerDeclaration): t.IndexerDeclarationDisplayParts;
+    abstract displayDereferenceOperatorDeclaration(dereferenceOperator: t.DereferenceOperatorDeclaration): string;
+    abstract displayTypeDeclaration(type: t.TypeDeclaration): string;
+    abstract displayTypeDeclarationEntity(entity: e.TypeEntity): string;
+    abstract displayTypeParameterValue(value: t.TypeParameterValue): string;
+    abstract displayGetterEntity(entity: e.GetterEntity): string;
+    abstract displaySetterEntity(entity: e.SetterEntity): string;
+    abstract displayTypeExtensionEntity(entity: e.TypeExtensionEntity): string;
+    abstract displayLocalizableTextEntity(entity: e.TextTranslationEntity): string;
+    protected getPackageNameShorteningMap(): ReadonlyMap<e.PackageEntity, Option<Name>> | undefined;
+}

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

@@ -0,0 +1,52 @@
+import { Analyzer } from '../../../analysis/Analyzer.js';
+import { PackageNameTreeNode } from '../../../analysis/ImportedPackageNameTree.js';
+import { HelperPhraseKind, Name, PackageDialect, PackageLocale } from '../../../common/index.js';
+import { Entity, NamedEntity } from '../../../entities/Entity.js';
+import { GetterEntity, PackageAliasEntity, PackageEntity, SetterEntity, TextTranslationEntity, TypeExtensionEntity } from '../../../entities/interfaces/index.js';
+import { OperatorKind } from '../../../entities/OperatorKind.js';
+import { TypeEntity } from '../../../entities/TypeEntity.js';
+import { SourceFile } from '../../../project/index.js';
+import * as types from '../../../types/index.js';
+import { DisplayServiceA } from '../../a/DisplayService.js';
+import * as t from './Types.js';
+export declare class DisplayService {
+    private readonly analyzer;
+    private readonly locale;
+    private readonly dialect;
+    private readonly contextualSourceFile?;
+    private a_;
+    get a(): DisplayServiceA;
+    constructor(analyzer: Analyzer | undefined, locale: PackageLocale, dialect: PackageDialect, contextualSourceFile?: SourceFile | undefined);
+    displayVariableDeclaration(variable: t.VariableDeclaration): string;
+    displayType(type: types.Type): string;
+    getFunctionTypeBodyDisplayParts(type: types.FunctionType): t.FunctionTypeBodyDisplayParts;
+    getNamedTypeDisplayParts(type: t.NamedType): t.NamedTypeDisplayParts;
+    displayPackageAliasEntity(entity: PackageAliasEntity): string;
+    displayPackage(package_: PackageEntity): string;
+    displayPackageNameTreeNode(node: PackageNameTreeNode): string;
+    displayParameterDeclaration(parameter: t.ParameterDeclaration, options?: t.TypeDisplayOptions): string;
+    displayFunctionDeclaration(func: t.FunctionDeclaration): string;
+    getFunctionDeclarationDisplayParts(func: t.FunctionDeclaration): t.FunctionDeclarationDisplayParts;
+    displayAnonymousFunctionDeclaration(func: t.AnonymousFunctionDeclaration): string;
+    displayOperatorKind(kind: OperatorKind): string;
+    displayConstructorDeclaration(constructor: t.ConstructorDeclaration): string;
+    getConstructorDeclarationDisplayParts(constructor: t.ConstructorDeclaration): t.ConstructorDeclarationDisplayParts;
+    displayDestructorDeclaration(destructor: t.DestructorDeclaration): string;
+    displayIndexerDeclaration(indexer: t.IndexerDeclaration): string;
+    getIndexerDeclarationDisplayParts(indexer: t.IndexerDeclaration): t.IndexerDeclarationDisplayParts;
+    displayDereferenceOperatorDeclaration(dereferenceOperator: t.DereferenceOperatorDeclaration): string;
+    displayTypeDeclaration(type: t.TypeDeclaration): string;
+    displayTypeDeclarationEntity(entity: TypeEntity): string;
+    displayTypeParameterValue(value: t.TypeParameterValue): string;
+    displayGetterEntity(entity: GetterEntity): string;
+    displaySetterEntity(entity: SetterEntity): string;
+    displayTypeExtensionEntity(entity: TypeExtensionEntity): string;
+    displayLocalizableTextEntity(entity: TextTranslationEntity): string;
+    displayEntity(entity: Entity): string;
+    displayTypeEntity(entity: TypeEntity): string;
+    displayTypeMember(member: types.TypeMember): string;
+    displayHelperPhrase(kind: HelperPhraseKind): string;
+    displayEntityName(entity: NamedEntity): string;
+    displayName(name: Name): string;
+    private getDialectSpecificService;
+}