@artel/artc 0.6.25191

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

@@ -0,0 +1,25 @@
+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;
+    readonly _node: AutotypeCallExpression;
+    readonly _targetTypeHint: TargetTypeHint | undefined;
+    constructor(_analyzer: Analyzer, _node: AutotypeCallExpression, _targetTypeHint: TargetTypeHint | undefined);
+    resolve(): Meaning;
+}
+export type Meaning = Meaning_constructorCall | Meaning_unresolved;
+declare class Meaning_constructorCall {
+    readonly candidates: readonly FoundAnonymousDeclaration<types.Constructor>[];
+    readonly suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[];
+    readonly kind = "constructor-call";
+    constructor(candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
+}
+declare class Meaning_unresolved {
+    readonly diagnostics: readonly Diagnostic[];
+    readonly kind = "unresolved";
+    constructor(diagnostics: readonly Diagnostic[]);
+}
+export {};

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

@@ -0,0 +1,47 @@
+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. основа() - в конструкторе для вызова базового конструктора или в методе для вызова заменённого метода.
+ * 2. основа.поле (основа.метод) - в любом выражении в контексте типа, имеющего базовый тип.
+ * 3. основа[] - аналогично п. 2.
+ */
+export declare class Resolver {
+    private readonly _analyzer;
+    private readonly _node;
+    constructor(analyzer: Analyzer, node: tree.BaseExpression);
+    resolve(): Meaning;
+    private resolveBaseConstructorOrMethodAccess;
+    private resolveBaseConstructorAccess;
+    private resolveBaseMethodAccess;
+    private resolveBaseObjectAccess;
+    private invalidContextMeaning;
+    private getBaseOrAliasedType;
+    private findContainingConstructorOrTypeMethod;
+}
+export type Meaning = Meaning_baseObjectAccess | Meaning_baseConstructorAccess | Meaning_overriddenMethodAccess | Meaning_unresolved;
+declare class Meaning_baseObjectAccess {
+    readonly type: types.Type;
+    readonly kind = "base-object-access";
+    constructor(type: types.Type);
+}
+declare class Meaning_baseConstructorAccess {
+    readonly candidates: readonly FoundAnonymousDeclaration<types.Constructor>[];
+    readonly suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[];
+    readonly kind = "base-constructor-access";
+    constructor(candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
+}
+declare class Meaning_overriddenMethodAccess {
+    readonly method: types.Method;
+    readonly kind = "overridden-method-access";
+    constructor(method: types.Method);
+}
+declare class Meaning_unresolved {
+    readonly diagnostic: Diagnostic;
+    readonly kind = "unresolved";
+    constructor(diagnostic: Diagnostic);
+}
+export {};

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

@@ -0,0 +1,14 @@
+import { BinaryOperatorEntity, TypeEntity, UnaryOperatorEntity } from '../entities/index.js';
+import { Analyzer } from './index.js';
+export declare class BuiltInOperators {
+    private readonly _analyzer;
+    private readonly _unaryOperators;
+    private readonly _binaryOperators;
+    private get unaryOperators();
+    private get binaryOperators();
+    constructor(_analyzer: Analyzer);
+    getUnaryOperators(entity: TypeEntity): readonly UnaryOperatorEntity[];
+    getBinaryOperators(entity: TypeEntity): readonly BinaryOperatorEntity[];
+    private createBuiltInUnaryOperators;
+    private createBuiltInBinaryOperators;
+}

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

@@ -0,0 +1,30 @@
+import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { VariableEntity } from '../entities/index.js';
+import { AutotypeCallExpression, CallArgument, CallExpression, Tag } from '../tree/index.js';
+import * as types from '../types/index.js';
+import { LocalizedName } from './Localization.js';
+import { Analyzer } from './index.js';
+export declare class CallArgumentToParameterMatchResult {
+    private readonly _analyzer;
+    private readonly _matchResults;
+    constructor(_analyzer: Analyzer);
+    ofCallExpression(node: CallExpression): MatchResult | undefined;
+    ofAutotypeCallExpression(node: AutotypeCallExpression): MatchResult | undefined;
+    ofTag(node: Tag): MatchResult | undefined;
+    private convertSignatureWithParametersMatchResult;
+    private convertParameter;
+    private convertConstructorSignatureMatchResult;
+    private convertConstructorParameter;
+}
+export declare class MatchResult {
+    readonly parameterByCallArgument: ReadonlyMap<CallArgument, MatchResultValueParameter>;
+    readonly unmatchedParameters: readonly MatchResultValueParameter[];
+    readonly diagnostics: readonly Diagnostic[];
+    constructor(parameterByCallArgument: ReadonlyMap<CallArgument, MatchResultValueParameter>, unmatchedParameters: readonly MatchResultValueParameter[], diagnostics: readonly Diagnostic[]);
+}
+export declare class MatchResultValueParameter {
+    readonly entity: VariableEntity;
+    readonly type: types.Type;
+    readonly name: LocalizedName;
+    constructor(entity: VariableEntity, type: types.Type, name: LocalizedName);
+}

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

@@ -0,0 +1,44 @@
+import { Name } from '../common/index.js';
+import { Diagnostic, DiagnosticLocation } from '../diagnostic/Diagnostic.js';
+import * as tree from '../tree/index.js';
+import * as types from '../types/index.js';
+import { Analyzer } from './index.js';
+export declare class CallArgumentToParameterMatcher<TSignature extends ISignature<TParameter>, TParameter extends ISignatureParameter, TCallArgument extends ICallArgument> {
+    private readonly _analyzer;
+    private readonly _signature;
+    private readonly _callArguments;
+    constructor(_analyzer: Analyzer, _signature: TSignature, _callArguments: readonly TCallArgument[]);
+    match(): MatchResult<TParameter, TCallArgument>;
+    private matchCallArgumentsToParameters;
+    private addCallArgumentDiagnostic;
+    private getCallArgumentType;
+}
+export declare class MatchResult<TParameter extends ISignatureParameter, TCallArgument extends ICallArgument> {
+    readonly mapping: ReadonlyMap<TCallArgument, TParameter>;
+    readonly unmatchedRequiredParameters: readonly TParameter[];
+    readonly argumentArrangementDiagnostics: readonly Diagnostic[];
+    readonly hasTypeAssignabilityErrors: boolean;
+    get isMatching(): boolean;
+    constructor(mapping: ReadonlyMap<TCallArgument, TParameter>, unmatchedRequiredParameters: readonly TParameter[], argumentArrangementDiagnostics: readonly Diagnostic[], hasTypeAssignabilityErrors: boolean);
+}
+export interface ISignature<TParameter extends ISignatureParameter> {
+    getParameters(): readonly TParameter[];
+}
+export interface ISignatureParameter {
+    getName(): Name | undefined;
+    getType(): types.Type;
+    isOptional(): boolean;
+}
+export interface ICallArgument {
+    getExpression(): tree.Expression;
+    getName(): Name | undefined;
+    getDiagnosticLocation(): DiagnosticLocation | undefined;
+}
+export declare class CallArgument implements ICallArgument {
+    private readonly _analyzer;
+    readonly node: tree.CallArgument;
+    constructor(_analyzer: Analyzer, node: tree.CallArgument);
+    getExpression(): tree.Expression;
+    getName(): Name | undefined;
+    getDiagnosticLocation(): DiagnosticLocation;
+}

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

@@ -0,0 +1,39 @@
+import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { CallExpression } from '../tree/index.js';
+import * as types from '../types/index.js';
+import { AccessedMethod } from './AccessedMethod.js';
+import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
+import { WithLocalization } from './Localization.js';
+import { Analyzer } from './index.js';
+export declare class Resolver {
+    private readonly _analyzer;
+    private readonly _node;
+    constructor(_analyzer: Analyzer, _node: CallExpression);
+    private get callee();
+    resolve(): Meaning;
+    private resolveConstructorCallExpressionMeaning;
+    private getNodeForDiagnostics;
+}
+export type Meaning = Meaning_methodCall | Meaning_objectMethodCall | Meaning_constructorCall | Meaning_unresolved;
+declare class Meaning_methodCall {
+    readonly method: WithLocalization<AccessedMethod>;
+    readonly kind = "method-call";
+    constructor(method: WithLocalization<AccessedMethod>);
+}
+declare class Meaning_objectMethodCall {
+    readonly type: types.MethodType;
+    readonly kind = "object-method-call";
+    constructor(type: types.MethodType);
+}
+declare class Meaning_constructorCall {
+    readonly candidates: readonly FoundAnonymousDeclaration<types.Constructor>[];
+    readonly suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[];
+    readonly kind = "constructor-call";
+    constructor(candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
+}
+declare class Meaning_unresolved {
+    readonly diagnostics: readonly Diagnostic[];
+    readonly kind = "unresolved";
+    constructor(diagnostics: readonly Diagnostic[]);
+}
+export {};

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

@@ -0,0 +1,34 @@
+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);
+    resolve(candidates: Iterable<TCandidate>, callArguments: Iterable<tree.CallArgument>): Iterable<TCandidate>;
+}
+export interface ICandidate<TValueParameter extends IValueParameter> {
+    getValueParameters(): readonly TValueParameter[];
+}
+export interface IValueParameter {
+    getName(): Name;
+    getType(): types.Type;
+    isOptional(): boolean;
+}
+export declare class FoundTypeMemberCandidate implements ICandidate<FoundTypeMemberCandidateValueParameter> {
+    readonly value: FoundAnonymousDeclaration<types.Constructor>;
+    private readonly _valueParameters;
+    constructor(value: FoundAnonymousDeclaration<types.Constructor>);
+    getValueParameters(): readonly FoundTypeMemberCandidateValueParameter[];
+}
+declare class FoundTypeMemberCandidateValueParameter implements IValueParameter {
+    readonly value: types.ValueParameter;
+    readonly localizedName: LocalizedName;
+    constructor(value: types.ValueParameter, localizedName: LocalizedName);
+    getName(): Name;
+    getType(): types.Type;
+    isOptional(): boolean;
+}
+export {};

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

@@ -0,0 +1,18 @@
+import { CancellationToken } from '../common/index.js';
+import { Entity } 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;
+    private readonly _cancellationToken;
+    private readonly _usageCountByEntity;
+    constructor(analyzer: Analyzer, sourceFile: tree.SourceFile, cancellationToken: CancellationToken | undefined);
+    count(): Promise<DeclarationsUsageCountResult>;
+}
+export declare class DeclarationsUsageCountResult {
+    private readonly _usageCountByEntity;
+    constructor(_usageCountByEntity: ReadonlyMap<Entity, number>);
+    getUsageCount(entity: NamedEntity): number;
+}

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

@@ -0,0 +1,23 @@
+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;
+    private readonly _node;
+    constructor(_analyzer: Analyzer, _node: DereferenceExpression);
+    resolve(): Meaning;
+}
+export type Meaning = Meaning_resolved | Meaning_unresolved;
+declare class Meaning_resolved {
+    readonly operator: FoundAnonymousDeclaration<types.DereferenceOperator>;
+    readonly kind = "resolved";
+    constructor(operator: FoundAnonymousDeclaration<types.DereferenceOperator>);
+}
+declare class Meaning_unresolved {
+    readonly diagnostic: Diagnostic | undefined;
+    readonly kind = "unresolved";
+    constructor(diagnostic: Diagnostic | undefined);
+}
+export {};

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

@@ -0,0 +1,68 @@
+import { CancellationToken } from '../common/index.js';
+import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import * as project from '../project/index.js';
+import { Analyzer } from './index.js';
+export declare class DiagnosticCollector {
+    static readonly CancellationTokenThrottleTime = 50;
+    private readonly _analyzer;
+    private readonly _sourceFile;
+    private readonly _cancellationToken;
+    private readonly _displayService;
+    private readonly _translationPackage;
+    private readonly _diagnostics;
+    private readonly _diagnosticAcceptor;
+    private _namedDeclarationsCountResult;
+    private get node();
+    private get translationPackage();
+    private get isInterfacePackageFile();
+    constructor(analyzer: Analyzer, sourceFile: project.SourceFile, cancellationToken: CancellationToken | undefined);
+    collect(): Promise<Diagnostic[]>;
+    private collectNodeDiagnostics;
+    private addNotTranslatedPackageMembersDiagnostics;
+    private collectNotTranslatedPackageMembers;
+    private addNotTranslatedTypeMembersDiagnostics;
+    private collectNotTranslatedTypeMembers;
+    private createNotTranslatedEntitiesDiagnostic;
+    private checkAllDefaultConstructorArgumentsAreNamed;
+    private checkPackageMethodDeclaration;
+    private checkPackageVariableGetterDeclaration;
+    private checkPackageVariableSetterDeclaration;
+    private checkTypeMethodDeclaration;
+    private checkTypeVariableGetterDeclaration;
+    private checkTypeVariableSetterDeclaration;
+    private checkTypeIndexedGetterDeclaration;
+    private checkTypeIndexedSetterDeclaration;
+    private checkNestedMethodDeclaration;
+    private checkPossibleGeneratorMethodReturnType;
+    private checkReturnStatement;
+    private checkYieldStatement;
+    private checkTypeMemberBodyPresence;
+    private isAspectTypeMemberDeclaration;
+    private collectIdentifierExpressionDiagnostics;
+    private collectPropertyAccessExpressionDiagnostics;
+    private addDiagnosticsFromMatchResult;
+    private checkStatementForVariablesUsedBeforeBeingAssigned;
+    private checkExpressionTypeAssignableToTargetType;
+    private addTypeAssignabilityDiagnosticIfBothTypesResolved;
+    private checkAssignmentIsValid;
+    private checkAssignmentToIdentifierExpression;
+    private checkAssignmentToPropertyAccessExpression;
+    private checkAssignmentToVariable;
+    private checkAssignmentToPackageVariable;
+    private checkAssignmentToTypeVariable;
+    private checkAssignmentToObjectExpression;
+    private checkAssignmentToDereferenceExpression;
+    private checkAssignmentToIndexedAccessExpression;
+    private checkGenericSpecializationExpression;
+    private checkMethodSpecialization;
+    private checkTypeSpecialization;
+    private checkSpecializationOfDeclarationWithParameters;
+    /**
+     * @returns `true` если была ошибка, иначе `false`.
+     */
+    private checkTypeArgumentCount;
+    private checkParameterDeclaration;
+    private checkIfVariableIsUnused;
+    private addDiagnostic;
+    private addDiagnostics;
+}

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

@@ -0,0 +1,15 @@
+import { LocalizedSubprogramSignature, LocalizedTypeHeader, TypeEntityWithHeaderLocalization } from '../analysis/AnalyzedTranslationPackage.js';
+import { Analyzer } from '../analysis/index.js';
+import { Localization } from '../analysis/Localization.js';
+import { ConstructorEntity, DestructorEntity, IndexerEntity, MethodEntity, MethodTypeEntity } from '../entities/index.js';
+import * as types from '../types/index.js';
+export declare class EntityLocalizationHelper {
+    static getLocalizedMethodSignature(method: MethodEntity, localization: Localization): LocalizedSubprogramSignature;
+    static getLocalizedMethodTypeSignature(methodType: MethodTypeEntity, localization: Localization): LocalizedSubprogramSignature;
+    static getLocalizedConstructorSignature(constructor: ConstructorEntity, localization: Localization): LocalizedSubprogramSignature;
+    static getLocalizedDestructorSignature(destructor: DestructorEntity, localization: Localization): LocalizedSubprogramSignature;
+    static getLocalizedIndexerSignature(indexer: IndexerEntity, localization: Localization): LocalizedSubprogramSignature;
+    static getLocalizedTypeHeader(type: TypeEntityWithHeaderLocalization, localization: Localization): LocalizedTypeHeader;
+    static getLocalizedSignatureTypeOfMethod(analyzer: Analyzer, method: MethodEntity, signatureType: types.MethodType, localization: Localization): types.MethodType;
+    static localizeMethodType(analyzer: Analyzer, type: types.MethodType, localizedSignature: LocalizedSubprogramSignature): types.MethodType;
+}

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

@@ -0,0 +1,4 @@
+import * as tree from '../tree/index.js';
+type NodeWithModifiers = tree.PackageMemberDeclaration | tree.TypeMemberDeclaration;
+export declare function findModifier(node: NodeWithModifiers, modifierKeywordKind: tree.ModifierKeywordKind): tree.Modifier | undefined;
+export {};

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

@@ -0,0 +1,19 @@
+import { PackageLocale, Name } from '../common/index.js';
+import { Localization, LocalizedName, Translation, WithLocalization } from './Localization.js';
+export declare class FoundNamedDeclaration<T> implements WithLocalization<T> {
+    readonly value: T;
+    readonly name: LocalizedName;
+    readonly requiresExplicitOriginalName: boolean;
+    get localization(): Localization;
+    constructor(value: T, name: LocalizedName, requiresExplicitOriginalName: boolean);
+    static original<T>(value: T, name: Name, locale: PackageLocale, requiresExplicitOriginalName: boolean): FoundNamedDeclaration<T>;
+    static translated<T>(value: T, localizedName: LocalizedName.Translated): FoundNamedDeclaration<T>;
+    withValue<T>(value: T): FoundNamedDeclaration<T>;
+}
+export declare class FoundAnonymousDeclaration<T> implements WithLocalization<T> {
+    readonly value: T;
+    readonly localization: Localization;
+    constructor(value: T, localization: Localization);
+    static original<T>(value: T, locale: PackageLocale): FoundAnonymousDeclaration<T>;
+    static translated<T>(value: T, translation: Translation): FoundAnonymousDeclaration<T>;
+}

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

@@ -0,0 +1,98 @@
+import { Name } from '../common/index.js';
+import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { NamedTypeEntity, PackageAliasEntity, VariableEntity, VariantEntity } from '../entities/index.js';
+import { IdentifierExpression } from '../tree/index.js';
+import * as types from '../types/index.js';
+import { AccessedMethod } from './AccessedMethod.js';
+import { FoundNamedDeclaration } from './FoundDeclaration.js';
+import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
+import * as scope from './Scope.js';
+import * as variableAccess from './VariableAccess.js';
+import { Analyzer, TargetTypeHint } from './index.js';
+export declare class Resolver {
+    private readonly _identifierValue;
+    private readonly _accessKind;
+    private readonly _semanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _targetTypeHint;
+    constructor(analyzer: Analyzer, node: IdentifierExpression, targetTypeHint: TargetTypeHint | undefined);
+    private get identifierSearchName();
+    private get accessKind();
+    private get semanticContext();
+    resolve(): ResolutionResult;
+    private resolveMethodOverload;
+    private createAccessedMethod;
+}
+export declare class ResolutionResult {
+    readonly meaning: Meaning;
+    readonly diagnostic?: Diagnostic | undefined;
+    constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined);
+}
+export type Meaning = Meaning_variantAccess | Meaning_variableAccess | Meaning_methodAccess | Meaning_packageNameSegmentAccess | Meaning_packageAliasAccess | Meaning_typeAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
+declare class Meaning_variantAccess {
+    readonly variant: FoundNamedDeclaration<VariantEntity>;
+    readonly kind = "variant-access";
+    constructor(variant: FoundNamedDeclaration<VariantEntity>);
+}
+declare class Meaning_variableAccess {
+    readonly variable: FoundNamedDeclaration<AccessedVariable>;
+    readonly access: variableAccess.VariableAccess;
+    readonly kind = "variable-access";
+    constructor(variable: FoundNamedDeclaration<AccessedVariable>, access: variableAccess.VariableAccess);
+}
+declare class Meaning_methodAccess {
+    readonly candidates: readonly FoundNamedDeclaration<AccessedMethod>[];
+    readonly suitableMethods: readonly FoundNamedDeclaration<AccessedMethod>[];
+    readonly kind = "method-access";
+    get singleSuitableMethod(): FoundNamedDeclaration<AccessedMethod> | undefined;
+    constructor(candidates: readonly FoundNamedDeclaration<AccessedMethod>[], suitableMethods: readonly FoundNamedDeclaration<AccessedMethod>[]);
+}
+declare class Meaning_packageAliasAccess {
+    readonly packageAlias: PackageAliasEntity;
+    readonly kind = "package-alias-access";
+    constructor(packageAlias: PackageAliasEntity);
+}
+declare class Meaning_packageNameSegmentAccess {
+    readonly packageTreeNode: PackageNameTreeNode;
+    readonly kind = "package-name-segment-access";
+    constructor(packageTreeNode: PackageNameTreeNode);
+}
+declare class Meaning_typeAccess {
+    readonly candidates: readonly FoundNamedDeclaration<NamedTypeEntity>[];
+    readonly suitableTypes: readonly FoundNamedDeclaration<types.Type>[];
+    readonly kind = "type-access";
+    get singleSuitableType(): FoundNamedDeclaration<types.Type> | undefined;
+    constructor(candidates: readonly FoundNamedDeclaration<NamedTypeEntity>[], suitableTypes: readonly FoundNamedDeclaration<types.Type>[]);
+}
+declare class Meaning_mixedAmbiguousAccess {
+    readonly declarations: readonly FoundNamedDeclaration<scope.NamedDeclaration>[];
+    readonly kind = "mixed-ambiguous-access";
+    constructor(declarations: readonly FoundNamedDeclaration<scope.NamedDeclaration>[]);
+}
+declare class Meaning_unresolved {
+    readonly kind = "unresolved";
+}
+export type AccessedVariable = AccessedVariable_entity | AccessedVariable_typeMember;
+export declare class AccessedVariable_entity implements IAccessedVariable {
+    readonly value: VariableEntity;
+    readonly kind = "entity";
+    constructor(value: VariableEntity);
+    getEntity(): VariableEntity;
+    getName(): Name;
+    getType(): types.Type;
+}
+export declare class AccessedVariable_typeMember implements IAccessedVariable {
+    readonly value: types.Variable;
+    readonly kind = "type-member";
+    constructor(value: types.Variable);
+    getEntity(): VariableEntity;
+    getName(): Name;
+    getType(): types.Type;
+}
+interface IAccessedVariable {
+    getEntity(): VariableEntity;
+    getName(): Name;
+    getType(): types.Type;
+}
+export {};

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

@@ -0,0 +1,22 @@
+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;
+    get rootNodes(): ReadonlyMap<string, PackageNameTreeNode>;
+    constructor(owningPackage: PackageEntity, packageImportInfos: readonly PackageImportInfo[]);
+    private add;
+}
+export interface PackageNameTreeNode {
+    readonly name: Name;
+    readonly package: ImportedPackage | 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

@@ -0,0 +1,26 @@
+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 * as indexerAccess from './IndexerAccess.js';
+import { Analyzer } from './index.js';
+export declare class Resolver {
+    private readonly _analyzer;
+    private readonly _node;
+    constructor(_analyzer: Analyzer, _node: IndexedAccessExpression);
+    resolve(): Meaning;
+    private getArgumentsRangeWithBrackets;
+}
+export type Meaning = Meaning_resolved | Meaning_unresolved;
+declare class Meaning_resolved {
+    readonly indexer: FoundAnonymousDeclaration<types.Indexer>;
+    readonly access: indexerAccess.IndexerAccess;
+    readonly kind = "resolved";
+    constructor(indexer: FoundAnonymousDeclaration<types.Indexer>, access: indexerAccess.IndexerAccess);
+}
+declare class Meaning_unresolved {
+    readonly diagnostic: Diagnostic | undefined;
+    readonly kind = "unresolved";
+    constructor(diagnostic: Diagnostic | undefined);
+}
+export {};

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

@@ -0,0 +1,10 @@
+import { AccessKind } from '../common/index.js';
+import { IndexerEntity, GetterEntity, SetterEntity } from '../entities/index.js';
+export type IndexerAccess = {
+    kind: AccessKind.Get;
+    accessorEntity: GetterEntity | undefined;
+} | {
+    kind: AccessKind.Set;
+    accessorEntity: SetterEntity | undefined;
+};
+export declare function create(indexerEntity: IndexerEntity, accessKind: AccessKind): IndexerAccess;

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

@@ -0,0 +1,54 @@
+import { PackageLocale, Name } from '../common/index.js';
+import { Entity } from '../entities/index.js';
+import { AnalyzedTranslationPackage } from './AnalyzedTranslationPackage.js';
+export type Localization = Localization.Original | Localization.Translated;
+export declare namespace Localization {
+    export class Original implements ILocalization {
+        readonly locale: PackageLocale;
+        readonly kind = "original";
+        constructor(locale: PackageLocale);
+        equals(other: Localization): boolean;
+        static ofEntity(entity: Entity): Localization.Original;
+    }
+    export class Translated implements ILocalization {
+        readonly translation: Translation;
+        readonly kind = "translated";
+        get locale(): PackageLocale;
+        constructor(translation: Translation);
+        equals(other: Localization): boolean;
+    }
+    interface ILocalization {
+        readonly locale: PackageLocale;
+        equals(other: Localization): boolean;
+    }
+    export {};
+}
+export interface WithLocalization<T> {
+    readonly value: T;
+    readonly localization: Localization;
+}
+export declare class Translation {
+    readonly translationPackage: AnalyzedTranslationPackage;
+    constructor(translationPackage: AnalyzedTranslationPackage);
+    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 {};
+}

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

@@ -0,0 +1,15 @@
+import { PackageLocale, Name } from '../common/index.js';
+import { AliasTypeEntity, MethodEntity, PackageAliasEntity, PackageEntity, PackageMethodTypeEntity, PackageStructuredTypeEntity, PackageVariantTypeEntity, TypeEntity, TypeParameterEntity, VariableEntity, VariantEntity, VariantTypeEntity } from '../entities/index.js';
+import { AnalyzedTranslationPackage, TranslatedTypeEntityMembers, TranslatedVariants } from './AnalyzedTranslationPackage.js';
+export declare class LocalizationContext {
+    readonly originalLocale: PackageLocale;
+    private readonly _translationPackageByTranslated;
+    get translationPackages(): Iterable<AnalyzedTranslationPackage>;
+    constructor(translationPackages: readonly AnalyzedTranslationPackage[], originalLocale: PackageLocale);
+    getTranslationPackage(packageEntity: PackageEntity): AnalyzedTranslationPackage | undefined;
+    getTranslationLocale(packageEntity: PackageEntity): PackageLocale;
+    getTranslatedTypeEntityMembers(typeEntity: TypeEntity): TranslatedTypeEntityMembers | undefined;
+    getTranslatedVariants(typeEntity: VariantTypeEntity): TranslatedVariants | undefined;
+    getEntityName(entity: NamedEntity): Name;
+}
+export type NamedEntity = VariableEntity | VariantEntity | PackageVariantTypeEntity | MethodEntity | TypeParameterEntity | PackageMethodTypeEntity | PackageStructuredTypeEntity | PackageAliasEntity | AliasTypeEntity;

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

@@ -0,0 +1,23 @@
+import { Query, SearchName } from '../common/index.js';
+import { IEntityHidingMatcher, TypeEntity, TypeExtensionEntity } from '../entities/index.js';
+import { FoundNamedDeclaration } from './FoundDeclaration.js';
+import { IScope, NamedDeclaration, TypeOrContainerWithTypes } from './Scope.js';
+export declare class Lookup {
+    private readonly _scopeChain;
+    private readonly _hidingMatcher;
+    constructor(_scopeChain: ScopeChain, _hidingMatcher: IEntityHidingMatcher);
+    getTypesOrContainersWithTypes(): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getTypesOrContainersWithTypesByName(name: SearchName): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getNamedDeclarations(): FoundNamedDeclaration<NamedDeclaration>[];
+    getNamedDeclarationsByName(name: SearchName): FoundNamedDeclaration<NamedDeclaration>[];
+    getTypeExtensionsByType(type: TypeEntity): TypeExtensionEntity[];
+    private checkTypeOrPackageDeclarationShadowing;
+    private checkNamedDeclarationShadowing;
+}
+export declare class ScopeChain {
+    private readonly _entry;
+    private constructor();
+    addFirst(scope: IScope): ScopeChain;
+    toQuery(): Query<IScope>;
+    static withSingleScope(scope: IScope): ScopeChain;
+}