@artel/artc 0.6.25244 → 0.6.25245

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,8 +39,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(
     /**
@@ -52,7 +50,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/DiagnosticCollector.d.ts

@@ -28,6 +28,7 @@ export declare class DiagnosticCollector {
     private collectNotTranslatedPackageMembers;
     private addNotTranslatedTypeMembersDiagnostics;
     private collectNotTranslatedTypeMembers;
+    private isNotTranslatedEntity;
     private createNotTranslatedEntitiesDiagnostic;
     private checkAllDefaultConstructorArgumentsAreNamed;
     private checkPackageFunctionDeclaration;

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

@@ -4,7 +4,6 @@ import { NamedTypeEntity, PackageAliasEntity, VariableEntity } from '../entities
 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';
@@ -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

@@ -2,7 +2,6 @@ import { AccessKind, MaybeLazy } 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;
@@ -21,12 +20,12 @@ export declare class ResolutionResult {
 }
 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/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;
 }

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

@@ -4,16 +4,14 @@ import { Entity, PackageTypeEntity, PackageVariableEntity } from '../entities/in
 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 { WithLocalization } from './Localization.js';
 export declare class Resolver {
     private readonly _semanticContext;
     private readonly _analyzer;
     private readonly _node;
     private readonly _targetTypeHint;
-    private get memberSearchName();
+    private get memberName();
     private get semanticContext();
     private get receiver();
     constructor(analyzer: Analyzer, node: tree.MemberAccessExpression, targetTypeHint: TargetTypeHint | undefined);
@@ -44,24 +42,24 @@ export declare class ResolutionResult {
 }
 export type Meaning = Meaning_packageVariableAccess | Meaning_packageFunctionAccess | Meaning_packageTypeAccess | Meaning_packageNameSegmentAccess | Meaning_staticFieldAccess | Meaning_staticMethodAccess | Meaning_instanceFieldAccess | Meaning_instanceMethodAccess | Meaning_operatorAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
 declare class Meaning_packageVariableAccess {
-    readonly variable: FoundNamedDeclaration<PackageVariableEntity>;
+    readonly variable: PackageVariableEntity;
     readonly accessKind: AccessKind;
     readonly kind = "package-variable-access";
-    constructor(variable: FoundNamedDeclaration<PackageVariableEntity>, accessKind: AccessKind);
+    constructor(variable: PackageVariableEntity, accessKind: AccessKind);
 }
 declare class Meaning_packageFunctionAccess {
-    readonly candidates: readonly FoundNamedDeclaration<AccessedFunction>[];
-    readonly suitableFunctions: readonly FoundNamedDeclaration<AccessedFunction>[];
+    readonly candidates: readonly AccessedFunction[];
+    readonly suitableFunctions: readonly AccessedFunction[];
     readonly kind = "package-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_packageTypeAccess {
-    readonly candidates: readonly FoundNamedDeclaration<PackageTypeEntity>[];
-    readonly suitableTypes: readonly FoundNamedDeclaration<types.Type>[];
+    readonly candidates: readonly PackageTypeEntity[];
+    readonly suitableTypes: readonly types.Type[];
     readonly kind = "package-type-access";
-    get singleSuitableType(): FoundNamedDeclaration<types.Type> | undefined;
-    constructor(candidates: readonly FoundNamedDeclaration<PackageTypeEntity>[], suitableTypes: readonly FoundNamedDeclaration<types.Type>[]);
+    get singleSuitableType(): types.Type | undefined;
+    constructor(candidates: readonly PackageTypeEntity[], suitableTypes: readonly types.Type[]);
 }
 declare class Meaning_packageNameSegmentAccess {
     readonly packageTreeNode: PackageNameTreeNode;
@@ -70,43 +68,43 @@ declare class Meaning_packageNameSegmentAccess {
 }
 declare class Meaning_staticFieldAccess {
     readonly type: types.Type;
-    readonly field: FoundNamedDeclaration<types.Field>;
+    readonly field: types.Field;
     readonly accessKind: AccessKind;
     readonly kind = "static-field-access";
-    constructor(type: types.Type, field: FoundNamedDeclaration<types.Field>, accessKind: AccessKind);
+    constructor(type: types.Type, field: types.Field, accessKind: AccessKind);
 }
 declare class Meaning_staticMethodAccess {
     readonly type: types.Type;
-    readonly candidates: readonly FoundNamedDeclaration<AccessedFunction>[];
-    readonly suitableFunctions: readonly FoundNamedDeclaration<AccessedFunction>[];
+    readonly candidates: readonly AccessedFunction[];
+    readonly suitableFunctions: readonly AccessedFunction[];
     readonly kind = "static-method-access";
-    get singleSuitableFunction(): FoundNamedDeclaration<AccessedFunction> | undefined;
-    constructor(type: types.Type, candidates: readonly FoundNamedDeclaration<AccessedFunction>[], suitableFunctions: readonly FoundNamedDeclaration<AccessedFunction>[]);
+    get singleSuitableFunction(): AccessedFunction | undefined;
+    constructor(type: types.Type, candidates: readonly AccessedFunction[], suitableFunctions: readonly AccessedFunction[]);
 }
 declare class Meaning_instanceFieldAccess {
-    readonly field: FoundNamedDeclaration<types.Field>;
+    readonly field: types.Field;
     readonly accessKind: AccessKind;
     readonly kind = "instance-field-access";
-    constructor(field: FoundNamedDeclaration<types.Field>, accessKind: AccessKind);
+    constructor(field: types.Field, accessKind: AccessKind);
 }
 declare class Meaning_instanceMethodAccess {
-    readonly candidates: readonly FoundNamedDeclaration<AccessedFunction>[];
-    readonly suitableFunctions: readonly FoundNamedDeclaration<AccessedFunction>[];
+    readonly candidates: readonly AccessedFunction[];
+    readonly suitableFunctions: readonly AccessedFunction[];
     readonly kind = "instance-method-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_mixedAmbiguousAccess {
-    readonly entities: readonly WithLocalization<Entity>[];
+    readonly entities: readonly Entity[];
     readonly kind = "mixed-ambiguous-access";
-    constructor(entities: readonly WithLocalization<Entity>[]);
+    constructor(entities: readonly Entity[]);
 }
 declare class Meaning_unresolved {
     readonly kind = "unresolved";

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

@@ -3,9 +3,7 @@ import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { NamedTypeEntity, PackageAliasEntity } from '../entities/index.js';
 import { QualifiedName } from '../tree/index.js';
 import { Analyzer } from './Analyzer.js';
-import { FoundNamedDeclaration } from './FoundDeclaration.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
-import { WithLocalization } from './Localization.js';
 import { EntityOrPackageNameTreeNode } from './Utils.js';
 export declare class NamedTypeResolver {
     private readonly _analyzer;
@@ -22,11 +20,11 @@ export declare class NamedTypeResolver {
     private createAmbiguousAccessDiagnostic;
 }
 export declare class NamedTypeResolutionResult {
-    readonly types: readonly FoundNamedDeclaration<NamedTypeEntity>[];
+    readonly types: readonly NamedTypeEntity[];
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
     readonly diagnostics: readonly MaybeLazy<Diagnostic>[];
-    readonly ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined;
-    constructor(types: readonly FoundNamedDeclaration<NamedTypeEntity>[], resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly MaybeLazy<Diagnostic>[], ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined);
+    readonly ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined;
+    constructor(types: readonly NamedTypeEntity[], resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly MaybeLazy<Diagnostic>[], ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined);
 }
 export type ResolvedQualifier = ResolvedQualifier_packageNameSegment | ResolvedQualifier_packageAlias | ResolvedQualifier_type;
 export declare class ResolvedQualifier_packageNameSegment {
@@ -40,8 +38,8 @@ export declare class ResolvedQualifier_packageAlias {
     constructor(packageAlias: PackageAliasEntity);
 }
 export declare class ResolvedQualifier_type {
-    readonly candidates: readonly FoundNamedDeclaration<NamedTypeEntity>[];
-    readonly suitableTypes: readonly FoundNamedDeclaration<NamedTypeEntity>[];
+    readonly candidates: readonly NamedTypeEntity[];
+    readonly suitableTypes: readonly NamedTypeEntity[];
     readonly kind = "type";
-    constructor(candidates: readonly FoundNamedDeclaration<NamedTypeEntity>[], suitableTypes: readonly FoundNamedDeclaration<NamedTypeEntity>[]);
+    constructor(candidates: readonly NamedTypeEntity[], suitableTypes: readonly NamedTypeEntity[]);
 }

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

@@ -3,8 +3,6 @@ import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { NamedTypeSpecifier } from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
-import { FoundNamedDeclaration } from './FoundDeclaration.js';
-import { WithLocalization } from './Localization.js';
 import { ResolvedQualifier } from './NamedTypeResolver.js';
 import { EntityOrPackageNameTreeNode } from './Utils.js';
 export declare class NamedTypeSpecifierResolver {
@@ -15,9 +13,9 @@ export declare class NamedTypeSpecifierResolver {
     private resolveTypeOverload;
 }
 export declare class NamedTypeSpecifierResolutionResult {
-    readonly type: FoundNamedDeclaration<types.Type> | undefined;
+    readonly type: types.Type | undefined;
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
     readonly diagnostics: readonly MaybeLazy<Diagnostic>[];
-    readonly ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined;
-    constructor(type: FoundNamedDeclaration<types.Type> | undefined, resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly MaybeLazy<Diagnostic>[], ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined);
+    readonly ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined;
+    constructor(type: types.Type | undefined, resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly MaybeLazy<Diagnostic>[], ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined);
 }

package/build/types/analysis/ObjectExpressionMeaning.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. объект() - в конструкторе для вызова другого собственного конструктора.
@@ -28,8 +27,8 @@ declare class Meaning_ownConstructorAccess {
      * с ним совместим.
      */
     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 = "own-constructor-access";
     constructor(
     /**
@@ -39,7 +38,7 @@ declare class Meaning_ownConstructorAccess {
      * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
      * с ним совместим.
      */
-    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_objectAccess {
     readonly type: types.Type;

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

@@ -1,14 +1,9 @@
-import { SearchName } from '../common/index.js';
+import { Name } from '../common/index.js';
 import { IEntityHidingMatcher, NamedPackageMemberEntity, PackageEntity, TypeEntity, TypeExtensionEntity } from '../entities/index.js';
-import { FoundNamedDeclaration } from './FoundDeclaration.js';
-import { LocalizationContext } from './LocalizationContext.js';
 export declare class PackageMemberLookup {
     private readonly _package;
-    private readonly _localizationContext;
-    private readonly _translatedMembers;
-    private get translatedMembers();
-    constructor(_package: PackageEntity, _localizationContext: LocalizationContext | undefined);
-    getNamedMembers(hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedPackageMemberEntity>[];
-    getNamedMembersByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedPackageMemberEntity>[];
+    constructor(_package: PackageEntity);
+    getNamedMembers(hidingMatcher?: IEntityHidingMatcher): readonly NamedPackageMemberEntity[];
+    getNamedMembersByName(name: Name, hidingMatcher?: IEntityHidingMatcher): readonly NamedPackageMemberEntity[];
     getTypeExtensions(type: TypeEntity, hidingMatcher?: IEntityHidingMatcher): readonly TypeExtensionEntity[];
 }

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

@@ -1,12 +1,12 @@
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
-import { OriginalPackageMembers } from '../entities/PackageMembers.js';
+import { PackageEntityMembers } from '../entities/PackageMembers.js';
 import { ProgramPackage } from '../project/SourcePackage.js';
 import { Analyzer } from './Analyzer.js';
 export declare class PackageMemberNameConflictsValidator {
     private readonly _analyzer;
     private readonly _members;
     private readonly _diagnostics;
-    constructor(_analyzer: Analyzer, _members: OriginalPackageMembers);
+    constructor(_analyzer: Analyzer, _members: PackageEntityMembers);
     validate(): readonly Diagnostic[];
     private validateFunctionNameConflicts;
     private validateTypeNameConflicts;

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

@@ -1,4 +1,4 @@
-import { SearchName } from '../common/index.js';
+import { Name } from '../common/index.js';
 import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { PackageAliasEntity, PackageFunctionEntity, PackageTypeEntity, PackageVariableEntity, TypeExtensionEntity } from '../entities/index.js';
 import { Analyzer } from './Analyzer.js';
@@ -10,9 +10,9 @@ export declare class SourceFileMembers {
     get declarationsByName(): ReadonlyMap<string, readonly NamedSourceFileMemberEntity[]>;
     constructor(analyzer: Analyzer, namedMembers: readonly NamedSourceFileMemberEntity[], typeExtensions: readonly TypeExtensionEntity[]);
     getNamedDeclarations(): readonly NamedSourceFileMemberEntity[];
-    getNamedDeclarationsByName(name: SearchName): readonly NamedSourceFileMemberEntity[];
+    getNamedDeclarationsByName(name: Name): readonly NamedSourceFileMemberEntity[];
     getPackageAliases(): readonly PackageAliasEntity[];
-    getPackageAliasesByName(name: SearchName): readonly PackageAliasEntity[];
+    getPackageAliasesByName(name: Name): readonly PackageAliasEntity[];
     getTypeExtensions(): readonly TypeExtensionEntity[];
     validateNameConflicts(diagnostics: DiagnosticAcceptor): void;
     private getDiagnosticLocation;

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

@@ -4,10 +4,8 @@ import { FunctionEntity, NamedTypeEntity, PackageAliasEntity } from '../entities
 import { Tag } 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 } from './index.js';
-import { WithLocalization } from './Localization.js';
 import { EntityOrPackageNameTreeNode } from './Utils.js';
 export declare class Resolver {
     private readonly _analyzer;
@@ -28,24 +26,24 @@ export declare class ResolutionResult {
     readonly meaning: Meaning;
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
     readonly diagnostic?: MaybeLazy<Diagnostic> | undefined;
-    readonly ambiguousDeclarations?: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined;
-    constructor(meaning: Meaning, resolvedQualifiers: readonly ResolvedQualifier[], diagnostic?: MaybeLazy<Diagnostic> | undefined, ambiguousDeclarations?: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined);
+    readonly ambiguousDeclarations?: readonly EntityOrPackageNameTreeNode[] | undefined;
+    constructor(meaning: Meaning, resolvedQualifiers: readonly ResolvedQualifier[], diagnostic?: MaybeLazy<Diagnostic> | undefined, ambiguousDeclarations?: readonly EntityOrPackageNameTreeNode[] | undefined);
 }
 export type Meaning = Meaning_tagType | Meaning_tagFunction | Meaning_unresolved;
 declare class Meaning_tagType {
     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 = "tag-type";
-    get singleSuitableConstructor(): FoundAnonymousDeclaration<types.Constructor> | undefined;
-    constructor(type: types.Type, candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
+    get singleSuitableConstructor(): types.Constructor | undefined;
+    constructor(type: types.Type, candidates: readonly types.Constructor[], suitableConstructors: readonly types.Constructor[]);
 }
 declare class Meaning_tagFunction {
-    readonly candidates: readonly FoundNamedDeclaration<AccessedFunction>[];
-    readonly suitableFunctions: readonly FoundNamedDeclaration<AccessedFunction>[];
+    readonly candidates: readonly AccessedFunction[];
+    readonly suitableFunctions: readonly AccessedFunction[];
     readonly kind = "tag-function";
-    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_unresolved {
     readonly kind = "unresolved";
@@ -62,17 +60,17 @@ export declare class ResolvedQualifier_packageAlias {
     constructor(packageAlias: PackageAliasEntity);
 }
 export declare class ResolvedQualifier_type {
-    readonly candidates: readonly FoundNamedDeclaration<NamedTypeEntity>[];
-    readonly suitableTypes: readonly FoundNamedDeclaration<NamedTypeEntity>[];
+    readonly candidates: readonly NamedTypeEntity[];
+    readonly suitableTypes: readonly NamedTypeEntity[];
     readonly kind = "type";
-    get singleSuitableType(): FoundNamedDeclaration<NamedTypeEntity> | undefined;
-    constructor(candidates: readonly FoundNamedDeclaration<NamedTypeEntity>[], suitableTypes: readonly FoundNamedDeclaration<NamedTypeEntity>[]);
+    get singleSuitableType(): NamedTypeEntity | undefined;
+    constructor(candidates: readonly NamedTypeEntity[], suitableTypes: readonly NamedTypeEntity[]);
 }
 export declare class ResolvedQualifier_function {
-    readonly candidates: readonly FoundNamedDeclaration<FunctionEntity>[];
-    readonly suitableFunctions: readonly FoundNamedDeclaration<FunctionEntity>[];
+    readonly candidates: readonly FunctionEntity[];
+    readonly suitableFunctions: readonly FunctionEntity[];
     readonly kind = "function";
-    get singleSuitableFunction(): FoundNamedDeclaration<FunctionEntity> | undefined;
-    constructor(candidates: readonly FoundNamedDeclaration<FunctionEntity>[], suitableFunctions: readonly FoundNamedDeclaration<FunctionEntity>[]);
+    get singleSuitableFunction(): FunctionEntity | undefined;
+    constructor(candidates: readonly FunctionEntity[], suitableFunctions: readonly FunctionEntity[]);
 }
 export {};