@artel/artc 0.6.25244 → 0.6.25246

package/build/types/analysis/AutotypeCallExpressionMeaning.d.ts

@@ -1,7 +1,6 @@
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { AutotypeCallExpression } from '../tree/index.js';
 import * as types from '../types/index.js';
-import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
 import { Analyzer, TargetTypeHint } from './index.js';
 export declare class Resolver {
     private readonly _analyzer;
@@ -20,8 +19,8 @@ declare class Meaning_constructorCall {
      * с ним совместим.
      */
     readonly type: types.Type;
-    readonly candidates: readonly FoundAnonymousDeclaration<types.Constructor>[];
-    readonly suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[];
+    readonly candidates: readonly types.Constructor[];
+    readonly suitableConstructors: readonly types.Constructor[];
     readonly kind = "constructor-call";
     constructor(
     /**
@@ -31,7 +30,7 @@ declare class Meaning_constructorCall {
      * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
      * с ним совместим.
      */
-    type: types.Type, candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
+    type: types.Type, candidates: readonly types.Constructor[], suitableConstructors: readonly types.Constructor[]);
 }
 declare class Meaning_unresolved {
     readonly diagnostics: readonly Diagnostic[];

package/build/types/analysis/BaseExpressionMeaning.d.ts

@@ -2,7 +2,6 @@ import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
-import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
 /**
  * "основа" не является самостоятельным выражением и может использоваться только в следующих конструкциях:
  * 1. `основа()` - в конструкторе для вызова базового конструктора или в методе для вызова базового метода.
@@ -16,16 +15,22 @@ export declare class Resolver {
     private readonly _analyzer;
     private readonly _node;
     constructor(analyzer: Analyzer, node: tree.BaseExpression);
-    resolve(): Meaning;
+    resolve(): ResolutionsResult;
     private resolveBaseConstructorOrMethodAccess;
     private resolveBaseConstructorAccess;
     private resolveBaseMethodAccess;
     private resolveBaseOperatorAccess;
     private resolveBaseObjectAccess;
-    private invalidContextMeaning;
+    private invalidContextDiagnostic;
     private getBaseOrAliasedType;
     private getContainingTypeMemberDeclaration;
 }
+export declare class ResolutionsResult {
+    readonly meaning: Meaning;
+    readonly diagnostics?: readonly Diagnostic[] | undefined;
+    constructor(meaning: Meaning, diagnostics?: readonly Diagnostic[] | undefined);
+    static unresolved(diagnostics?: readonly Diagnostic[]): ResolutionsResult;
+}
 export type Meaning = Meaning_baseObjectAccess | Meaning_baseConstructorAccess | Meaning_overriddenMethodAccess | Meaning_overriddenOperatorAccess | Meaning_unresolved;
 declare class Meaning_baseObjectAccess {
     readonly type: types.Type;
@@ -41,9 +46,10 @@ declare class Meaning_baseConstructorAccess {
      * с ним совместим.
      */
     readonly type: types.Type;
-    readonly candidates: readonly FoundAnonymousDeclaration<types.Constructor>[];
-    readonly suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[];
+    readonly candidates: readonly types.Constructor[];
+    readonly suitableConstructors: readonly types.Constructor[];
     readonly kind = "base-constructor-access";
+    get singleSuitableConstructor(): types.Constructor | undefined;
     constructor(
     /**
      * Тип объекта, получаемого в результате вызова конструктора.
@@ -52,7 +58,7 @@ declare class Meaning_baseConstructorAccess {
      * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
      * с ним совместим.
      */
-    type: types.Type, candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
+    type: types.Type, candidates: readonly types.Constructor[], suitableConstructors: readonly types.Constructor[]);
 }
 declare class Meaning_overriddenMethodAccess {
     readonly method: types.Method;
@@ -65,8 +71,6 @@ declare class Meaning_overriddenOperatorAccess {
     constructor(operator: types.Operator);
 }
 declare class Meaning_unresolved {
-    readonly diagnostic: Diagnostic;
     readonly kind = "unresolved";
-    constructor(diagnostic: Diagnostic);
 }
 export {};

package/build/types/analysis/BaseMemberConflictsValidator.d.ts

@@ -1,28 +1,26 @@
-import { PackageDialect } from '../common/index.js';
 import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { IEntityHidingMatcher, TypeEntityWithMembers } from '../entities/index.js';
 import { Node } from '../tree/index.js';
 import { Analyzer } from './Analyzer.js';
-import { LocalizationContext } from './LocalizationContext.js';
+import { DiagnosticArgumentFactory } from './DiagnosticArgumentFactory.js';
 export declare class BaseMemberConflictsValidator {
     private readonly _analyzer;
     private readonly _typeEntity;
     private readonly _hidingMatcher;
-    private readonly _localizationContext;
-    private readonly _dialect;
+    private readonly _diagnosticArgumentFactory;
     private readonly _diagnostics;
     private readonly _nodeForDiagnostic;
-    private _displayService;
-    private get displayService();
-    constructor(_analyzer: Analyzer, _typeEntity: TypeEntityWithMembers, _hidingMatcher: IEntityHidingMatcher, _localizationContext: LocalizationContext, _dialect: PackageDialect | undefined, _diagnostics: DiagnosticAcceptor, _nodeForDiagnostic: Node);
+    constructor(_analyzer: Analyzer, _typeEntity: TypeEntityWithMembers, _hidingMatcher: IEntityHidingMatcher, _diagnosticArgumentFactory: DiagnosticArgumentFactory, _diagnostics: DiagnosticAcceptor, _nodeForDiagnostic: Node);
     validate(): void;
     private getAllNotShadowedNotOverriddenMembers;
-    private validateMemberConflictsMutatingMap;
-    private validateNamedMemberConflictsUsingOriginalNames;
+    private validateMemberConflicts;
     private doTypeMembersConflict;
+    private doNamedTypeMemberConflictInOriginalLanguage;
+    private doNamedTypeMembersConflict;
     private reportMembersConflictDiagnostic;
     private reportMembersOriginalNameConflictConflictDiagnostic;
     private addOverriddenMembersRecursively;
     private typeMemberMatchesHiding;
-    private getOriginalNameOfLeastOverriddenMember;
+    private getOriginalTypeMemberNameConsideringOverriddenMembers;
+    private getLeastOverriddenNamedMember;
 }

package/build/types/analysis/CallExpressionMeaning.d.ts

@@ -2,8 +2,6 @@ import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { CallExpression } from '../tree/index.js';
 import * as types from '../types/index.js';
 import { AccessedFunction } from './AccessedFunction.js';
-import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
-import { WithLocalization } from './Localization.js';
 import { Analyzer } from './index.js';
 export declare class Resolver {
     private readonly _analyzer;
@@ -18,14 +16,14 @@ export declare class Resolver {
 }
 export type Meaning = Meaning_functionCall | Meaning_operatorCall | Meaning_objectFunctionCall | Meaning_constructorCall | Meaning_unresolved;
 declare class Meaning_functionCall {
-    readonly func: WithLocalization<AccessedFunction>;
+    readonly func: AccessedFunction;
     readonly kind = "function-call";
-    constructor(func: WithLocalization<AccessedFunction>);
+    constructor(func: AccessedFunction);
 }
 declare class Meaning_operatorCall {
-    readonly operator: WithLocalization<types.Operator>;
+    readonly operator: types.Operator;
     readonly kind = "operator-call";
-    constructor(operator: WithLocalization<types.Operator>);
+    constructor(operator: types.Operator);
 }
 declare class Meaning_objectFunctionCall {
     readonly type: types.FunctionType;
@@ -41,9 +39,10 @@ declare class Meaning_constructorCall {
      * с ним совместим.
      */
     readonly type: types.Type;
-    readonly candidates: readonly FoundAnonymousDeclaration<types.Constructor>[];
-    readonly suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[];
+    readonly candidates: readonly types.Constructor[];
+    readonly suitableConstructors: readonly types.Constructor[];
     readonly kind = "constructor-call";
+    get singleSuitableConstructor(): types.Constructor | undefined;
     constructor(
     /**
      * Тип объекта, получаемого в результате вызова конструктора.
@@ -52,7 +51,7 @@ declare class Meaning_constructorCall {
      * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
      * с ним совместим.
      */
-    type: types.Type, candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
+    type: types.Type, candidates: readonly types.Constructor[], suitableConstructors: readonly types.Constructor[]);
 }
 declare class Meaning_unresolved {
     readonly diagnostics: readonly Diagnostic[];

package/build/types/analysis/ConstructorOverloadResolver.d.ts

@@ -2,8 +2,6 @@ import { Name } from '../common/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
-import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
-import { LocalizedName } from './Localization.js';
 export declare class Resolver<TCandidate extends ICandidate<TValueParameter>, TValueParameter extends IValueParameter> {
     private readonly _analyzer;
     constructor(_analyzer: Analyzer);
@@ -17,16 +15,15 @@ export interface IValueParameter {
     getType(): types.Type;
     isOptional(): boolean;
 }
-export declare class FoundTypeMemberCandidate implements ICandidate<FoundTypeMemberCandidateValueParameter> {
-    readonly value: FoundAnonymousDeclaration<types.Constructor>;
+export declare class TypeMemberCandidate implements ICandidate<FoundTypeMemberCandidateValueParameter> {
+    readonly value: types.Constructor;
     private readonly _valueParameters;
-    constructor(value: FoundAnonymousDeclaration<types.Constructor>);
+    constructor(value: types.Constructor);
     getValueParameters(): readonly FoundTypeMemberCandidateValueParameter[];
 }
 declare class FoundTypeMemberCandidateValueParameter implements IValueParameter {
     readonly value: types.ValueParameter;
-    readonly localizedName: LocalizedName;
-    constructor(value: types.ValueParameter, localizedName: LocalizedName);
+    constructor(value: types.ValueParameter);
     getName(): Name;
     getType(): types.Type;
     isOptional(): boolean;

package/build/types/analysis/DeclarationsUsageCounter.d.ts

@@ -1,8 +1,7 @@
 import { CancellationToken } from '../common/index.js';
-import { Entity } from '../entities/index.js';
+import { Entity, NamedEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import { Analyzer } from './Analyzer.js';
-import { NamedEntity } from './LocalizationContext.js';
 export declare class DeclarationsUsageCounter {
     private readonly _analyzer;
     private readonly _sourceFile;

package/build/types/analysis/DereferenceExpressionMeaning.d.ts

@@ -2,7 +2,6 @@ import { AccessKind } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { DereferenceExpression } from '../tree/index.js';
 import * as types from '../types/index.js';
-import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
 import { Analyzer } from './index.js';
 export declare class Resolver {
     private readonly _analyzer;
@@ -15,10 +14,10 @@ export declare class Resolver {
 }
 export type Meaning = Meaning_resolved | Meaning_unresolved;
 declare class Meaning_resolved {
-    readonly operator: FoundAnonymousDeclaration<types.DereferenceOperator>;
+    readonly operator: types.DereferenceOperator;
     readonly accessKind: AccessKind;
     readonly kind = "resolved";
-    constructor(operator: FoundAnonymousDeclaration<types.DereferenceOperator>, accessKind: AccessKind);
+    constructor(operator: types.DereferenceOperator, accessKind: AccessKind);
 }
 declare class Meaning_unresolved {
     readonly diagnostic: Diagnostic | undefined;

package/build/types/analysis/DiagnosticArgumentFactory.d.ts

@@ -0,0 +1,18 @@
+import { PackageDialect, PackageLocale } from '../common/index.js';
+import { Entity } from '../entities/index.js';
+import * as types from '../types/index.js';
+import { AccessedFunction } from './AccessedFunction.js';
+import { Analyzer } from './Analyzer.js';
+import { DisplayableAccessedFunction, DisplayableEntity, DisplayablePackageNameTreeNode, DisplayableType, DisplayableTypeMember } from './DisplayableEntity.js';
+import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
+export declare class DiagnosticArgumentFactory {
+    readonly locale: PackageLocale;
+    readonly dialect: PackageDialect;
+    private readonly _analyzer;
+    constructor(analyzer: Analyzer, locale: PackageLocale, dialect: PackageDialect);
+    createDisplayableEntity(entity: Entity): DisplayableEntity;
+    createDisplayableAccessedFunction(accessedFunction: AccessedFunction): DisplayableAccessedFunction;
+    createDisplayableTypeMember(member: types.TypeMember): DisplayableTypeMember;
+    createDisplayablePackageNameTreeNode(node: PackageNameTreeNode): DisplayablePackageNameTreeNode;
+    createDisplayableType(type: types.Type): DisplayableType;
+}

package/build/types/analysis/DiagnosticCollector.d.ts

@@ -7,7 +7,7 @@ export declare class DiagnosticCollector {
     private readonly _analyzer;
     private readonly _sourceFile;
     private readonly _cancellationToken;
-    private readonly _displayService;
+    private readonly _diagnosticArgumentFactory;
     private readonly _translationPackage;
     private readonly _diagnostics;
     private readonly _diagnosticAcceptor;
@@ -28,6 +28,7 @@ export declare class DiagnosticCollector {
     private collectNotTranslatedPackageMembers;
     private addNotTranslatedTypeMembersDiagnostics;
     private collectNotTranslatedTypeMembers;
+    private isNotTranslatedEntity;
     private createNotTranslatedEntitiesDiagnostic;
     private checkAllDefaultConstructorArgumentsAreNamed;
     private checkPackageFunctionDeclaration;
@@ -85,6 +86,5 @@ export declare class DiagnosticCollector {
     private attachNodeLocationAndAddDiagnostics;
     private addDiagnostic;
     private addDiagnostics;
-    private addMaybeLazyDiagnostic;
-    private addMaybeLazyDiagnostics;
+    private addDiagnosticsLocatedInAnalyzedFile;
 }

package/build/types/analysis/DisplayableEntity.d.ts

@@ -0,0 +1,46 @@
+import { Displayable, PackageDialect, PackageLocale } from '../common/index.js';
+import { Entity } from '../entities/index.js';
+import { AccessedFunction } from './AccessedFunction.js';
+import { Analyzer } from './Analyzer.js';
+import * as types from '../types/index.js';
+import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
+export declare class DisplayableEntity implements Displayable {
+    private readonly _analyzer;
+    private readonly _entity;
+    private readonly _locale;
+    private readonly _dialect;
+    constructor(_analyzer: Analyzer, _entity: Entity, _locale: PackageLocale, _dialect: PackageDialect | undefined);
+    getDisplayText(): string;
+}
+export declare class DisplayableAccessedFunction implements Displayable {
+    private readonly _analyzer;
+    private readonly _accessedFunction;
+    private readonly _locale;
+    private readonly _dialect;
+    constructor(_analyzer: Analyzer, _accessedFunction: AccessedFunction, _locale: PackageLocale, _dialect: PackageDialect | undefined);
+    getDisplayText(): string;
+}
+export declare class DisplayableTypeMember implements Displayable {
+    private readonly _analyzer;
+    private readonly _member;
+    private readonly _locale;
+    private readonly _dialect;
+    constructor(_analyzer: Analyzer, _member: types.TypeMember, _locale: PackageLocale, _dialect: PackageDialect | undefined);
+    getDisplayText(): string;
+}
+export declare class DisplayablePackageNameTreeNode implements Displayable {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _locale;
+    private readonly _dialect;
+    constructor(_analyzer: Analyzer, _node: PackageNameTreeNode, _locale: PackageLocale, _dialect: PackageDialect | undefined);
+    getDisplayText(): string;
+}
+export declare class DisplayableType implements Displayable {
+    private readonly _analyzer;
+    private readonly _type;
+    private readonly _locale;
+    private readonly _dialect;
+    constructor(_analyzer: Analyzer, _type: types.Type, _locale: PackageLocale, _dialect: PackageDialect | undefined);
+    getDisplayText(): string;
+}

package/build/types/analysis/IdentifierExpressionMeaning.d.ts

@@ -1,10 +1,9 @@
-import { AccessKind, MaybeLazy, Name } from '../common/index.js';
+import { AccessKind, Name } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { NamedTypeEntity, PackageAliasEntity, VariableEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { AccessedFunction } from './AccessedFunction.js';
-import { FoundAnonymousDeclaration, FoundNamedDeclaration } from './FoundDeclaration.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
 import { Analyzer, TargetTypeHint } from './index.js';
 import { NamedDeclaration } from './semantic-context/index.js';
@@ -23,12 +22,12 @@ export declare class Resolver {
 }
 export declare class ResolutionResult {
     readonly meaning: Meaning;
-    readonly diagnostic?: MaybeLazy<Diagnostic> | undefined;
+    readonly diagnostic?: Diagnostic | undefined;
     /**
      * Может ли измениться результат, если посчитать его с другим целевым типом?
      */
     readonly dependsOnTargetType: boolean;
-    constructor(meaning: Meaning, diagnostic?: MaybeLazy<Diagnostic> | undefined, 
+    constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined, 
     /**
      * Может ли измениться результат, если посчитать его с другим целевым типом?
      */
@@ -36,24 +35,24 @@ export declare class ResolutionResult {
 }
 export type Meaning = Meaning_variableAccess | Meaning_functionAccess | Meaning_operatorAccess | Meaning_packageNameSegmentAccess | Meaning_packageAliasAccess | Meaning_typeAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
 declare class Meaning_variableAccess {
-    readonly variable: FoundNamedDeclaration<AccessedVariable>;
+    readonly variable: AccessedVariable;
     readonly accessKind: AccessKind;
     readonly kind = "variable-access";
-    constructor(variable: FoundNamedDeclaration<AccessedVariable>, accessKind: AccessKind);
+    constructor(variable: AccessedVariable, accessKind: AccessKind);
 }
 declare class Meaning_functionAccess {
-    readonly candidates: readonly FoundNamedDeclaration<AccessedFunction>[];
-    readonly suitableFunctions: readonly FoundNamedDeclaration<AccessedFunction>[];
+    readonly candidates: readonly AccessedFunction[];
+    readonly suitableFunctions: readonly AccessedFunction[];
     readonly kind = "function-access";
-    get singleSuitableFunction(): FoundNamedDeclaration<AccessedFunction> | undefined;
-    constructor(candidates: readonly FoundNamedDeclaration<AccessedFunction>[], suitableFunctions: readonly FoundNamedDeclaration<AccessedFunction>[]);
+    get singleSuitableFunction(): AccessedFunction | undefined;
+    constructor(candidates: readonly AccessedFunction[], suitableFunctions: readonly AccessedFunction[]);
 }
 declare class Meaning_operatorAccess {
-    readonly candidates: readonly FoundAnonymousDeclaration<types.Operator>[];
-    readonly suitableOperators: readonly FoundAnonymousDeclaration<types.Operator>[];
+    readonly candidates: readonly types.Operator[];
+    readonly suitableOperators: readonly types.Operator[];
     readonly kind = "operator-access";
-    get singleSuitableOperator(): FoundAnonymousDeclaration<types.Operator> | undefined;
-    constructor(candidates: readonly FoundAnonymousDeclaration<types.Operator>[], suitableOperators: readonly FoundAnonymousDeclaration<types.Operator>[]);
+    get singleSuitableOperator(): types.Operator | undefined;
+    constructor(candidates: readonly types.Operator[], suitableOperators: readonly types.Operator[]);
 }
 declare class Meaning_packageAliasAccess {
     readonly packageAlias: PackageAliasEntity;
@@ -66,16 +65,16 @@ declare class Meaning_packageNameSegmentAccess {
     constructor(packageTreeNode: PackageNameTreeNode);
 }
 declare class Meaning_typeAccess {
-    readonly candidates: readonly FoundNamedDeclaration<NamedTypeEntity>[];
-    readonly suitableTypes: readonly FoundNamedDeclaration<types.Type>[];
+    readonly candidates: readonly NamedTypeEntity[];
+    readonly suitableTypes: readonly types.Type[];
     readonly kind = "type-access";
-    get singleSuitableType(): FoundNamedDeclaration<types.Type> | undefined;
-    constructor(candidates: readonly FoundNamedDeclaration<NamedTypeEntity>[], suitableTypes: readonly FoundNamedDeclaration<types.Type>[]);
+    get singleSuitableType(): types.Type | undefined;
+    constructor(candidates: readonly NamedTypeEntity[], suitableTypes: readonly types.Type[]);
 }
 declare class Meaning_mixedAmbiguousAccess {
-    readonly declarations: readonly FoundNamedDeclaration<NamedDeclaration>[];
+    readonly declarations: readonly NamedDeclaration[];
     readonly kind = "mixed-ambiguous-access";
-    constructor(declarations: readonly FoundNamedDeclaration<NamedDeclaration>[]);
+    constructor(declarations: readonly NamedDeclaration[]);
 }
 declare class Meaning_unresolved {
     readonly kind = "unresolved";

package/build/types/analysis/ImportedPackageNameTree.d.ts

@@ -1,6 +1,5 @@
 import { Name } from '../common/index.js';
 import { PackageEntity } from '../entities/PackageEntity.js';
-import { AnalyzedTranslationPackage } from './AnalyzedTranslationPackage.js';
 import { PackageImportInfo } from './Analyzer.js';
 export declare class ImportedPackageNameTree {
     private readonly _rootNodes;
@@ -10,14 +9,9 @@ export declare class ImportedPackageNameTree {
 }
 export interface PackageNameTreeNode {
     readonly name: Name;
-    readonly package: ImportedPackage | undefined;
+    readonly package: PackageEntity | undefined;
     readonly parent: PackageNameTreeNode | undefined;
     getChild(name: Name): PackageNameTreeNode | undefined;
     hasChild(name: Name): boolean;
     getChildren(): Iterable<PackageNameTreeNode>;
 }
-export declare class ImportedPackage {
-    readonly value: PackageEntity;
-    readonly translationPackage: AnalyzedTranslationPackage | undefined;
-    constructor(value: PackageEntity, translationPackage: AnalyzedTranslationPackage | undefined);
-}

package/build/types/analysis/IndexedAccessExpressionMeaning.d.ts

@@ -1,8 +1,7 @@
-import { AccessKind, MaybeLazy } from '../common/index.js';
+import { AccessKind } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { IndexedAccessExpression } from '../tree/index.js';
 import * as types from '../types/index.js';
-import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
 import { Analyzer } from './index.js';
 export declare class Resolver {
     private readonly _analyzer;
@@ -16,17 +15,17 @@ export declare class Resolver {
 }
 export declare class ResolutionResult {
     readonly meaning: Meaning;
-    readonly diagnostic?: MaybeLazy<Diagnostic> | undefined;
-    constructor(meaning: Meaning, diagnostic?: MaybeLazy<Diagnostic> | undefined);
+    readonly diagnostic?: Diagnostic | undefined;
+    constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined);
 }
 export type Meaning = Meaning_resolved | Meaning_unresolved;
 declare class Meaning_resolved {
-    readonly candidates: readonly FoundAnonymousDeclaration<types.Indexer>[];
-    readonly suitableIndexers: readonly FoundAnonymousDeclaration<types.Indexer>[];
+    readonly candidates: readonly types.Indexer[];
+    readonly suitableIndexers: readonly types.Indexer[];
     readonly accessKind: AccessKind;
     readonly kind = "resolved";
-    get singleSuitableIndexer(): FoundAnonymousDeclaration<types.Indexer> | undefined;
-    constructor(candidates: readonly FoundAnonymousDeclaration<types.Indexer>[], suitableIndexers: readonly FoundAnonymousDeclaration<types.Indexer>[], accessKind: AccessKind);
+    get singleSuitableIndexer(): types.Indexer | undefined;
+    constructor(candidates: readonly types.Indexer[], suitableIndexers: readonly types.Indexer[], accessKind: AccessKind);
 }
 declare class Meaning_unresolved {
     readonly kind = "unresolved";

package/build/types/analysis/InstanceFieldsInitializationValidator.d.ts

@@ -0,0 +1,18 @@
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
+import { Analyzer } from './Analyzer.js';
+import { DeclarationsUsageCountResult } from './DeclarationsUsageCounter.js';
+import { TypeWithMembersDeclaration } from './NodeTypeUtils.js';
+export declare class InstanceFieldsInitializationValidator {
+    private readonly _analyzer;
+    private readonly _typeDeclaration;
+    private readonly _declarationsUsageCountResult;
+    private readonly _diagnostics;
+    private readonly _semanticContext;
+    private get semanticContext();
+    constructor(_analyzer: Analyzer, _typeDeclaration: TypeWithMembersDeclaration, _declarationsUsageCountResult: DeclarationsUsageCountResult, _diagnostics: DiagnosticAcceptor);
+    validate(): void;
+    private getFieldsThatNeedToBeInitializedInConstructor;
+    private checkDefaultConstructorInitializesAllFields;
+    private checkConstructorInitializesAllFields;
+    private getFieldDiagnosticLocationWithFallback;
+}

package/build/types/analysis/Localization.d.ts

@@ -1,5 +1,7 @@
-import { PackageLocale, Name } from '../common/index.js';
+import { PackageLocale } from '../common/index.js';
 import { Entity } from '../entities/index.js';
+import { TranslationPackage } from '../project/index.js';
+import * as tree from '../tree/index.js';
 import { AnalyzedTranslationPackage } from './AnalyzedTranslationPackage.js';
 export type Localization = Localization.Original | Localization.Translated;
 export declare namespace Localization {
@@ -23,32 +25,24 @@ export declare namespace Localization {
     }
     export {};
 }
-export interface WithLocalization<T> {
-    readonly value: T;
-    readonly localization: Localization;
-}
 export declare class Translation {
     readonly translationPackage: AnalyzedTranslationPackage;
-    constructor(translationPackage: AnalyzedTranslationPackage);
+    readonly definition: TranslationDefinition;
+    constructor(translationPackage: AnalyzedTranslationPackage, definition: TranslationDefinition);
     equals(other: Translation): boolean;
 }
-export type LocalizedName = LocalizedName.Original | LocalizedName.Translated;
-export declare namespace LocalizedName {
-    export class Original implements ILocalizedName {
-        readonly value: Name;
-        readonly localization: Localization.Original;
-        readonly kind = "original";
-        constructor(value: Name, localization: Localization.Original);
-    }
-    export class Translated implements ILocalizedName {
-        readonly value: Name;
-        readonly localization: Localization.Translated;
-        readonly kind = "translated";
-        constructor(value: Name, localization: Localization.Translated);
-    }
-    interface ILocalizedName {
-        readonly value: Name;
-        readonly localization: Localization;
-    }
-    export {};
+export type TranslationDefinition = SourceTranslationDefinition | IntrinsicTranslationDefinition;
+export declare class SourceTranslationDefinition {
+    readonly nodeOrPackage: TranslationPackage | SourceTranslationDefinitionNode;
+    readonly translatedNameIdentifier: tree.Identifier | undefined;
+    readonly kind = "source";
+    constructor(nodeOrPackage: TranslationPackage | SourceTranslationDefinitionNode, translatedNameIdentifier: tree.Identifier | undefined);
+    equals(other: TranslationDefinition): boolean;
+}
+export type SourceTranslationDefinitionNode = tree.TopLevelTranslation | tree.TypeMemberTranslation;
+export declare class IntrinsicTranslationDefinition {
+    readonly isMissingTranslationReplacement: boolean;
+    readonly kind = "intrinsic";
+    constructor(isMissingTranslationReplacement?: boolean);
+    equals(other: TranslationDefinition): boolean;
 }