@artel/artc 0.6.25191

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

@@ -0,0 +1,42 @@
+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';
+export declare class NamedTypeResolver {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _semanticContext;
+    private get semanticContext();
+    constructor(analyzer: Analyzer, node: QualifiedName);
+    resolve(): NamedTypeResolutionResult;
+    private lookupTypeOrContainerWithTypes;
+    private findTypesOrContainersWithTypesInResolvedQualifier;
+    private findTypesOrContainersWithTypesInPackageAccessedViaAlias;
+    private findTypesOrContainersWithTypesInPackageNameSegment;
+    private convertPackageMember;
+}
+export declare class NamedTypeResolutionResult {
+    readonly types: readonly FoundNamedDeclaration<NamedTypeEntity>[];
+    readonly resolvedQualifiers: readonly ResolvedQualifier[];
+    readonly diagnostics: readonly Diagnostic[];
+    constructor(types: readonly FoundNamedDeclaration<NamedTypeEntity>[], resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly Diagnostic[]);
+}
+export type ResolvedQualifier = ResolvedQualifier_packageNameSegment | ResolvedQualifier_packageAlias | ResolvedQualifier_type;
+export declare class ResolvedQualifier_packageNameSegment {
+    readonly packageTreeNode: PackageNameTreeNode;
+    readonly kind = "package-name-segment";
+    constructor(packageTreeNode: PackageNameTreeNode);
+}
+export declare class ResolvedQualifier_packageAlias {
+    readonly packageAlias: PackageAliasEntity;
+    readonly kind = "package-alias";
+    constructor(packageAlias: PackageAliasEntity);
+}
+export declare class ResolvedQualifier_type {
+    readonly candidates: readonly FoundNamedDeclaration<NamedTypeEntity>[];
+    readonly suitableTypes: readonly FoundNamedDeclaration<NamedTypeEntity>[];
+    readonly kind = "type";
+    constructor(candidates: readonly FoundNamedDeclaration<NamedTypeEntity>[], suitableTypes: readonly FoundNamedDeclaration<NamedTypeEntity>[]);
+}

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

@@ -0,0 +1,20 @@
+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 { ResolvedQualifier } from './NamedTypeResolver.js';
+export declare class NamedTypeSpecifierResolver {
+    private readonly _analyzer;
+    private readonly _node;
+    constructor(_analyzer: Analyzer, _node: NamedTypeSpecifier);
+    resolve(): NamedTypeSpecifierResolutionResult;
+    private convertNamedTypeToTypeDeclaration;
+    private resolveTypeOverload;
+}
+export declare class NamedTypeSpecifierResolutionResult {
+    readonly type: FoundNamedDeclaration<types.Type> | undefined;
+    readonly resolvedQualifiers: readonly ResolvedQualifier[];
+    readonly diagnostics: readonly Diagnostic[];
+    constructor(type: FoundNamedDeclaration<types.Type> | undefined, resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly Diagnostic[]);
+}

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

@@ -0,0 +1,28 @@
+import * as tree from '../tree/index.js';
+export declare class NodeTypeUtils {
+    static isTypeDeclaration(node: tree.Node): node is TypeDeclaration;
+    static isNamedTypeDeclaration(node: tree.Node): node is NamedTypeDeclaration;
+    static isPackageTypeDeclaration(node: tree.Node): node is PackageTypeDeclaration;
+    static isStructuredTypeDeclaration(node: tree.Node): node is StructuredTypeDeclaration;
+    static isTypeMemberDeclaration(node: tree.Node): node is tree.TypeMemberDeclaration;
+    static isPackageMemberDeclaration(node: tree.Node): node is tree.PackageMemberDeclaration;
+    static isExpression(node: tree.Node): node is tree.Expression;
+    static isStatement(node: tree.Node): node is tree.Statement;
+    static isTypeSpecifier(node: tree.Node): node is tree.TypeSpecifier;
+    static isMethodDeclaration(node: tree.Node): node is MethodDeclaration;
+    static isVariableDeclaration(node: tree.Node): node is VariableDeclaration;
+}
+export type PackageTypeDeclaration = tree.PackageAliasTypeDeclaration | tree.PackageMethodTypeDeclaration | tree.PackageStructuredTypeDeclaration | tree.PackageVariantTypeDeclaration;
+export type StructuredTypeDeclaration = tree.PackageStructuredTypeDeclaration | tree.AnonymousStructuredTypeDeclaration;
+export type VariantTypeDeclaration = tree.PackageVariantTypeDeclaration | tree.AnonymousVariantTypeDeclaration;
+export type MethodTypeDeclaration = tree.PackageMethodTypeDeclaration | tree.AnonymousMethodTypeDeclaration;
+export type MethodDeclaration = tree.PackageMethodDeclaration | tree.NestedMethodDeclaration | tree.TypeMethodDeclaration;
+export type TypeDeclaration = StructuredTypeDeclaration | VariantTypeDeclaration | MethodTypeDeclaration | tree.PackageAliasTypeDeclaration | tree.TypeParameterDeclaration;
+export type NamedTypeDeclaration = tree.PackageStructuredTypeDeclaration | tree.PackageVariantTypeDeclaration | tree.PackageMethodTypeDeclaration | tree.PackageAliasTypeDeclaration | tree.TypeParameterDeclaration;
+export type VariableDeclaration = tree.EnumerationVariableDeclaration | tree.PackageVariableDeclaration | tree.LocalVariableDeclaration | tree.ParameterDeclaration | tree.TypeVariableDeclaration | tree.VariantDeclaration;
+export type GetterDeclaration = tree.PackageVariableGetterDeclaration | tree.TypeVariableGetterDeclaration | tree.TypeIndexedGetterDeclaration | tree.TypeDereferencedVariableGetterDeclaration;
+export type SetterDeclaration = tree.PackageVariableSetterDeclaration | tree.TypeVariableSetterDeclaration | tree.TypeIndexedSetterDeclaration | tree.TypeDereferencedVariableSetterDeclaration;
+export type PackageVariableAccessorDeclaration = tree.PackageVariableGetterDeclaration | tree.PackageVariableSetterDeclaration;
+export type TypeVariableAccessorDeclaration = tree.TypeVariableGetterDeclaration | tree.TypeVariableSetterDeclaration;
+export type TypeIndexedAccessorDeclaration = tree.TypeIndexedGetterDeclaration | tree.TypeIndexedSetterDeclaration;
+export type TypeDereferencedVariableAccessorDeclaration = tree.TypeDereferencedVariableGetterDeclaration | tree.TypeDereferencedVariableSetterDeclaration;

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

@@ -0,0 +1,38 @@
+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. объект - в любом выражении в контексте типа.
+ */
+export declare class Resolver {
+    private readonly _analyzer;
+    private readonly _node;
+    constructor(analyzer: Analyzer, node: tree.ObjectExpression);
+    resolve(): Meaning;
+    private resolveOwnConstructorAccess;
+    private resolveContextAccess;
+    private invalidContextMeaning;
+    private findContainingConstructor;
+}
+export type Meaning = Meaning_ownConstructorAccess | Meaning_objectAccess | Meaning_unresolved;
+declare class Meaning_ownConstructorAccess {
+    readonly candidates: readonly FoundAnonymousDeclaration<types.Constructor>[];
+    readonly suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[];
+    readonly kind = "own-constructor-access";
+    constructor(candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
+}
+declare class Meaning_objectAccess {
+    readonly type: types.Type;
+    readonly kind = "object-access";
+    constructor(type: types.Type);
+}
+declare class Meaning_unresolved {
+    readonly diagnostic: Diagnostic;
+    readonly kind = "unresolved";
+    constructor(diagnostic: Diagnostic);
+}
+export {};

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

@@ -0,0 +1,19 @@
+import { Name } from '../common/index.js';
+import { CallExpression } from '../tree/index.js';
+import * as types from '../types/index.js';
+import { Analyzer } from './Analyzer.js';
+export declare class Resolver<TCandidate extends ICandidate<TValueParameter>, TValueParameter extends IValueParameter> {
+    private readonly _analyzer;
+    constructor(_analyzer: Analyzer);
+    resolveByCallExpression(candidates: Iterable<TCandidate>, node: CallExpression): Iterable<TCandidate>;
+    resolveByTargetType(candidates: Iterable<TCandidate>, targetType: types.MethodType): Iterable<TCandidate>;
+}
+export interface ICandidate<TValueParameter extends IValueParameter> {
+    getValueParameters(): readonly TValueParameter[];
+    getSignatureType(): types.Type;
+}
+export interface IValueParameter {
+    getName(): Name | undefined;
+    getType(): types.Type;
+    isOptional(): boolean;
+}

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

@@ -0,0 +1,12 @@
+import { Analyzer } from '../analysis/index.js';
+import * as matcher from './CallArgumentsToParametersMatcher.js';
+export declare class OverloadResolver<TSignature extends matcher.ISignature<TParameter>, TParameter extends matcher.ISignatureParameter, TCallArgument extends matcher.ICallArgument> {
+    private readonly _analyzer;
+    private readonly _signatures;
+    private readonly _callArguments;
+    constructor(_analyzer: Analyzer, _signatures: readonly TSignature[], _callArguments: readonly TCallArgument[]);
+    resolveOverload(): TSignature[];
+    private tryChooseBestSignature;
+    private chooseBetterTargetType;
+    private getDistanceBetweenTypesInHierarchy;
+}

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

@@ -0,0 +1,15 @@
+import { Query, SearchName } from '../common/index.js';
+import { NamedMember } from '../entities/PackageMembers.js';
+import { IEntityHidingMatcher, 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): Query<FoundNamedDeclaration<NamedMember>>;
+    getNamedMembersByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): Query<FoundNamedDeclaration<NamedMember>>;
+    getTypeExtensions(type: TypeEntity, hidingMatcher?: IEntityHidingMatcher): Query<TypeExtensionEntity>;
+}

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

@@ -0,0 +1,27 @@
+import { WithDiagnostics } from '../common/index.js';
+import { NotExpression, PrefixUnaryExpression } from '../tree/index.js';
+import * as types from '../types/index.js';
+import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
+import { Analyzer } from './index.js';
+/**
+ * Определяет подходящую одноместную операцию, определённую пользователем (+, -, не).
+ *
+ * Алгоритм:
+ *
+ * 1. Определить тип операнда.
+ * 2. Найти в типе операторы необходимого вида.
+ * 3. Если найден один оператор - проверить, совместим ли тип выражения с типом операнда.
+ *    Если подошло несколько операторов - ошибка неоднозначного доступа.
+ *    Если не подошёл ни один - алгоритм завершается с соответствующим сообщением об ошибке.
+ */
+export declare class PrefixUnaryOperatorResolver {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _operandType;
+    private get operandType();
+    private get operand();
+    private get operatorNode();
+    private get operatorKind();
+    constructor(_analyzer: Analyzer, _node: PrefixUnaryExpression | NotExpression);
+    resolve(): WithDiagnostics<FoundAnonymousDeclaration<types.UnaryOperator>>;
+}

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

@@ -0,0 +1,100 @@
+import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { PackageTypeEntity, PackageVariableEntity, VariantEntity } from '../entities/index.js';
+import { PropertyAccessExpression } 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 variableAccess from './VariableAccess.js';
+import { Analyzer, TargetTypeHint } from './index.js';
+export declare class Resolver {
+    private readonly _propertySearchName;
+    private readonly _accessKind;
+    private readonly _semanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _targetTypeHint;
+    constructor(analyzer: Analyzer, node: PropertyAccessExpression, targetTypeHint: TargetTypeHint | undefined);
+    private get propertySearchName();
+    private get accessKind();
+    private get semanticContext();
+    private get receiver();
+    resolve(): ResolutionResult;
+    private resolvePackageAliasMemberAccessMeaning;
+    private resolvePackageMemberAccessMeaning;
+    private resolvePackageNameSegmentAccessMeaning;
+    private createAccessedMethodFromPackageMember;
+    private resolveStaticMemberOrVariantAccessMeaning;
+    private createAccessedMethodFromTypeMember;
+    private resolveInstanceMemberAccessMeaning;
+    private resolveMethodOverload;
+}
+export declare class ResolutionResult {
+    readonly meaning: Meaning;
+    readonly diagnostic?: Diagnostic | undefined;
+    constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined);
+}
+export type Meaning = Meaning_packageVariableAccess | Meaning_packageMethodAccess | Meaning_packageTypeAccess | Meaning_packageNameSegmentAccess | Meaning_variantAccess | Meaning_staticVariableAccess | Meaning_staticMethodAccess | Meaning_instanceVariableAccess | Meaning_instanceMethodAccess | Meaning_unresolved;
+declare class Meaning_packageVariableAccess {
+    readonly variable: FoundNamedDeclaration<PackageVariableEntity>;
+    readonly access: variableAccess.VariableAccess;
+    readonly kind = "package-variable-access";
+    constructor(variable: FoundNamedDeclaration<PackageVariableEntity>, access: variableAccess.VariableAccess);
+}
+declare class Meaning_packageMethodAccess {
+    readonly candidates: readonly FoundNamedDeclaration<AccessedMethod>[];
+    readonly suitableMethods: readonly FoundNamedDeclaration<AccessedMethod>[];
+    readonly kind = "package-method-access";
+    get singleSuitableMethod(): FoundNamedDeclaration<AccessedMethod> | undefined;
+    constructor(candidates: readonly FoundNamedDeclaration<AccessedMethod>[], suitableMethods: readonly FoundNamedDeclaration<AccessedMethod>[]);
+}
+declare class Meaning_packageTypeAccess {
+    readonly candidates: readonly FoundNamedDeclaration<PackageTypeEntity>[];
+    readonly suitableTypes: readonly FoundNamedDeclaration<types.Type>[];
+    readonly kind = "package-type-access";
+    get singleSuitableType(): FoundNamedDeclaration<types.Type> | undefined;
+    constructor(candidates: readonly FoundNamedDeclaration<PackageTypeEntity>[], suitableTypes: readonly FoundNamedDeclaration<types.Type>[]);
+}
+declare class Meaning_packageNameSegmentAccess {
+    readonly packageTreeNode: PackageNameTreeNode;
+    readonly kind = "package-name-segment-access";
+    constructor(packageTreeNode: PackageNameTreeNode);
+}
+declare class Meaning_variantAccess {
+    readonly type: types.VariantType;
+    readonly variant: FoundNamedDeclaration<VariantEntity>;
+    readonly kind = "variant-access";
+    constructor(type: types.VariantType, variant: FoundNamedDeclaration<VariantEntity>);
+}
+declare class Meaning_staticVariableAccess {
+    readonly type: types.Type;
+    readonly variable: FoundNamedDeclaration<types.Variable>;
+    readonly access: variableAccess.VariableAccess;
+    readonly kind = "static-variable-access";
+    constructor(type: types.Type, variable: FoundNamedDeclaration<types.Variable>, access: variableAccess.VariableAccess);
+}
+declare class Meaning_staticMethodAccess {
+    readonly type: types.Type;
+    readonly candidates: readonly FoundNamedDeclaration<AccessedMethod>[];
+    readonly suitableMethods: readonly FoundNamedDeclaration<AccessedMethod>[];
+    readonly kind = "static-method-access";
+    get singleSuitableMethod(): FoundNamedDeclaration<AccessedMethod> | undefined;
+    constructor(type: types.Type, candidates: readonly FoundNamedDeclaration<AccessedMethod>[], suitableMethods: readonly FoundNamedDeclaration<AccessedMethod>[]);
+}
+declare class Meaning_instanceVariableAccess {
+    readonly variable: FoundNamedDeclaration<types.Variable>;
+    readonly access: variableAccess.VariableAccess;
+    readonly kind = "instance-variable-access";
+    constructor(variable: FoundNamedDeclaration<types.Variable>, access: variableAccess.VariableAccess);
+}
+declare class Meaning_instanceMethodAccess {
+    readonly candidates: readonly FoundNamedDeclaration<AccessedMethod>[];
+    readonly suitableMethods: readonly FoundNamedDeclaration<AccessedMethod>[];
+    readonly kind = "instance-method-access";
+    get singleSuitableMethod(): FoundNamedDeclaration<AccessedMethod> | undefined;
+    constructor(candidates: readonly FoundNamedDeclaration<AccessedMethod>[], suitableMethods: readonly FoundNamedDeclaration<AccessedMethod>[]);
+}
+declare class Meaning_unresolved {
+    readonly kind = "unresolved";
+}
+export {};

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

@@ -0,0 +1,309 @@
+import { Name, PackageLocale, SearchName } from '../common/index.js';
+import { AliasTypeEntity, EntityHidingLevel, IEntityHidingMatcher, MethodEntity, NamedTypeEntity, PackageAliasEntity, PackageMethodTypeEntity, PackageStructuredTypeEntity, PackageVariantTypeEntity, TypeEntity, TypeExtensionEntity, TypeParameterEntity, VariableEntity, VariantEntity } from '../entities/index.js';
+import * as tree from '../tree/index.js';
+import * as types from '../types/index.js';
+import { Analyzer } from './Analyzer.js';
+import { FoundNamedDeclaration } from './FoundDeclaration.js';
+import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
+import { Lookup } from './Lookup.js';
+import { TypeMemberLookup } from './TypeMemberLookup.js';
+export interface IScope {
+    getTypesOrContainersWithTypes(hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getTypesOrContainersWithTypesByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getNamedDeclarations(hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
+    getNamedDeclarationsByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
+    getTypeExtensionsByType(typeEntity: TypeEntity, hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
+}
+export type TypeOrContainerWithTypes = TypeOrContainerWithTypes_type | TypeOrContainerWithTypes_packageAlias | TypeOrContainerWithTypes_packageNameSegment;
+export declare class TypeOrContainerWithTypes_type implements ITypeOrContainerWithTypes {
+    readonly value: TypeDeclaration;
+    readonly kind = "type";
+    constructor(value: TypeDeclaration);
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export declare class TypeOrContainerWithTypes_packageAlias implements ITypeOrContainerWithTypes {
+    readonly value: PackageAliasEntity;
+    readonly kind = "package-alias";
+    constructor(value: PackageAliasEntity);
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export declare class TypeOrContainerWithTypes_packageNameSegment implements ITypeOrContainerWithTypes {
+    readonly value: PackageNameTreeNode;
+    readonly kind = "package-name-segment";
+    constructor(value: PackageNameTreeNode);
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+}
+interface ITypeOrContainerWithTypes {
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export type TypeDeclaration = TypeDeclaration_structured | TypeDeclaration_variant | TypeDeclaration_method | TypeDeclaration_parameter | TypeDeclaration_alias;
+export declare class TypeDeclaration_structured implements ITypeDeclaration {
+    readonly value: PackageStructuredTypeEntity;
+    readonly kind = "structured";
+    constructor(value: PackageStructuredTypeEntity);
+    getArity(): number;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getName(): Name;
+    getEntity(): NamedTypeEntity;
+    isHidden(): EntityHidingLevel | undefined;
+    instantiate(analyzer: Analyzer, typeArguments: readonly types.Type[]): types.Type;
+}
+export declare class TypeDeclaration_variant implements ITypeDeclaration {
+    readonly value: PackageVariantTypeEntity;
+    readonly kind = "variant";
+    constructor(value: PackageVariantTypeEntity);
+    getArity(): number;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getName(): Name;
+    getEntity(): NamedTypeEntity;
+    isHidden(): EntityHidingLevel | undefined;
+    instantiate(analyzer: Analyzer, typeArguments: readonly types.Type[]): types.Type;
+}
+export declare class TypeDeclaration_method implements ITypeDeclaration {
+    readonly value: PackageMethodTypeEntity;
+    readonly kind = "method";
+    constructor(value: PackageMethodTypeEntity);
+    getArity(): number;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getName(): Name;
+    getEntity(): NamedTypeEntity;
+    isHidden(): EntityHidingLevel | undefined;
+    instantiate(analyzer: Analyzer, typeArguments: readonly types.Type[]): types.Type;
+}
+export declare class TypeDeclaration_parameter implements ITypeDeclaration {
+    readonly value: TypeParameterEntity;
+    readonly kind = "parameter";
+    constructor(value: TypeParameterEntity);
+    getArity(): number;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getName(): Name;
+    getEntity(): NamedTypeEntity;
+    isHidden(): EntityHidingLevel | undefined;
+    instantiate(analyzer: Analyzer, _typeArguments: readonly types.Type[]): types.Type;
+}
+export declare class TypeDeclaration_alias implements ITypeDeclaration {
+    readonly value: AliasTypeEntity;
+    readonly kind = "alias";
+    constructor(value: AliasTypeEntity);
+    getArity(): number;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getName(): Name;
+    getEntity(): NamedTypeEntity;
+    isHidden(): EntityHidingLevel | undefined;
+    instantiate(analyzer: Analyzer, typeArguments: readonly types.Type[]): types.Type;
+}
+interface ITypeDeclaration {
+    getArity(): number;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getName(): Name;
+    getEntity(): NamedTypeEntity;
+    isHidden(): EntityHidingLevel | undefined;
+    instantiate(analyzer: Analyzer, typeArguments: readonly types.Type[]): types.Type;
+}
+export type NamedDeclaration = NamedDeclaration_method | NamedDeclaration_variable | NamedDeclaration_type | NamedDeclaration_variant | NamedDeclaration_packageAlias | NamedDeclaration_packageNameSegment;
+export declare class NamedDeclaration_method implements INamedDeclaration {
+    readonly value: NamedDeclarationMethod;
+    readonly kind = "method";
+    constructor(value: NamedDeclarationMethod);
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export type NamedDeclarationMethod = NamedDeclarationMethod_entity | NamedDeclarationMethod_typeMember;
+export declare class NamedDeclarationMethod_entity implements INamedDeclarationMethod {
+    readonly kind = "entity";
+    private readonly _valueParameters;
+    readonly value: MethodEntity;
+    constructor(value: MethodEntity);
+    getName(): Name;
+    getEntity(): MethodEntity;
+    getTypeParameterArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+    getValueParameters(): readonly ValueParameter[];
+}
+export declare class NamedDeclarationMethod_typeMember implements INamedDeclarationMethod {
+    readonly kind = "type-member";
+    private readonly _valueParameters;
+    readonly value: types.Method;
+    constructor(value: types.Method);
+    getName(): Name;
+    getEntity(): MethodEntity;
+    getTypeParameterArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+    getValueParameters(): readonly ValueParameter[];
+}
+interface INamedDeclarationMethod {
+    getName(): Name;
+    getEntity(): MethodEntity;
+    getTypeParameterArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+    getValueParameters(): readonly ValueParameter[];
+}
+export type ValueParameter = ValueParameter_entity | ValueParameter_typeMember;
+export declare class ValueParameter_entity implements IValueParameter {
+    readonly value: VariableEntity;
+    readonly kind = "entity";
+    constructor(value: VariableEntity);
+    getName(): Name;
+    getType(): types.Type;
+}
+export declare class ValueParameter_typeMember implements IValueParameter {
+    readonly value: types.ValueParameter;
+    readonly kind = "type-member";
+    constructor(value: types.ValueParameter);
+    getName(): Name;
+    getType(): types.Type;
+}
+interface IValueParameter {
+    getName(): Name;
+    getType(): types.Type;
+}
+export declare class NamedDeclaration_variable implements INamedDeclaration {
+    readonly value: NamedDeclarationVariable;
+    readonly kind = "variable";
+    constructor(value: NamedDeclarationVariable);
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export type NamedDeclarationVariable = NamedDeclarationVariable_entity | NamedDeclarationVariable_typeMember;
+export declare class NamedDeclarationVariable_entity implements INamedDeclarationVariable {
+    readonly value: VariableEntity;
+    readonly kind = "entity";
+    constructor(value: VariableEntity);
+    getName(): Name;
+    getEntity(): VariableEntity;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export declare class NamedDeclarationVariable_typeMember implements INamedDeclarationVariable {
+    readonly value: types.Variable;
+    readonly kind = "type-member";
+    constructor(value: types.Variable);
+    getName(): Name;
+    getEntity(): VariableEntity;
+    isHidden(): EntityHidingLevel | undefined;
+}
+interface INamedDeclarationVariable {
+    getName(): Name;
+    getEntity(): VariableEntity;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export declare class NamedDeclaration_type implements INamedDeclaration {
+    readonly value: TypeDeclaration;
+    readonly kind = "type";
+    constructor(value: TypeDeclaration);
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export declare class NamedDeclaration_variant implements INamedDeclaration {
+    readonly value: VariantEntity;
+    readonly kind = "variant";
+    constructor(value: VariantEntity);
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export declare class NamedDeclaration_packageAlias implements INamedDeclaration {
+    readonly value: PackageAliasEntity;
+    readonly kind = "package-alias";
+    constructor(value: PackageAliasEntity);
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export declare class NamedDeclaration_packageNameSegment implements INamedDeclaration {
+    readonly value: PackageNameTreeNode;
+    readonly kind = "package-name-segment";
+    constructor(value: PackageNameTreeNode);
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+}
+interface INamedDeclaration {
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export declare class SourceFileScope implements IScope {
+    private readonly _sourceFileMembers;
+    private readonly _containingPackageMemberLookup;
+    private readonly _importedPackageMemberLookups;
+    private readonly _packageNameSegments;
+    private readonly _locale;
+    constructor(analyzer: Analyzer, node: tree.SourceFile);
+    getTypesOrContainersWithTypes(hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getTypesOrContainersWithTypesByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getNamedDeclarations(hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
+    getNamedDeclarationsByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
+    getTypeExtensionsByType(type: TypeEntity, hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
+    private convertPackageMembersTypeDeclaration;
+    private convertPackageMemberToNamedDeclaration;
+    private convertPackageAliasToTypeOrContainerWithTypes;
+    private convertPackageMemberToTypeOrContainerWithTypes;
+    private convertPackageAliasToNamedDeclaration;
+    private checkTypeOrContainerWithTypesShadowing;
+    private checkNamedDeclarationShadowing;
+}
+export declare class GenericScope implements IScope {
+    private readonly _typeOrContainerWithTypes;
+    private readonly _namedDeclarations;
+    private readonly _typeExtensionEntities;
+    private readonly _locale;
+    private readonly _namedDeclarationsByName;
+    private readonly _typesOrContainerWithTypesByName;
+    private get namedDeclarationsByName();
+    private get typesOrContainerWithTypesByName();
+    constructor(typeOrContainerWithTypes: readonly TypeOrContainerWithTypes[], namedDeclarations: readonly NamedDeclaration[], typeExtensionEntities: readonly TypeExtensionEntity[], locale: PackageLocale);
+    getTypesOrContainersWithTypes(hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getTypesOrContainersWithTypesByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getNamedDeclarations(hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
+    getNamedDeclarationsByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
+    getTypeExtensionsByType(typeEntity: TypeEntity, hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
+    private checkHiding;
+}
+export declare class ParameterDeclarationsScope implements IScope {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _namedDeclarations;
+    private readonly _namedDeclarationsByName;
+    private _locale;
+    private get namedDeclarations();
+    private get namedDeclarationsByName();
+    private get locale();
+    constructor(analyzer: Analyzer, node: tree.ParameterList);
+    getTypesOrContainersWithTypes(hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getTypesOrContainersWithTypesByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getNamedDeclarations(hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
+    getNamedDeclarationsByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
+    getTypeExtensionsByType(typeEntity: TypeEntity, hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
+    private checkHiding;
+}
+export declare class StructuredTypeBodyScope implements IScope {
+    private readonly _memberLookup;
+    private readonly _typeExtensionsLookup;
+    constructor(_memberLookup: TypeMemberLookup, _typeExtensionsLookup: Lookup);
+    getTypesOrContainersWithTypes(_hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getTypesOrContainersWithTypesByName(_name: SearchName, _hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getNamedDeclarations(hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
+    getNamedDeclarationsByName(name: SearchName, hidingMatcher: IEntityHidingMatcher | undefined): FoundNamedDeclaration<NamedDeclaration>[];
+    getTypeExtensionsByType(_typeEntity: TypeEntity, _hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
+    private convertNamedMember;
+}
+export declare class TypeExtensionBodyScope implements IScope {
+    private readonly _analyzer;
+    private readonly _extendedTypeMemberLookup;
+    private readonly _extendedType;
+    private readonly _typeExtensionEntity;
+    private readonly _typeExtensionsLookup;
+    private readonly _locale;
+    private readonly _substitutions;
+    private get substitutions();
+    constructor(_analyzer: Analyzer, _extendedTypeMemberLookup: TypeMemberLookup | undefined, _extendedType: NamedTypeEntity | undefined, _typeExtensionEntity: TypeExtensionEntity, _typeExtensionsLookup: Lookup, _locale: PackageLocale);
+    getTypesOrContainersWithTypes(_hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getTypesOrContainersWithTypesByName(_name: SearchName, _hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getNamedDeclarations(hidingMatcher: IEntityHidingMatcher | undefined): FoundNamedDeclaration<NamedDeclaration>[];
+    getNamedDeclarationsByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
+    getTypeExtensionsByType(_typeEntity: TypeEntity, _hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
+    private convertTypeExtensionMember;
+    private convertExtendedTypeMember;
+    private checkNamedDeclarationShadowing;
+}
+export {};