@artel/artc 0.6.25191

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

@@ -0,0 +1,665 @@
+import ts from 'typescript';
+import { AccessKind, CancellationToken, Name, PackageLocale, Range, SearchName, WithDiagnostics } from '../common/index.js';
+import { Diagnostic, DiagnosticAcceptor, DiagnosticLocation } from '../diagnostic/Diagnostic.js';
+import { DiagnosticCode } from '../diagnostic/DiagnosticCode.js';
+import { DiagnosticFlags, DiagnosticKind } from '../diagnostic/DiagnosticData.js';
+import * as packageMembers from '../entities/PackageMembers.js';
+import * as entities from '../entities/index.js';
+import { AliasTypeEntity, AnonymousMethodTypeEntity, AnonymousStructuredTypeEntity, AnonymousVariantTypeEntity, BinaryOperatorEntity, BinaryOperatorKind, ConstructorEntity, DereferenceOperatorEntity, DestructorEntity, GetterEntity, IEntityHidingMatcher, LocalVariableEntity, MethodEntity, MethodTypeEntity, NamedTypeEntity, NestedMethodEntity, PackageAliasEntity, PackageEntity, PackageMethodEntity, PackageMethodTypeEntity, PackageStructuredTypeEntity, PackageVariableEntity, PackageVariantTypeEntity, SetterEntity, SourceIndexerEntity, StructuredTypeEntity, TypeEntity, TypeExtensionEntity, TypeMemberEntityContainer, TypeMethodEntity, TypeParameterEntity, TypeVariableEntity, UnaryOperatorEntity, VariableEntity, VariantEntity, VariantTypeEntity } from '../entities/index.js';
+import { ReservedIdentifierKind } from '../parser/ReservedIdentifierDictionary.js';
+import * as project from '../project/index.js';
+import { PackageName, PlatformKind, SourcePackage } from '../project/index.js';
+import * as tree from '../tree/index.js';
+import { TsInteropContext, TsProgramState } from '../ts-interop/TsInteropContext.js';
+import * as types from '../types/index.js';
+import { TypeFactory } from '../types/index.js';
+import { AccessedMethod } from './AccessedMethod.js';
+import { AnalyzedTranslationPackage } from './AnalyzedTranslationPackage.js';
+import * as autotypeCallExpressionMeaning from './AutotypeCallExpressionMeaning.js';
+import * as baseExpressionMeaning from './BaseExpressionMeaning.js';
+import { BuiltInOperators } from './BuiltInOperators.js';
+import { CallArgumentToParameterMatchResult, MatchResultValueParameter } from './CallArgumentToParameterMatchResult.js';
+import * as callExpressionMeaning from './CallExpressionMeaning.js';
+import * as constructorOverloadResolver from './ConstructorOverloadResolver.js';
+import { DeclarationsUsageCountResult } from './DeclarationsUsageCounter.js';
+import * as dereferenceExpressionMeaning from './DereferenceExpressionMeaning.js';
+import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
+import * as identifierExpressionResolution from './IdentifierExpressionMeaning.js';
+import { ImportedPackageNameTree, PackageNameTreeNode } from './ImportedPackageNameTree.js';
+import * as indexedAccessExpressionMeaning from './IndexedAccessExpressionMeaning.js';
+import { WithLocalization } from './Localization.js';
+import { LocalizationContext } from './LocalizationContext.js';
+import { NamedTypeSpecifierResolutionResult } from './NamedTypeSpecifierResolver.js';
+import { GetterDeclaration, MethodTypeDeclaration, PackageVariableAccessorDeclaration, SetterDeclaration, StructuredTypeDeclaration, TypeDereferencedVariableAccessorDeclaration, TypeIndexedAccessorDeclaration, TypeVariableAccessorDeclaration, VariantTypeDeclaration } from './NodeTypeUtils.js';
+import * as objectExpressionMeaning from './ObjectExpressionMeaning.js';
+import * as operationOverloadResolver from './OperationOverloadResolver.js';
+import * as propertyAccessExpressionResolution from './PropertyAccessExpressionMeaning.js';
+import * as scope from './Scope.js';
+import { SemanticContextBuilder } from './SemanticContextBuilder.js';
+import * as sourceFileMembers from './SourceFileMembers.js';
+import * as tagMeaning from './TagMeaning.js';
+import * as tags from './Tags.js';
+import { TargetTypeHint } from './TargetTypeHint.js';
+import * as typeOverloadResolver from './TypeOverloadResolver.js';
+import { WellKnownDeclarations } from './index.js';
+import { NamedTypeMemberEntity } from '../entities/TypeEntityMembers.js';
+export declare class Analyzer {
+    static readonly enumeratorMethodName = "\u043F\u0435\u0440\u0435\u0431\u043E\u0440";
+    static readonly methodTypeInvokeMethodName = "\u0432\u044B\u043F\u043E\u043B\u043D\u0438\u0442\u044C";
+    readonly compilation: project.Compilation;
+    /**
+     * Пакет с именем 'Артель', содержащий стандартные типы.
+     */
+    readonly systemPackage: PackageEntity;
+    readonly wellKnownDeclarations: WellKnownDeclarations;
+    readonly standardTypes: types.StandardTypes;
+    readonly typeFactory: TypeFactory;
+    readonly type: Type;
+    readonly returnType: ReturnType;
+    readonly entity: Entity;
+    readonly resultLocalVariableEntity: ResultLocalVariableEntity;
+    readonly paramLocalVariableEntity: ParamLocalVariableEntity;
+    readonly valueLocalVariableEntity: ValueLocalVariableEntity;
+    readonly destructuredParameterLocalVariableEntities: DestructuredParameterLocalVariableEntities;
+    readonly scope: Scope;
+    readonly semanticContext: SemanticContextBuilder;
+    readonly callArgumentToParameterMatchResult: CallArgumentToParameterMatchResult;
+    readonly defaultConstructors: DefaultConstructors;
+    readonly overriddenMember: OverriddenMember;
+    readonly tags: Tags;
+    readonly linkedEntity: LinkedEntity;
+    readonly owningPlainObjectModificationCheck: OwningPlainObjectModificationCheck;
+    readonly builtInOperators: BuiltInOperators;
+    readonly packageImports: PackageImports;
+    private readonly _tsInteropInputs;
+    private readonly _targetType;
+    private readonly _typeAssignabilityCheck;
+    private readonly _tsInterop;
+    private readonly _propertyAccessExpressionResolutionResults;
+    private readonly _sourceFileMembers;
+    private readonly _callExpressionMeanings;
+    private readonly _indexedAccessExpressionMeanings;
+    private readonly _dereferenceExpressionMeanings;
+    private readonly _autotypeCallExpressionMeanings;
+    private readonly _identifierExpressionResolutionResults;
+    private readonly _tagMeanings;
+    private readonly _objectExpressionMeanings;
+    private readonly _baseExpressionMeanings;
+    private readonly _namedTypeSpecifierResolutionResults;
+    private readonly _prefixUnaryExpressionOperatorResolutionResults;
+    private readonly _notExpressionOperatorResolutionResults;
+    private readonly _binaryExpressionUserDefinableOperatorResolutionResults;
+    private readonly _assignmentStatementOperatorResolutionResults;
+    private readonly _methodEntitySignatureTypes;
+    private readonly _valueParametersOfMethodBlockLiterals;
+    private readonly _extendedTypes;
+    private readonly _analyzedTranslationPackages;
+    private readonly _linkedMultiPlatformPackagesByPlatform;
+    private readonly _bodyUsesYieldStatementCheckResults;
+    private readonly _namedDeclarationsUsageCountResults;
+    get tsInterop(): TsInteropContext;
+    constructor(compilation: project.Compilation, tsInteropInputs: TsInteropInputs);
+    getProjectSourceFile(node: tree.SourceFile): project.SourceFile;
+    ifTypeEnumerableThenItemType(type: types.Type): types.Type | undefined;
+    ifTypeEnumeratorThenItemType(type: types.Type): types.Type | undefined;
+    isTypeArrayOrReadonlyArray(type: types.Type): {
+        elementType: types.Type;
+    } | undefined;
+    isTypeReference(type: types.Type): {
+        referencedType: types.Type;
+    } | undefined;
+    isTypeAssignableTo(source: types.Type, target: types.Type): boolean;
+    checkStatementBlockInvokesAsyncMethods(node: tree.StatementBlock): boolean;
+    getExpressionAccessKind(node: tree.Expression): AccessKind;
+    getTypeMemberEntityContainer(node: tree.TypeMemberDeclaration): TypeMemberEntityContainer;
+    getTargetTypeOfExpression(node: tree.Expression, hint?: TargetTypeHint): types.Type | undefined;
+    getUnambiguousTargetMethodType(targetType: types.Type | undefined): types.MethodType | undefined;
+    getUnambiguousTargetVariantType(targetType: types.Type | undefined): types.VariantType | undefined;
+    getUnambiguousTargetArrayType(targetType: types.Type | undefined): types.Type | undefined;
+    getEnumeratorElementType(node: tree.Node): types.Type | undefined;
+    resolveMethodOverloadByCallExpression<TCandidate extends operationOverloadResolver.ICandidate<TValueParameter>, TValueParameter extends operationOverloadResolver.IValueParameter>(candidates: Iterable<TCandidate>, node: tree.CallExpression): Iterable<TCandidate>;
+    resolveMethodOverloadByTargetType<TCandidate extends operationOverloadResolver.ICandidate<TValueParameter>, TValueParameter extends operationOverloadResolver.IValueParameter>(candidates: Iterable<TCandidate>, targetType: types.MethodType): Iterable<TCandidate>;
+    resolveConstructorOverload<TCandidate extends constructorOverloadResolver.ICandidate<TValueParameter>, TValueParameter extends constructorOverloadResolver.IValueParameter>(candidates: Iterable<TCandidate>, callArguments: Iterable<tree.CallArgument>): Iterable<TCandidate>;
+    resolveTypeOverloadByArgumentCount<TCandidate extends typeOverloadResolver.ICandidate>(candidates: Iterable<TCandidate>, argumentCount: number): Iterable<TCandidate>;
+    resolvePropertyAccessExpression(node: tree.PropertyAccessExpression, targetTypeHint?: TargetTypeHint): propertyAccessExpressionResolution.ResolutionResult;
+    enumeratePackageImports(packageImportDirectives: Iterable<tree.PackageImportDirective>): Iterable<tree.PackageImport>;
+    getSourceFileMembers(node: tree.SourceFile): sourceFileMembers.SourceFileMembers;
+    getCallExpressionMeaning(node: tree.CallExpression): callExpressionMeaning.Meaning;
+    getRespectiveParameter(node: tree.CallArgument): MatchResultValueParameter | undefined;
+    getIndexedAccessExpressionMeaning(node: tree.IndexedAccessExpression): indexedAccessExpressionMeaning.Meaning;
+    getDereferenceExpressionMeaning(node: tree.DereferenceExpression): dereferenceExpressionMeaning.Meaning;
+    getAutotypeCallExpressionMeaning(node: tree.AutotypeCallExpression, targetTypeHint?: TargetTypeHint): autotypeCallExpressionMeaning.Meaning;
+    resolveIdentifierExpression(node: tree.IdentifierExpression, targetTypeHint?: TargetTypeHint): identifierExpressionResolution.ResolutionResult;
+    getTagMeaning(node: tree.Tag): tagMeaning.Meaning;
+    getObjectExpressionMeaning(node: tree.ObjectExpression): objectExpressionMeaning.Meaning;
+    getBaseExpressionMeaning(node: tree.BaseExpression): baseExpressionMeaning.Meaning;
+    checkExpressionOptionalChaining(node: tree.Expression): boolean;
+    makeNoneAssignableToTypeIfExpressionOptionalChaining(type: types.Type, node: tree.Expression): types.Type;
+    checkIdentifierNameIsReserved(name: string, locale: PackageLocale): ReservedIdentifierKind | undefined;
+    getReservedIdentifierName(reservedIdentifierKind: ReservedIdentifierKind, locale: PackageLocale): string;
+    createNameFromIdentifier(node: tree.Identifier): Name;
+    createSearchNameFromIdentifier(identifier: tree.Identifier): SearchName;
+    createLocalizationContext(sourceFile: project.SourceFile): LocalizationContext;
+    typeIsValidBaseObjectType(type: types.Type): boolean;
+    typeIsValidBaseAspectType(type: types.Type): boolean;
+    getImplicitBaseTypeForStructuredType(entity: StructuredTypeEntity): types.StructuredType | undefined;
+    getImplicitBaseTypeForVariantType(): types.StructuredType;
+    getImplicitBaseTypeForMethodType(): types.StructuredType;
+    resolveNamedTypeSpecifier(node: tree.NamedTypeSpecifier): NamedTypeSpecifierResolutionResult;
+    checkExpressionDenotesType(expression: tree.Expression): {
+        type: types.Type | undefined;
+    } | undefined;
+    checkExpressionDenotesPackageAlias(expression: tree.Expression): {
+        packageAlias: PackageAliasEntity;
+    } | undefined;
+    checkExpressionDenotesMethod(expression: tree.Expression): ExpressionDenotesMethodCheckResult | undefined;
+    checkExpressionDenotesPackageNameSegment(expression: tree.Expression): {
+        packageTreeNode: PackageNameTreeNode;
+    } | undefined;
+    checkMethodBodyUsesYieldStatement(node: tree.StatementBlock): boolean;
+    enumerateAspects(type: types.Type): Iterable<types.StructuredType>;
+    checkTypeIsBasedOnAspect(type: types.Type, aspectEntity: StructuredTypeEntity): boolean;
+    resolvePrefixUnaryExpressionOperator(node: tree.PrefixUnaryExpression): WithDiagnostics<FoundAnonymousDeclaration<types.UnaryOperator>>;
+    resolveNotExpressionOperator(node: tree.NotExpression): WithDiagnostics<FoundAnonymousDeclaration<types.UnaryOperator>>;
+    resolveBinaryExpressionUserDefinableOperator(node: tree.BinaryExpression, operatorKind: BinaryOperatorKind): WithDiagnostics<FoundAnonymousDeclaration<types.BinaryOperator>>;
+    resolveCompoundAssignmentStatementOperator(node: tree.AssignmentStatement, operatorKind: BinaryOperatorKind): WithDiagnostics<FoundAnonymousDeclaration<types.BinaryOperator>>;
+    classifyBinaryExpressionOperator(operator: tree.BinaryExpressionOperator): BinaryExpressionOperatorClassificationResult;
+    getBinaryOperatorKindIfCompoundAssignmentOperator(operator: tree.AssignmentStatementOperator): BinaryOperatorKind | undefined;
+    getPackageEntities(): readonly PackageEntity[];
+    getPackageEntity(name: PackageName): PackageEntity | undefined;
+    createMethodTypeInvokeMethod(entity: MethodTypeEntity): TypeMethodEntity;
+    /**
+     * Преобразует тип таким образом, чтобы он не мог содержать значение `пусто`.
+     * После преобразования метод `canTypeBeNone` вернёт `true` для полученного типа.
+     * @example
+     * - Число         -> Число
+     * - Число | Пусто -> Число
+     * - Т: Объект?    -> Т: Объект? (с флагом isNoneExcluded === true)
+     * - Т: Объект     -> Т: Объект (без изменения)
+     */
+    excludeNoneFromType(type: types.Type): types.Type;
+    /**
+     * Отвечает на вопрос "Может ли переменная данного типа иметь значение `пусто`?".
+     * @example Для следующих типов метод вернёт:
+     * - Число         -> нет
+     * - Число | Пусто -> да
+     * - Т: Объект?    -> да
+     * - Т: Объект     -> нет
+     */
+    canTypeBeNone(type: types.Type): boolean;
+    canTypeParameterBeNone(type: types.ParameterType): boolean;
+    /**
+     * Делает тип `Пусто` совместимым с данным типом.
+     * @example
+     * - Число         -> Число | Пусто
+     * - Число | Пусто -> Число | Пусто
+     * - Т: Объект?    -> (Т: Объект?) | Пусто (см. метод isNoneAssignableToType)
+     * - Т: Объект     -> (Т: Объект) | Пусто
+     */
+    makeNoneAssignableToType(type: types.Type): types.Type;
+    /**
+     * Отвечает на вопрос "Совместим ли тип `Пусто` с данным типом?" (Можно ли присвоить `пусто` в переменную с данным типом?).
+     * @example Для следующих типов метод вернёт:
+     * - Число         -> нет
+     * - Число | Пусто -> да
+     * - Т: Объект?    -> нет, поскольку в качестве конкретного типа, заменяющего параметр, может быть использован тип, исключающий `пусто`.
+     */
+    isNoneAssignableToType(type: types.Type): boolean;
+    isMethodValueParameterVariadic(entity: VariableEntity): boolean;
+    getDefaultTypeParameterConstraint(): types.Type;
+    getOriginalSignatureTypeOfMethodEntity(entity: MethodEntity): types.MethodType;
+    getMethodBlockLiteralValueParameters(node: tree.MethodBlockLiteral): readonly VariableEntity[];
+    getExtendedType(node: tree.TypeExtensionDeclaration): WithDiagnostics<NamedTypeEntity>;
+    getAnalyzedTranslationPackageIfTargetResolved(package_: project.TranslationPackage): AnalyzedTranslationPackage | undefined;
+    getAnalyzedTranslationPackageForPackage(entity: PackageEntity, locale: PackageLocale): AnalyzedTranslationPackage | undefined;
+    enumerateAnalyzedTranslationPackages(): Iterable<AnalyzedTranslationPackage>;
+    getCommonObjectAndAspectTypesOfUnion(_unionType: types.UnionType): readonly types.StructuredType[];
+    getLinkedMultiPlatformPackagesByPlatform(entity: PackageEntity): ReadonlyMap<PlatformKind, LinkedMultiPlatformPackage> | undefined;
+    getLinkedMultiPlatformPackage(entity: PackageEntity, platform: PlatformKind): LinkedMultiPlatformPackage | undefined;
+    createPackageMembers(pkg: SourcePackage): packageMembers.OriginalPackageMembers;
+    instantiateType(entity: entities.TypeEntity, typeArguments?: readonly types.Type[]): types.Type;
+    instantiateTypeByIdentitySubstitution(entity: entities.TypeEntity): types.Type;
+    createPackageMemberHiding(node: tree.PackageMemberDeclaration): entities.EntityHidingLevel | undefined;
+    createTypeMemberHiding(node: tree.TypeMemberDeclaration): entities.EntityHidingLevel | undefined;
+    getDeclarationsUsageCount(sourceFile: tree.SourceFile, cancellationToken: CancellationToken | undefined): Promise<DeclarationsUsageCountResult>;
+    isExpressionImplicitlyReturnedFromSubprogram(node: tree.ExpressionStatement): boolean;
+    createBackingPackageVariables(declaredVariables: readonly PackageVariableEntity[], pkg: PackageEntity): PackageVariableEntity[];
+    createBackingTypeVariables(declaredVariables: readonly TypeVariableEntity[], type: TypeEntity): TypeVariableEntity[];
+    createNodeDiagnostic(code: DiagnosticCode, node: tree.Node, formatArguments?: readonly string[], kind?: DiagnosticKind, flags?: DiagnosticFlags): Diagnostic;
+    createSourceFileRangeDiagnostic(code: DiagnosticCode, range: Range, nodeOrSourceFile: tree.Node | project.SourceFile, formatArguments?: readonly string[], kind?: DiagnosticKind, flags?: DiagnosticFlags): Diagnostic;
+    createDiagnostic(code: DiagnosticCode, location: DiagnosticLocation | undefined, formatArguments?: readonly string[], kind?: DiagnosticKind, flags?: DiagnosticFlags): Diagnostic;
+    createNodeDiagnosticLocation(node: tree.Node): DiagnosticLocation;
+    getDeclaredTypeMemberEntities(node: tree.TypeMemberDeclarationBlock): DeclaredTypeMemberEntities;
+    getRedefinableMethodOfOriginalTypeForRedefinableMethodOfAliasType(entity: TypeMethodEntity): TypeMethodEntity | undefined;
+    checkBodyOfRedefinableAliasTypeMethod(node: tree.TypeMethodDeclaration, diagnostics?: DiagnosticAcceptor): {
+        redefinableMethodOfOriginalType: TypeMethodEntity;
+    } | undefined;
+    private createTsInterop;
+}
+export declare class TsInteropInputs {
+    readonly programState: TsProgramState;
+    readonly standardLibraryFileByName: ReadonlyMap<string, ts.SourceFile>;
+    readonly rootFileByGlobalLibraryName: ReadonlyMap<string, ts.SourceFile>;
+    readonly moduleSymbolByName: ReadonlyMap<string, ts.Symbol>;
+    constructor(programState: TsProgramState, standardLibraryFileByName: ReadonlyMap<string, ts.SourceFile>, rootFileByGlobalLibraryName: ReadonlyMap<string, ts.SourceFile>, moduleSymbolByName: ReadonlyMap<string, ts.Symbol>);
+}
+export type BinaryExpressionOperatorClassificationResult = {
+    kind: 'user-definable';
+    operatorKind: BinaryOperatorKind;
+} | {
+    kind: 'question-question';
+};
+declare class Type {
+    private readonly _analyzer;
+    private readonly _unionTypeSpecifierTypes;
+    private readonly _methodLiteralTypes;
+    private readonly _methodBlockLiteralTypes;
+    constructor(_analyzer: Analyzer);
+    ofExpression(node: tree.Expression, targetTypeHint?: TargetTypeHint): types.Type;
+    ofTypeSpecifier(node: tree.TypeSpecifier): types.Type;
+    ofAccessedMethod(accessedMethod: WithLocalization<AccessedMethod>): types.Type;
+    ofMethodBlockLiteral(node: tree.MethodBlockLiteral, targetTypeHint?: TargetTypeHint): types.MethodType;
+    ofMethodLiteral(node: tree.MethodLiteral, targetTypeHint?: TargetTypeHint): types.MethodType;
+    private ofArrayLiteral;
+    private ofAssertionExpression;
+    private ofAssumptionExpression;
+    private ofAsExpression;
+    private ofBinaryExpression;
+    private ofCallExpression;
+    private ofAutotypeCallExpression;
+    private ofIndexedAccessExpression;
+    private ofInvalidExpression;
+    private ofIsExpression;
+    private ofUnobservableExpression;
+    private ofNotExpression;
+    private ofParenthesizedExpression;
+    private ofPrefixUnaryExpression;
+    private ofPropertyAccessExpression;
+    private ofReferenceExpression;
+    private ofDereferenceExpression;
+    private ofWhenTernaryExpression;
+    private ofTextTemplateLiteral;
+    private ofTransactionalExpression;
+    private ofIdentifierExpression;
+    private ofTokenExpression;
+    private ofKeywordExpression;
+    private ofObjectExpression;
+    private ofBaseExpression;
+    private ofGenericSpecializationExpression;
+    private ofDefaultMatchExpression;
+    private ofAnonymousTypeSpecifier;
+    private ofNamedTypeSpecifier;
+    private ofParenthesizedTypeSpecifier;
+    private ofNullableTypeSpecifier;
+    private ofUnionTypeSpecifier;
+    private ofInvalidTypeSpecifier;
+    private getTargetlessMethodBlockLiteralType;
+    private inferMethodLiteralTypeFromNodeWithFallbackToTargetType;
+    private inferMethodLiteralTypeFromNode;
+}
+declare class ReturnType {
+    private readonly _analyzer;
+    constructor(_analyzer: Analyzer);
+    ofAnonymousMethodTypeDeclaration(node: tree.AnonymousMethodTypeDeclaration): types.Type;
+    ofMethodBlockLiteral(node: tree.MethodBlockLiteral): types.Type;
+    ofPackageMethodDeclaration(node: tree.PackageMethodDeclaration): types.Type;
+    ofPackageMethodTypeDeclaration(node: tree.PackageMethodTypeDeclaration): types.Type;
+    ofNestedMethodDeclaration(node: tree.NestedMethodDeclaration): types.Type;
+    ofMethodLiteral(node: tree.MethodLiteral): types.Type;
+    ofTypeMethodDeclaration(node: tree.TypeMethodDeclaration): types.Type;
+}
+declare class Entity {
+    private readonly _analyzer;
+    private readonly _packageEntities;
+    private readonly _packageVariableEntities;
+    private readonly _typeVariableEntities;
+    private readonly _parameterVariableEntities;
+    private readonly _localVariableEntities;
+    private readonly _typeParameterEntities;
+    private readonly _indexerEntities;
+    private readonly _referenceOperatorEntities;
+    private readonly _packageStructuredTypeEntities;
+    private readonly _anonymousStructuredTypeEntities;
+    private readonly _packageVariantTypeEntities;
+    private readonly _anonymousVariantTypeEntities;
+    private readonly _packageMethodTypeEntities;
+    private readonly _anonymousMethodTypeEntities;
+    private readonly _aliasTypeEntities;
+    private readonly _packageMethodEntities;
+    private readonly _typeMethodEntities;
+    private readonly _nestedMethodEntities;
+    private readonly _constructorEntities;
+    private readonly _destructorEntities;
+    private readonly _getterEntities;
+    private readonly _setterEntities;
+    private readonly _variantEntities;
+    private readonly _typeExtensionEntities;
+    private readonly _packageAliasEntities;
+    constructor(_analyzer: Analyzer);
+    ofPackage(pkg: SourcePackage): PackageEntity;
+    ofPackageVariableDeclaration(node: tree.PackageVariableDeclaration): entities.PackageVariableEntity;
+    ofComputedPackageVariableDeclaration(node: PackageVariableAccessorDeclaration): entities.PackageVariableEntity;
+    ofTypeVariableDeclaration(node: tree.TypeVariableDeclaration): entities.TypeVariableEntity;
+    ofComputedTypeVariableDeclaration(node: TypeVariableAccessorDeclaration): entities.TypeVariableEntity;
+    ofLocalVariableDeclaration(node: tree.LocalVariableDeclaration): entities.LocalVariableEntity;
+    ofEnumerationVariableDeclaration(node: tree.EnumerationVariableDeclaration): entities.LocalVariableEntity;
+    ofErrorVariableDeclaration(node: tree.ErrorVariableDeclaration): entities.LocalVariableEntity;
+    ofParameterDeclaration(node: tree.ParameterDeclaration): entities.ParameterVariableEntity;
+    ofSetterParameterDeclaration(node: tree.SetterParameterDeclaration): entities.ParameterVariableEntity;
+    ofTypeParameterDeclaration(node: tree.TypeParameterDeclaration): TypeParameterEntity;
+    ofTypeIndexerDeclaration(node: TypeIndexedAccessorDeclaration): entities.SourceIndexerEntity;
+    ofTypeDereferenceOperatorDeclaration(node: TypeDereferencedVariableAccessorDeclaration): entities.DereferenceOperatorEntity;
+    ofPackageStructuredTypeDeclaration(node: tree.PackageStructuredTypeDeclaration): PackageStructuredTypeEntity;
+    ofAnonymousStructuredTypeDeclaration(node: tree.AnonymousStructuredTypeDeclaration): AnonymousStructuredTypeEntity;
+    ofStructuredTypeDeclaration(node: StructuredTypeDeclaration): StructuredTypeEntity;
+    ofPackageMethodTypeDeclaration(node: tree.PackageMethodTypeDeclaration): PackageMethodTypeEntity;
+    ofAnonymousMethodTypeDeclaration(node: tree.AnonymousMethodTypeDeclaration): AnonymousMethodTypeEntity;
+    ofMethodTypeDeclaration(node: MethodTypeDeclaration): MethodTypeEntity;
+    ofPackageVariantTypeDeclaration(node: tree.PackageVariantTypeDeclaration): PackageVariantTypeEntity;
+    ofAnonymousVariantTypeDeclaration(node: tree.AnonymousVariantTypeDeclaration): AnonymousVariantTypeEntity;
+    ofVariantTypeDeclaration(node: VariantTypeDeclaration): VariantTypeEntity;
+    ofPackageAliasTypeDeclaration(node: tree.PackageAliasTypeDeclaration): AliasTypeEntity;
+    ofPackageMethodDeclaration(node: tree.PackageMethodDeclaration): PackageMethodEntity;
+    ofTypeMethodDeclaration(node: tree.TypeMethodDeclaration): TypeMethodEntity;
+    ofNestedMethodDeclaration(node: tree.NestedMethodDeclaration): NestedMethodEntity;
+    ofPackageVariableGetterDeclaration(node: tree.PackageVariableGetterDeclaration): GetterEntity;
+    ofTypeVariableGetterDeclaration(node: tree.TypeVariableGetterDeclaration): GetterEntity;
+    ofTypeIndexedGetterDeclaration(node: tree.TypeIndexedGetterDeclaration): GetterEntity;
+    ofTypeDereferencedVariableGetterDeclaration(node: tree.TypeDereferencedVariableGetterDeclaration): GetterEntity;
+    ofGetterDeclaration(node: GetterDeclaration): GetterEntity;
+    ofPackageVariableSetterDeclaration(node: tree.PackageVariableSetterDeclaration): SetterEntity;
+    ofTypeVariableSetterDeclaration(node: tree.TypeVariableSetterDeclaration): SetterEntity;
+    ofTypeIndexedSetterDeclaration(node: tree.TypeIndexedSetterDeclaration): SetterEntity;
+    ofTypeDereferencedVariableSetterDeclaration(node: tree.TypeDereferencedVariableSetterDeclaration): SetterEntity;
+    ofSetterDeclaration(node: SetterDeclaration): SetterEntity;
+    ofTypeConstructorDeclaration(node: tree.TypeConstructorDeclaration): ConstructorEntity;
+    ofTypeDestructorDeclaration(node: tree.TypeDestructorDeclaration): DestructorEntity;
+    ofVariantDeclaration(node: tree.VariantDeclaration): VariantEntity;
+    ofTypeExtensionDeclaration(node: tree.TypeExtensionDeclaration): TypeExtensionEntity;
+    ofPackageImport(node: tree.PackageImport): PackageAliasEntity;
+    private getContainingPackageLoadedFromDts;
+    private createComputedTypeVariableEntities;
+    private createTypeDereferenceOperatorEntities;
+    private createTypeIndexerEntities;
+    private areTypeIndexedAccessorDeclarationsEqual;
+}
+declare class ResultLocalVariableEntity {
+    private readonly _analyzer;
+    private readonly _entities;
+    constructor(_analyzer: Analyzer);
+    ofPackageMethodDeclaration(node: tree.PackageMethodDeclaration): LocalVariableEntity | undefined;
+    ofTypeMethodDeclaration(node: tree.TypeMethodDeclaration): LocalVariableEntity | undefined;
+    ofNestedMethodDeclaration(node: tree.NestedMethodDeclaration): LocalVariableEntity | undefined;
+    ofMethodLiteral(node: tree.MethodLiteral): LocalVariableEntity | undefined;
+    ofMethodBlockLiteral(node: tree.MethodBlockLiteral): LocalVariableEntity | undefined;
+    ofPackageVariableGetterDeclaration(node: tree.PackageVariableGetterDeclaration): LocalVariableEntity;
+    ofTypeVariableGetterDeclaration(node: tree.TypeVariableGetterDeclaration): LocalVariableEntity;
+    ofTypeIndexedGetterDeclaration(node: tree.TypeIndexedGetterDeclaration): LocalVariableEntity;
+    ofTypeDereferencedVariableGetterDeclaration(node: tree.TypeDereferencedVariableGetterDeclaration): LocalVariableEntity;
+    private createResultLocalVariableEntity;
+}
+declare class ParamLocalVariableEntity {
+    private readonly _analyzer;
+    private readonly _optionalEntities;
+    private readonly _entities;
+    constructor(_analyzer: Analyzer);
+    ofTypeIndexedGetterDeclaration(node: tree.TypeIndexedGetterDeclaration): VariableEntity;
+    ofPackageVariableSetterDeclaration(node: tree.PackageVariableSetterDeclaration): VariableEntity;
+    ofTypeVariableSetterDeclaration(node: tree.TypeVariableSetterDeclaration): VariableEntity;
+    ofTypeIndexedSetterDeclaration(node: tree.TypeIndexedSetterDeclaration): VariableEntity;
+    ofTypeDereferencedVariableSetterDeclaration(node: tree.TypeDereferencedVariableSetterDeclaration): VariableEntity;
+    ofPackageMethodDeclaration(node: tree.PackageMethodDeclaration): VariableEntity | undefined;
+    ofTypeMethodDeclaration(node: tree.TypeMethodDeclaration): VariableEntity | undefined;
+    ofNestedMethodDeclaration(node: tree.NestedMethodDeclaration): VariableEntity | undefined;
+    ofMethodLiteral(node: tree.MethodLiteral): VariableEntity | undefined;
+    ofMethodBlockLiteral(node: tree.MethodBlockLiteral): VariableEntity | undefined;
+    ofTypeConstructorDeclaration(node: tree.TypeConstructorDeclaration): VariableEntity | undefined;
+    private createParamLocalVariableEntity;
+    private createAccessorParamLocalVariableEntity;
+}
+declare class ValueLocalVariableEntity {
+    private readonly _analyzer;
+    private readonly _entities;
+    constructor(_analyzer: Analyzer);
+    ofPackageVariableSetterDeclaration(node: tree.PackageVariableSetterDeclaration): VariableEntity | undefined;
+    ofTypeVariableSetterDeclaration(node: tree.TypeVariableSetterDeclaration): VariableEntity | undefined;
+    ofTypeIndexedSetterDeclaration(node: tree.TypeIndexedSetterDeclaration): VariableEntity | undefined;
+    ofTypeDereferencedVariableSetterDeclaration(node: tree.TypeDereferencedVariableSetterDeclaration): VariableEntity | undefined;
+}
+declare class DestructuredParameterLocalVariableEntities {
+    private readonly _analyzer;
+    private readonly _entities;
+    constructor(_analyzer: Analyzer);
+    ofMethodBlockLiteral(node: tree.MethodBlockLiteral): readonly VariableEntity[];
+    ofPackageMethodDeclaration(node: tree.PackageMethodDeclaration): readonly VariableEntity[];
+    ofTypeMethodDeclaration(node: tree.TypeMethodDeclaration): readonly VariableEntity[];
+    ofMethodLiteral(node: tree.MethodLiteral): readonly VariableEntity[];
+    ofNestedMethodDeclaration(node: tree.NestedMethodDeclaration): readonly VariableEntity[];
+    ofTypeConstructorDeclaration(node: tree.TypeConstructorDeclaration): readonly VariableEntity[];
+    private createVariableEntitiesBasedOnValueParameters;
+}
+declare class Scope {
+    private readonly _analyzer;
+    private readonly _sourceFileScopes;
+    private readonly _methodBlockLiteralScopes;
+    private readonly _packageMethodDeclarationTypeParametersScopes;
+    private readonly _packageMethodDeclarationValueParametersScopes;
+    private readonly _structuredTypeMethodDeclarationTypeParametersScopes;
+    private readonly _structuredTypeMethodDeclarationValueParametersScopes;
+    private readonly _nestedMethodDeclarationTypeParametersScopes;
+    private readonly _nestedMethodDeclarationValueParametersScopes;
+    private readonly _methodLiteralScopes;
+    private readonly _statementBlockScopes;
+    private readonly _forEachStatementScopes;
+    private readonly _onErrorClauseScopes;
+    private readonly _packageStructuredTypeDeclarationTypeParametersScopes;
+    private readonly _structuredTypeDeclarationBodyScopes;
+    private readonly _packageMethodTypeDeclarationTypeParametersScopes;
+    private readonly _methodTypeDeclarationBodyScopes;
+    private readonly _packageVariantTypeDeclarationTypeParametersScopes;
+    private readonly _variantTypeDeclarationBodyScopes;
+    private readonly _aliasTypeDeclarationBodyScopes;
+    private readonly _packageAliasTypeDeclarationTypeParametersScopes;
+    private readonly _structuredTypeConstructorDeclarationScopes;
+    private readonly _structuredTypeDestructorDeclarationScopes;
+    private readonly _typeIndexedAccessorDeclarationParametersScopes;
+    private readonly _typeExtensionDeclarationScopes;
+    private readonly _setterParameterClauseScopes;
+    constructor(_analyzer: Analyzer);
+    ofSourceFile(node: tree.SourceFile): scope.IScope;
+    ofMethodBlockLiteral(node: tree.MethodBlockLiteral): scope.IScope;
+    ofPackageMethodDeclarationTypeParameters(node: tree.PackageMethodDeclaration): scope.IScope;
+    ofPackageMethodDeclarationValueParameters(node: tree.PackageMethodDeclaration): scope.IScope;
+    ofTypeMethodDeclarationTypeParameters(node: tree.TypeMethodDeclaration): scope.IScope;
+    ofTypeMethodDeclarationValueParameters(node: tree.TypeMethodDeclaration): scope.IScope;
+    ofNestedMethodDeclarationTypeParameters(node: tree.NestedMethodDeclaration): scope.IScope;
+    ofNestedMethodDeclarationValueParameters(node: tree.NestedMethodDeclaration): scope.IScope;
+    ofMethodLiteral(node: tree.MethodLiteral): scope.IScope;
+    ofStatementBlock(node: tree.StatementBlock): scope.IScope;
+    ofForStatement(node: tree.ForStatement): scope.IScope;
+    ofOnErrorClause(node: tree.OnErrorClause): scope.IScope;
+    ofPackageStructuredTypeDeclarationTypeParameters(node: tree.PackageStructuredTypeDeclaration): scope.IScope;
+    ofStructuredTypeDeclarationBody(node: tree.StructuredTypeDeclarationBody): scope.IScope;
+    ofPackageMethodTypeDeclarationTypeParameters(node: tree.PackageMethodTypeDeclaration): scope.IScope;
+    ofMethodTypeDeclarationBody(node: tree.MethodTypeDeclarationBody): scope.IScope;
+    ofPackageVariantTypeDeclarationTypeParameters(node: tree.PackageVariantTypeDeclaration): scope.IScope;
+    ofVariantTypeDeclarationBody(node: tree.VariantTypeDeclarationBody): scope.IScope;
+    ofAliasTypeDeclarationBody(node: tree.AliasTypeDeclarationBody): scope.IScope;
+    ofPackageAliasTypeDeclarationTypeParameters(node: tree.PackageAliasTypeDeclaration): scope.IScope;
+    ofTypeConstructorDeclaration(node: tree.TypeConstructorDeclaration): scope.IScope;
+    ofTypeDestructorDeclaration(node: tree.TypeDestructorDeclaration): scope.IScope;
+    ofTypeIndexedAccessorDeclarationParameters(node: TypeIndexedAccessorDeclaration): scope.IScope;
+    ofTypeExtensionDeclaration(node: tree.TypeExtensionDeclaration): scope.IScope;
+    ofSetterParameterClause(node: tree.SetterParameterClause): scope.IScope;
+}
+declare class DefaultConstructors {
+    private readonly _analyzer;
+    private readonly _defaultConstructorEntities;
+    constructor(_analyzer: Analyzer);
+    ofStructuredType(type: StructuredTypeDeclaration): readonly ConstructorEntity[];
+    createAliasTypeDefaultConstructors(aliasTypeEntity: AliasTypeEntity, hasDeclaredConstructors: boolean): readonly ConstructorEntity[];
+    private createDefaultConstructors;
+    private getPublicInstanceStoredVariables;
+}
+declare class OverriddenMember {
+    private readonly _analyzer;
+    constructor(_analyzer: Analyzer);
+    getOverriddenMethod(method: TypeMethodEntity): types.Method | undefined;
+    getTheMostBaseOverriddenMethod(method: TypeMethodEntity): types.Method | undefined;
+    getOverriddenVariable(variable: entities.TypeVariableEntity): types.Variable | undefined;
+    getTheMostBaseOverriddenVariable(variable: entities.TypeVariableEntity): types.Variable | undefined;
+    checkMethodOverridesMethod(methodInDerivedType: TypeMethodEntity, methodInBaseType: types.Method): boolean;
+    checkVariableOverridesVariable(variableInDerivedType: entities.TypeVariableEntity, variableInBaseType: types.Variable): boolean;
+    private findOverriddenVariableInType;
+    private findOverriddenMethodInType;
+    private methodSignatureTypesAreEqual;
+}
+declare class Tags {
+    readonly _analyzer: Analyzer;
+    private readonly _tags;
+    constructor(_analyzer: Analyzer);
+    ofTagList(tagList: tree.TagList): readonly tags.Tag[];
+    private createTags;
+    private callArgumentToTagArgument;
+}
+declare class LinkedEntity {
+    private readonly _analyzer;
+    constructor(_analyzer: Analyzer);
+    ofType(entity: TypeEntity, platform: PlatformKind): TypeEntity | undefined;
+    ofTypeWithMembers(entity: entities.TypeEntityWithMembers, platform: PlatformKind): entities.TypeEntityWithMembers | undefined;
+    ofParameterType(entity: TypeParameterEntity, platform: PlatformKind): TypeParameterEntity | undefined;
+    ofPackageVariable(entity: PackageVariableEntity, platform: PlatformKind): PackageVariableEntity | undefined;
+    ofPackageMethod(entity: PackageMethodEntity, platform: PlatformKind): PackageMethodEntity | undefined;
+    ofTypeVariable(entity: entities.TypeVariableEntity, platform: PlatformKind): entities.TypeVariableEntity | undefined;
+    ofTypeMethod(entity: entities.TypeMethodEntity, platform: PlatformKind): entities.TypeMethodEntity | undefined;
+    ofConstructor(entity: entities.ConstructorEntity, platform: PlatformKind): entities.ConstructorEntity | undefined;
+    ofIndexer(entity: entities.IndexerEntity, platform: PlatformKind): entities.IndexerEntity | undefined;
+    ofDereferenceOperator(entity: entities.DereferenceOperatorEntity, platform: PlatformKind): entities.DereferenceOperatorEntity | undefined;
+}
+export declare class LinkedMultiPlatformPackage {
+    readonly analyzer: Analyzer;
+    readonly pkg: PackageEntity;
+    readonly implementationPackage: PackageEntity;
+    readonly targetPlatform: PlatformKind;
+    private readonly _memberLookup;
+    private readonly _linkedTypesWithMembers;
+    private readonly _linkedParameterTypes;
+    private get memberLookup();
+    constructor(analyzer: Analyzer, pkg: PackageEntity, implementationPackage: PackageEntity, targetPlatform: PlatformKind);
+    getLinkedVariable(entity: PackageVariableEntity): PackageVariableEntity | undefined;
+    getLinkedMethod(entity: PackageMethodEntity): PackageMethodEntity | undefined;
+    getLinkedTypeWithMembers(entity: entities.TypeEntityWithMembers): LinkedTypeWithMembers | undefined;
+    getLinkedParameterType(entity: TypeParameterEntity): TypeParameterEntity | undefined;
+    /**
+     * Используется для сравнения типов при связывании объявления из многоплатформенного пакета с объявлением из
+     * реализационного пакета. В частности, при сравнении типов параметров для выбора правильной перегрузки
+     * метода (конструктора, индексатора).
+     */
+    compareTypesDuringLinking(type1: types.Type, type2: types.Type): boolean;
+    private findPackageType;
+    private compareSubstitutionsDuringLinking;
+}
+export declare class LinkedTypeWithMembers {
+    readonly analyzer: Analyzer;
+    readonly externalType: entities.TypeEntityWithMembers;
+    readonly targetType: entities.TypeEntityWithMembers;
+    readonly linkedPackage: LinkedMultiPlatformPackage;
+    private readonly _memberLookup;
+    private get memberLookup();
+    constructor(analyzer: Analyzer, externalType: entities.TypeEntityWithMembers, targetType: entities.TypeEntityWithMembers, linkedPackage: LinkedMultiPlatformPackage);
+    getLinkedVariable(entity: entities.TypeVariableEntity): entities.TypeVariableEntity | undefined;
+    getLinkedMethod(entity: entities.TypeMethodEntity): entities.TypeMethodEntity | undefined;
+    getLinkedConstructor(entity: entities.ConstructorEntity): entities.ConstructorEntity | undefined;
+    getLinkedIndexerEntity(entity: entities.IndexerEntity): entities.IndexerEntity | undefined;
+    getLinkedDereferenceOperatorEntity(entity: entities.DereferenceOperatorEntity): entities.DereferenceOperatorEntity | undefined;
+}
+declare class OwningPlainObjectModificationCheck {
+    private _analyzer;
+    private readonly _owningPlainObjectModificationCheckResult;
+    constructor(_analyzer: Analyzer);
+    ofDeclarationBody(node: tree.StatementBlock): boolean;
+    private checkMethodBodyModifiesPlainObject;
+    private checkReceiverModifiesPlainObjectRecursively;
+    private nodeBelongsToPlainObjectDeclaration;
+}
+declare class PackageImports {
+    private readonly _analyzer;
+    private readonly _packagesAvailableForImport;
+    private readonly _analyzedPackageImports;
+    private readonly _importedPackages;
+    private readonly _automaticallyImportedPackages;
+    private readonly _importedPackageNameTrees;
+    constructor(_analyzer: Analyzer);
+    analyzeExplicitPackageImports(sourceFile: project.SourceFile): AnalyzedPackageImports;
+    getPackagesAvailableForImport(pkg: project.SourcePackage): readonly AvailablePackage[];
+    getUniqueImportedPackages(sourceFile: project.SourceFile): readonly PackageImportInfo[];
+    getImportedPackageNameTree(node: tree.SourceFile): ImportedPackageNameTree;
+    private getAutomaticallyImportedPackages;
+}
+export declare class AnalyzedPackageImport {
+    readonly entity: PackageEntity | undefined;
+    readonly translationPackage: AnalyzedTranslationPackage | undefined;
+    readonly isAliasedImport: PackageAliasEntity | undefined;
+    constructor(entity: PackageEntity | undefined, translationPackage: AnalyzedTranslationPackage | undefined, isAliasedImport: PackageAliasEntity | undefined);
+}
+export declare class AnalyzedPackageImports {
+    readonly packageImportInfos: Map<tree.PackageImport, AnalyzedPackageImport>;
+    readonly diagnostics: readonly Diagnostic[];
+    constructor(packageImportInfos: Map<tree.PackageImport, AnalyzedPackageImport>, diagnostics: readonly Diagnostic[]);
+}
+export declare class PackageImportInfo {
+    readonly entity: PackageEntity;
+    readonly translationPackage: AnalyzedTranslationPackage | undefined;
+    readonly isAliasedImport: PackageAliasEntity | undefined;
+    constructor(entity: PackageEntity, translationPackage: AnalyzedTranslationPackage | undefined, isAliasedImport: PackageAliasEntity | undefined);
+}
+export declare class ExpressionDenotesMethodCheckResult {
+    readonly candidates: readonly WithLocalization<AccessedMethod>[];
+    readonly suitableMethods: readonly WithLocalization<AccessedMethod>[];
+    get singleSuitableMethod(): WithLocalization<AccessedMethod> | undefined;
+    constructor(candidates: readonly WithLocalization<AccessedMethod>[], suitableMethods: readonly WithLocalization<AccessedMethod>[]);
+}
+export declare class NonHiddenEntityHidingMatcher implements IEntityHidingMatcher {
+    matches(_hiding: entities.EntityHidingLevel): boolean;
+}
+type AvailablePackage = AvailablePackage.Original | AvailablePackage.Translated;
+declare namespace AvailablePackage {
+    export class Original implements IAvailablePackage {
+        readonly value: PackageEntity;
+        readonly kind = "original";
+        constructor(value: PackageEntity);
+        getImportName(): PackageName;
+        getLocale(): PackageLocale;
+        getEntity(): PackageEntity;
+        getTranslationPackage(): AnalyzedTranslationPackage | undefined;
+    }
+    export class Translated implements IAvailablePackage {
+        readonly value: AnalyzedTranslationPackage;
+        readonly kind = "translated";
+        constructor(value: AnalyzedTranslationPackage);
+        getImportName(): PackageName;
+        getLocale(): PackageLocale;
+        getEntity(): PackageEntity;
+        getTranslationPackage(): AnalyzedTranslationPackage | undefined;
+    }
+    interface IAvailablePackage {
+        getImportName(): PackageName;
+        getLocale(): PackageLocale;
+        getEntity(): PackageEntity;
+        getTranslationPackage(): AnalyzedTranslationPackage | undefined;
+    }
+    export {};
+}
+export declare class DeclaredTypeMemberEntities {
+    readonly variables: readonly TypeVariableEntity[];
+    readonly methods: readonly TypeMethodEntity[];
+    readonly constructors: readonly ConstructorEntity[];
+    readonly destructors: readonly DestructorEntity[];
+    readonly indexers: readonly SourceIndexerEntity[];
+    readonly dereferenceOperators: readonly DereferenceOperatorEntity[];
+    readonly unaryOperators: readonly UnaryOperatorEntity[];
+    readonly binaryOperators: readonly BinaryOperatorEntity[];
+    get namedMembers(): NamedTypeMemberEntity[];
+    constructor(variables: readonly TypeVariableEntity[], methods: readonly TypeMethodEntity[], constructors: readonly ConstructorEntity[], destructors: readonly DestructorEntity[], indexers: readonly SourceIndexerEntity[], dereferenceOperators: readonly DereferenceOperatorEntity[], unaryOperators: readonly UnaryOperatorEntity[], binaryOperators: readonly BinaryOperatorEntity[]);
+}
+export {};