@artel/artc 0.6.25271 → 0.6.25273

package/build/types/entities/interfaces/FunctionEntity.d.ts

@@ -0,0 +1,56 @@
+import { Tag } from '../../analysis/Tag.js';
+import { Translation } from '../../analysis/Translation.js';
+import { Name } from '../../common/index.js';
+import * as tree from '../../tree/index.js';
+import * as types from '../../types/index.js';
+import { IEntity } from '../IEntity.js';
+import type { PackageEntity, TypeWithMembersOrExtensionEntity } from '../index.js';
+import { DefinitionKind, EntityHidingLevel, EntityKind, ParameterEntity, SubstitutionApplicationMode, TypeParameterEntity } from '../index.js';
+export type FunctionEntity = PackageFunctionEntity | MethodEntity | NestedFunctionEntity;
+interface IFunctionEntity extends IEntity {
+    readonly kind: EntityKind.Function;
+    getName(): Name;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getParameters(): readonly ParameterEntity[];
+    getReturnType(): types.Type;
+    getDefinition(): FunctionEntityDefinition;
+    isAsync(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getTypeParametersArity(): number;
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+}
+export interface PackageFunctionEntity extends IFunctionEntity {
+    readonly subkind: 'package';
+    getContainingPackage(): PackageEntity;
+    getTranslation(): Translation | undefined;
+    getOriginalEntity(): PackageFunctionEntity;
+}
+export interface MethodEntity extends IFunctionEntity {
+    readonly subkind: 'method';
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    isStatic(): boolean;
+    isOverride(): boolean;
+    markedBasic(): boolean;
+    markedAbstract(): boolean;
+    isModifyingOwningPlainObject(): boolean;
+    isFunctionTypeInvokeMethod(): boolean;
+    getOverriddenMembers(): readonly types.Method[];
+    getTranslation(): Translation | undefined;
+    getOriginalEntity(): MethodEntity;
+}
+export interface NestedFunctionEntity extends IFunctionEntity {
+    readonly subkind: 'nested';
+    getContainingPackage(): PackageEntity;
+    getTranslation(): Translation | undefined;
+    getOriginalEntity(): NestedFunctionEntity;
+}
+export type FunctionEntityDefinition = {
+    kind: DefinitionKind.Source;
+    node: tree.PackageFunctionDeclaration | tree.MethodDeclaration | tree.NestedFunctionDeclaration;
+} | {
+    kind: DefinitionKind.Intrinsic;
+} | {
+    kind: DefinitionKind.TypeScript;
+};
+export {};

package/build/types/entities/interfaces/FunctionTypeEntity.d.ts

@@ -0,0 +1,52 @@
+import { Tag } from '../../analysis/Tag.js';
+import { Translation } from '../../analysis/Translation.js';
+import { Name } from '../../common/index.js';
+import * as tree from '../../tree/index.js';
+import * as types from '../../types/index.js';
+import { BaseObjectType } from '../BaseObjectType.js';
+import { EntityNaming } from '../EntityNaming.js';
+import { TypeEntityMembers } from '../TypeEntityMembers.js';
+import type { PackageEntity } from '../index.js';
+import { DefinitionKind, EntityHidingLevel, EntityKind, ITypeEntity, ParameterEntity, SubstitutionApplicationMode, TypeEntityKind, TypeParameterEntity } from '../index.js';
+export type FunctionTypeEntity = PackageFunctionTypeEntity | AnonymousFunctionTypeEntity;
+interface IFunctionTypeEntity extends ITypeEntity {
+    readonly kind: EntityKind.Type;
+    readonly typeEntityKind: TypeEntityKind.Function;
+    getNaming(): EntityNaming;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getParameters(): readonly ParameterEntity[];
+    getReturnType(): types.Type;
+    getMembers(): TypeEntityMembers;
+    getDefinition(): FunctionTypeEntityDefinition;
+    isAsync(): boolean;
+    getArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    /**
+     * При каждом вызове метод должен возвращать один и тот же экземпляр класса BaseObjectType.
+     */
+    getBaseObjectType(): BaseObjectType;
+}
+export interface PackageFunctionTypeEntity extends IFunctionTypeEntity {
+    readonly subkind: 'package';
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getTranslation(): Translation | undefined;
+    getOriginalEntity(): PackageFunctionTypeEntity;
+}
+export interface AnonymousFunctionTypeEntity extends IFunctionTypeEntity {
+    readonly subkind: 'anonymous';
+    getContainingPackage(): PackageEntity;
+    getTranslation(): Translation | undefined;
+    getOriginalEntity(): AnonymousFunctionTypeEntity;
+}
+export type FunctionTypeEntityDefinition = {
+    kind: DefinitionKind.Source;
+    node: tree.PackageFunctionTypeDeclaration | tree.AnonymousFunctionTypeDeclaration;
+} | {
+    kind: DefinitionKind.Intrinsic;
+} | {
+    kind: DefinitionKind.TypeScript;
+};
+export {};

package/build/types/entities/interfaces/GetterEntity.d.ts

@@ -0,0 +1,26 @@
+import { GetterDeclaration } from '../../analysis/NodeTypeUtils.js';
+import { Tag } from '../../analysis/Tag.js';
+import { Translation } from '../../analysis/Translation.js';
+import * as types from '../../types/index.js';
+import { IEntity } from '../IEntity.js';
+import { DefinitionKind, DereferenceOperatorEntity, EntityHidingLevel, EntityKind, FieldEntity, IndexerEntity, PackageVariableEntity } from '../index.js';
+export interface GetterEntity extends IEntity {
+    readonly kind: EntityKind.Getter;
+    getReturnType(): types.Type;
+    getDefinition(): GetterEntityDefinition;
+    isModifyingOwningPlainObject(): boolean;
+    getOwningEntity(): EntityOwningGetter;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getTranslation(): Translation | undefined;
+    getOriginalEntity(): GetterEntity;
+}
+export type GetterEntityDefinition = {
+    kind: DefinitionKind.Source;
+    node: GetterDeclaration;
+} | {
+    kind: DefinitionKind.Intrinsic;
+} | {
+    kind: DefinitionKind.TypeScript;
+};
+export type EntityOwningGetter = PackageVariableEntity | FieldEntity | IndexerEntity | DereferenceOperatorEntity;

package/build/types/entities/interfaces/IndexerEntity.d.ts

@@ -0,0 +1,33 @@
+import { Tag } from '../../analysis/Tag.js';
+import { Translation } from '../../analysis/Translation.js';
+import * as tree from '../../tree/index.js';
+import * as types from '../../types/index.js';
+import { IEntity } from '../IEntity.js';
+import { DefinitionKind, EntityHidingLevel, EntityKind, GetterEntity, ParameterEntity, SetterEntity, TypeWithMembersOrExtensionEntity } from '../index.js';
+export interface IndexerEntity extends IEntity {
+    readonly kind: EntityKind.Indexer;
+    getParameters(): readonly ParameterEntity[];
+    getType(): types.Type;
+    getGetter(): GetterEntity | undefined;
+    getSetter(): SetterEntity | undefined;
+    getDefinition(): IndexerEntityDefinition;
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    isStatic(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    isOverride(): boolean;
+    markedBasic(): boolean;
+    markedAbstract(): boolean;
+    getTags(): readonly Tag[];
+    getOverriddenMembers(): readonly types.Indexer[];
+    getTranslation(): Translation | undefined;
+    getOriginalEntity(): IndexerEntity;
+    ensureAllDiagnosticsReported?(): void;
+}
+export type IndexerEntityDefinition = {
+    kind: DefinitionKind.Source;
+    nodes: ReadonlyArray<tree.IndexedElementGetterDeclaration | tree.IndexedElementSetterDeclaration>;
+} | {
+    kind: DefinitionKind.Intrinsic;
+} | {
+    kind: DefinitionKind.TypeScript;
+};

package/build/types/entities/interfaces/OperatorEntity.d.ts

@@ -0,0 +1,27 @@
+import { Tag } from '../../analysis/Tag.js';
+import { Translation } from '../../analysis/Translation.js';
+import * as tree from '../../tree/index.js';
+import * as types from '../../types/index.js';
+import { IEntity } from '../IEntity.js';
+import { DefinitionKind, EntityHidingLevel, EntityKind, OperatorKind, ParameterEntity, TypeWithMembersOrExtensionEntity } from '../index.js';
+export interface OperatorEntity extends IEntity {
+    readonly kind: EntityKind.Operator;
+    getOperatorKind(): OperatorKind;
+    getParameters(): readonly ParameterEntity[];
+    getReturnType(): types.Type;
+    getDefinition(): OperatorEntityDefinition;
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    isStatic(): boolean;
+    isOverride(): boolean;
+    markedBasic(): boolean;
+    markedAbstract(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getOverriddenMembers(): readonly types.Operator[];
+    getTranslation(): Translation | undefined;
+    getOriginalEntity(): OperatorEntity;
+}
+export type OperatorEntityDefinition = {
+    kind: DefinitionKind.Source;
+    node: tree.OperatorDeclaration;
+};

package/build/types/entities/interfaces/PackageAliasEntity.d.ts

@@ -0,0 +1,21 @@
+import { Tag } from '../../analysis/Tag.js';
+import { Translation } from '../../analysis/Translation.js';
+import { Name } from '../../common/index.js';
+import * as tree from '../../tree/index.js';
+import { IEntity } from '../IEntity.js';
+import { DefinitionKind, EntityHidingLevel, EntityKind, PackageEntity } from '../index.js';
+export interface PackageAliasEntity extends IEntity {
+    readonly kind: EntityKind.PackageAlias;
+    getName(): Name;
+    getDefinition(): PackageAliasEntityDefinition;
+    getPackage(): PackageEntity | undefined;
+    isHidden(): EntityHidingLevel | undefined;
+    getContainingPackage(): PackageEntity;
+    getTranslation(): Translation | undefined;
+    getOriginalEntity(): PackageAliasEntity;
+    getTags(): readonly Tag[];
+}
+export type PackageAliasEntityDefinition = {
+    kind: DefinitionKind.Source;
+    node: tree.PackageImport;
+};

package/build/types/entities/{PackageEntity.d.ts → interfaces/PackageEntity.d.ts}

@@ -1,12 +1,11 @@
-import { Analyzer } from '../analysis/index.js';
-import { Tag } from '../analysis/Tag.js';
-import { Translation } from '../analysis/Translation.js';
-import { PackageDialect, PackageLocale } from '../common/index.js';
-import type { JavaScriptImplementationConfig, SourcePackage } from '../project/index.js';
-import { PackageName, PlatformKind } from '../project/index.js';
-import { IEntity } from './IEntity.js';
-import { DefinitionKind, EntityKind } from './index.js';
-import { PackageEntityMembers } from './PackageMembers.js';
+import { Tag } from '../../analysis/Tag.js';
+import { Translation } from '../../analysis/Translation.js';
+import { PackageDialect, PackageLocale } from '../../common/index.js';
+import type { JavaScriptImplementationConfig, SourcePackage } from '../../project/index.js';
+import { PackageName, PlatformKind } from '../../project/index.js';
+import { IEntity } from '../IEntity.js';
+import { DefinitionKind, EntityKind } from '../index.js';
+import { PackageEntityMembers } from '../PackageMembers.js';
 export interface PackageEntity extends IEntity {
     readonly kind: EntityKind.Package;
     getName(): PackageName;
@@ -51,29 +50,3 @@ export declare class TextTranslationPackageEntityInfo {
     readonly targetPackage: PackageEntity | undefined;
     constructor(translationLocale: PackageLocale, targetPackage: PackageEntity | undefined);
 }
-export declare class SourcePackageEntity implements PackageEntity {
-    private readonly analyzer;
-    private readonly package_;
-    readonly kind = EntityKind.Package;
-    private readonly members;
-    private readonly interfaceInfo;
-    private readonly implementedInterfacePackage;
-    private readonly textTranslationInfo;
-    constructor(analyzer: Analyzer, package_: SourcePackage);
-    getName(): PackageName;
-    getLocale(): PackageLocale;
-    getDialect(): PackageDialect;
-    getMembers(): PackageEntityMembers;
-    getInterfacePackageInfo(): InterfacePackageEntityInfo | undefined;
-    getImplementedInterfacePackage(): PackageEntity | undefined;
-    getSupportedPlatforms(): readonly PlatformKind[];
-    getContainingPackage(): PackageEntity;
-    getDefinition(): PackageEntityDefinition;
-    getTranslation(): Translation | undefined;
-    getOriginalEntity(): PackageEntity;
-    getTags(): readonly Tag[];
-    getTextTranslationPackageInfo(): TextTranslationPackageEntityInfo | undefined;
-    private createPackageMembers;
-    private createInterfacePackageInfo;
-    private createTextTranslationInfo;
-}

package/build/types/entities/interfaces/SetterEntity.d.ts

@@ -0,0 +1,24 @@
+import { SetterDeclaration } from '../../analysis/NodeTypeUtils.js';
+import { Tag } from '../../analysis/Tag.js';
+import { Translation } from '../../analysis/Translation.js';
+import { IEntity } from '../IEntity.js';
+import { DefinitionKind, DereferenceOperatorEntity, EntityHidingLevel, EntityKind, FieldEntity, IndexerEntity, PackageVariableEntity } from '../index.js';
+export interface SetterEntity extends IEntity {
+    readonly kind: EntityKind.Setter;
+    getDefinition(): SetterEntityDefinition;
+    isModifyingOwningPlainObject(): boolean;
+    getOwningEntity(): EntityOwningSetter;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getTranslation(): Translation | undefined;
+    getOriginalEntity(): SetterEntity;
+}
+export type SetterEntityDefinition = {
+    kind: DefinitionKind.Source;
+    node: SetterDeclaration;
+} | {
+    kind: DefinitionKind.Intrinsic;
+} | {
+    kind: DefinitionKind.TypeScript;
+};
+export type EntityOwningSetter = PackageVariableEntity | FieldEntity | IndexerEntity | DereferenceOperatorEntity;

package/build/types/entities/interfaces/StructuredTypeEntity.d.ts

@@ -0,0 +1,62 @@
+import { Tag } from '../../analysis/Tag.js';
+import { Translation } from '../../analysis/Translation.js';
+import { Name } from '../../common/index.js';
+import * as tree from '../../tree/index.js';
+import { BaseAspectTypes } from '../BaseAspectTypes.js';
+import { BaseObjectType } from '../BaseObjectType.js';
+import { EntityNaming } from '../EntityNaming.js';
+import { TypeEntityMembers } from '../TypeEntityMembers.js';
+import type { PackageEntity } from '../index.js';
+import { DefinitionKind, EntityHidingLevel, EntityKind, ITypeEntity, SubstitutionApplicationMode, TypeEntityKind, TypeParameterEntity } from '../index.js';
+export type StructuredTypeEntity = PackageStructuredTypeEntity | AnonymousStructuredTypeEntity;
+interface IStructuredTypeEntity extends ITypeEntity {
+    readonly kind: EntityKind.Type;
+    readonly typeEntityKind: TypeEntityKind.Structured;
+    getNaming(): EntityNaming;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getMembers(): TypeEntityMembers;
+    getDefinition(): StructuredTypeEntityDefinition;
+    markedBasic(): boolean;
+    isAbstract(): boolean;
+    getStructuredTypeKind(): StructuredTypeKind;
+    getArity(): number;
+    /**
+     * При каждом вызове метод должен возвращать один и тот же экземпляр класса BaseObjectType.
+     */
+    getBaseObjectType(): BaseObjectType;
+    /**
+     * При каждом вызове метод должен возвращать один и тот же экземпляр класса BaseAspectTypes.
+     */
+    getBaseAspectTypes(): BaseAspectTypes;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+}
+export interface PackageStructuredTypeEntity extends IStructuredTypeEntity {
+    readonly subkind: 'package';
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getTranslation(): Translation | undefined;
+    getOriginalEntity(): PackageStructuredTypeEntity;
+}
+export interface AnonymousStructuredTypeEntity extends IStructuredTypeEntity {
+    readonly subkind: 'anonymous';
+    getContainingPackage(): PackageEntity;
+    getTranslation(): Translation | undefined;
+    getOriginalEntity(): AnonymousStructuredTypeEntity;
+}
+export declare enum StructuredTypeKind {
+    RefObject = 0,
+    PlainObject = 1,
+    Aspect = 2
+}
+export type StructuredTypeEntityDefinition = {
+    kind: DefinitionKind.Source;
+    node: StructuredTypeEntityDefinitionNode;
+} | {
+    kind: DefinitionKind.Intrinsic;
+} | {
+    kind: DefinitionKind.TypeScript;
+};
+type StructuredTypeEntityDefinitionNode = tree.PackageStructuredTypeDeclaration | tree.AnonymousStructuredTypeDeclaration;
+export {};

package/build/types/entities/interfaces/TextTranslationEntity.d.ts

@@ -0,0 +1,18 @@
+import { TextKey } from '../../analysis/TextIdentity.js';
+import * as tree from '../../tree/index.js';
+import { IEntity } from '../IEntity.js';
+import { DefinitionKind, EntityKind, ParameterEntity } from '../index.js';
+export interface TextTranslationEntity extends IEntity {
+    readonly kind: EntityKind.TextTranslation;
+    isTextTemplate(): boolean;
+    getKey(): TextKey;
+    getText(): string;
+    getTextFragments(): readonly string[];
+    getComment(): string | undefined;
+    getParameters(): readonly ParameterEntity[];
+    getDefinition(): TextTranslationEntityDefinition;
+}
+export type TextTranslationEntityDefinition = {
+    kind: DefinitionKind.Source;
+    node: tree.TextTranslationSource;
+};

package/build/types/entities/interfaces/TypeExtensionEntity.d.ts

@@ -0,0 +1,22 @@
+import { Tag } from '../../analysis/Tag.js';
+import { Translation } from '../../analysis/Translation.js';
+import * as tree from '../../tree/index.js';
+import { IEntity } from '../IEntity.js';
+import { TypeEntityMembers } from '../TypeEntityMembers.js';
+import { DefinitionKind, EntityContext, EntityHidingLevel, EntityKind, NamedTypeEntity, PackageEntity } from '../index.js';
+export interface TypeExtensionEntity extends IEntity {
+    readonly kind: EntityKind.TypeExtension;
+    getMembers(): TypeEntityMembers;
+    getContainingPackage(): PackageEntity;
+    getExtendedTypeEntity(): NamedTypeEntity | undefined;
+    getDefinition(): TypeExtensionEntityDefinition;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getContext(): EntityContext;
+    getTranslation(): Translation | undefined;
+    getOriginalEntity(): TypeExtensionEntity;
+}
+export type TypeExtensionEntityDefinition = {
+    kind: DefinitionKind.Source;
+    node: tree.TypeExtensionDeclaration;
+};

package/build/types/entities/{TypeParameterEntity.d.ts → interfaces/TypeParameterEntity.d.ts}

@@ -1,10 +1,8 @@
-import { Analyzer } from '../analysis/index.js';
-import { Tag } from '../analysis/Tag.js';
-import { Translation } from '../analysis/Translation.js';
-import { Name, PackageDialect, PackageLocale } from '../common/index.js';
-import { TypeParameterDeclaration } from '../tree/index.js';
-import * as types from '../types/index.js';
-import { AliasTypeEntity, DefinitionKind, EntityContext, EntityHidingLevel, EntityKind, FunctionEntity, FunctionTypeEntity, ITypeEntity, PackageEntity, StructuredTypeEntity, TypeEntityKind, VariantTypeEntity } from './index.js';
+import { Translation } from '../../analysis/Translation.js';
+import { Name } from '../../common/index.js';
+import * as tree from '../../tree/index.js';
+import * as types from '../../types/index.js';
+import { AliasTypeEntity, DefinitionKind, EntityHidingLevel, EntityKind, FunctionEntity, FunctionTypeEntity, ITypeEntity, StructuredTypeEntity, TypeEntityKind, VariantTypeEntity } from '../index.js';
 export interface TypeParameterEntity extends ITypeEntity {
     readonly kind: EntityKind.Type;
     readonly typeEntityKind: TypeEntityKind.Parameter;
@@ -24,7 +22,7 @@ export interface TypeParameterEntity extends ITypeEntity {
 }
 export type TypeParameterEntityDefinition = {
     kind: DefinitionKind.Source;
-    node: TypeParameterDeclaration;
+    node: tree.TypeParameterDeclaration;
 } | {
     kind: DefinitionKind.Intrinsic;
 } | {
@@ -74,55 +72,3 @@ export declare class CycleFreeConstraintResolutionResult {
     constructor(type: types.Type | undefined, causesCycle: boolean);
 }
 export declare const emptyTypeParameterEntities: readonly TypeParameterEntity[];
-export declare class SourceTypeParameterEntity implements TypeParameterEntity {
-    private readonly analyzer;
-    private readonly node;
-    readonly kind = EntityKind.Type;
-    readonly typeEntityKind = TypeEntityKind.Parameter;
-    private readonly name;
-    private readonly definition;
-    private readonly constraint;
-    private readonly default;
-    constructor(analyzer: Analyzer, node: TypeParameterDeclaration);
-    getName(): Name;
-    getConstraint(): TypeParameterConstraint;
-    getDefaultType(): types.Type | undefined;
-    getDefinition(): TypeParameterEntityDefinition;
-    getArity(): number;
-    getTypeParameters(): readonly TypeParameterEntity[];
-    getContainingEntity(): EntityContainingTypeParameter;
-    getContainingPackage(): PackageEntity;
-    isHidden(): EntityHidingLevel | undefined;
-    getTags(): readonly Tag[];
-    getContext(): EntityContext;
-    getTranslation(): Translation | undefined;
-    getLocale(): PackageLocale;
-    getDialect(): PackageDialect;
-    getOriginalEntity(): TypeParameterEntity;
-}
-export declare class IntrinsicTypeParameterEntity implements TypeParameterEntity {
-    private readonly name;
-    private readonly constraint;
-    private readonly defaultValue;
-    private readonly containingEntity;
-    readonly kind = EntityKind.Type;
-    readonly typeEntityKind = TypeEntityKind.Parameter;
-    private readonly typeParameterConstraint;
-    private readonly context;
-    constructor(name: Name, constraint: types.Type | undefined, defaultValue: types.Type | undefined, containingEntity: EntityContainingTypeParameter, context: EntityContext | undefined);
-    getName(): Name;
-    getConstraint(): TypeParameterConstraint;
-    getDefaultType(): types.Type | undefined;
-    getDefinition(): TypeParameterEntityDefinition;
-    getArity(): number;
-    getTypeParameters(): readonly TypeParameterEntity[];
-    getContainingEntity(): EntityContainingTypeParameter;
-    getContainingPackage(): PackageEntity;
-    isHidden(): EntityHidingLevel | undefined;
-    getTags(): readonly Tag[];
-    getContext(): EntityContext;
-    getTranslation(): Translation | undefined;
-    getLocale(): PackageLocale;
-    getDialect(): PackageDialect;
-    getOriginalEntity(): TypeParameterEntity;
-}

package/build/types/entities/interfaces/VariableEntity.d.ts

@@ -0,0 +1,102 @@
+import { SetterDeclaration, SubprogramDeclarationOrLiteral } from '../../analysis/NodeTypeUtils.js';
+import { Tag } from '../../analysis/Tag.js';
+import { Translation } from '../../analysis/Translation.js';
+import { Name } from '../../common/index.js';
+import * as tree from '../../tree/index.js';
+import * as types from '../../types/index.js';
+import { IEntity } from '../IEntity.js';
+import type { IndexerEntity, PackageEntity, TypeWithMembersOrExtensionEntity } from '../index.js';
+import { ConstructorEntity, DefinitionKind, DestructorEntity, EntityHidingLevel, EntityKind, FunctionEntity, FunctionTypeEntity, GetterEntity, OperatorEntity, SetterEntity } from '../index.js';
+export type VariableEntity = PackageVariableEntity | FieldEntity | ParameterEntity | LocalVariableEntity;
+interface IVariableEntity extends IEntity {
+    readonly kind: EntityKind.Variable;
+    getName(): Name;
+    getType(): types.Type;
+    getDefinition(): VariableEntityDefinition;
+    getGetter(): GetterEntity | undefined;
+    getSetter(): SetterEntity | undefined;
+    isConstant(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    isSpecial(): SpecialVariableEntityInfo | undefined;
+    getTags(): readonly Tag[];
+    ensureAllDiagnosticsReported?(): void;
+}
+export interface PackageVariableEntity extends IVariableEntity {
+    readonly subkind: 'package';
+    getContainingPackage(): PackageEntity;
+    getTranslation(): Translation | undefined;
+    getOriginalEntity(): PackageVariableEntity;
+}
+export interface FieldEntity extends IVariableEntity {
+    readonly subkind: 'field';
+    getContainingEntity(): TypeWithMembersOrExtensionEntity;
+    isStatic(): boolean;
+    isOverride(): boolean;
+    markedBasic(): boolean;
+    markedAbstract(): boolean;
+    getOverriddenMembers(): readonly types.Field[];
+    isVariant(): boolean;
+    getTranslation(): Translation | undefined;
+    getOriginalEntity(): FieldEntity;
+}
+export interface ParameterEntity extends IVariableEntity {
+    readonly subkind: 'parameter';
+    getContainingEntity(): EntityContainingParameter;
+    isOptional(): boolean;
+    isVariadic(): boolean;
+    getTranslation(): Translation | undefined;
+    getOriginalEntity(): ParameterEntity;
+}
+export interface LocalVariableEntity extends IVariableEntity {
+    readonly subkind: 'local';
+    getLocalVariableKind(): LocalVariableKind;
+    getContainingPackage(): PackageEntity;
+    getTranslation(): Translation | undefined;
+    getOriginalEntity(): LocalVariableEntity;
+}
+export declare enum LocalVariableKind {
+    Regular = 0,
+    Enumeration = 1,
+    Error = 2
+}
+export type EntityContainingParameter = FunctionEntity | IndexerEntity | ConstructorEntity | DestructorEntity | FunctionTypeEntity | OperatorEntity | PackageEntity;
+export type VariableEntityDefinition = {
+    kind: DefinitionKind.Source;
+    value: SourceVariableEntityDefinition;
+} | {
+    kind: DefinitionKind.Intrinsic;
+} | {
+    kind: DefinitionKind.TypeScript;
+};
+export type SourceVariableEntityDefinition = SingleSourceVariableEntityDefinition | MultiSourceVariableEntityDefinition;
+export type SingleSourceVariableEntityDefinition = {
+    kind: 'single';
+    node: tree.PackageVariableDeclaration | tree.FieldDeclaration | tree.LocalVariableDeclaration | tree.ForStatementVariableDeclaration | tree.ErrorVariableDeclaration | tree.ParameterDeclaration | tree.VariantDeclaration | tree.TranslationTextTemplateParameter;
+};
+export type MultiSourceVariableEntityDefinition = {
+    kind: 'multi';
+    nodes: ReadonlyArray<tree.PackageVariableGetterDeclaration | tree.PackageVariableSetterDeclaration | tree.FieldGetterDeclaration | tree.FieldSetterDeclaration | tree.ParameterDeclaration>;
+};
+export type SpecialVariableEntityInfo = ResultSpecialVariableEntityInfo | ValueSpecialVariableEntityInfo | BackingSpecialVariableEntityInfo | ImplicitFunctionBlockParameterSpecialVariableEntityInfo;
+export declare class ResultSpecialVariableEntityInfo {
+    readonly subprogramNode: SubprogramDeclarationOrLiteral;
+    readonly kind = "result";
+    constructor(subprogramNode: SubprogramDeclarationOrLiteral);
+}
+export declare class ValueSpecialVariableEntityInfo {
+    readonly setterDeclaration: SetterDeclaration;
+    readonly kind = "value";
+    constructor(setterDeclaration: SetterDeclaration);
+}
+export declare class BackingSpecialVariableEntityInfo {
+    readonly computedVariable: PackageVariableEntity | FieldEntity;
+    readonly kind = "backing";
+    constructor(computedVariable: PackageVariableEntity | FieldEntity);
+}
+export declare class ImplicitFunctionBlockParameterSpecialVariableEntityInfo {
+    readonly targetTypeParameter: types.Parameter;
+    readonly functionBlockLiteral: tree.FunctionBlockLiteral;
+    readonly kind = "implicit-function-block-parameter";
+    constructor(targetTypeParameter: types.Parameter, functionBlockLiteral: tree.FunctionBlockLiteral);
+}
+export {};

package/build/types/entities/interfaces/VariantTypeEntity.d.ts

@@ -0,0 +1,47 @@
+import { Tag } from '../../analysis/Tag.js';
+import { Translation } from '../../analysis/Translation.js';
+import { Name } from '../../common/index.js';
+import * as tree from '../../tree/index.js';
+import * as types from '../../types/index.js';
+import { BaseObjectType } from '../BaseObjectType.js';
+import { EntityNaming } from '../EntityNaming.js';
+import { TypeEntityMembers } from '../TypeEntityMembers.js';
+import { DefinitionKind, EntityHidingLevel, EntityKind, ITypeEntity, PackageEntity, SubstitutionApplicationMode, TypeEntityKind, TypeParameterEntity } from '../index.js';
+export type VariantTypeEntity = PackageVariantTypeEntity | AnonymousVariantTypeEntity;
+interface IVariantTypeEntity extends ITypeEntity {
+    readonly kind: EntityKind.Type;
+    readonly typeEntityKind: TypeEntityKind.Variant;
+    getMembers(): TypeEntityMembers;
+    getUnderlyingType(): types.Type;
+    getDefinition(): VariantTypeEntityDefinition;
+    getNaming(): EntityNaming;
+    getArity(): number;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    /**
+     * При каждом вызове метод должен возвращать один и тот же экземпляр класса BaseObjectType.
+     */
+    getBaseObjectType(): BaseObjectType;
+}
+export interface PackageVariantTypeEntity extends IVariantTypeEntity {
+    readonly subkind: 'package';
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getTranslation(): Translation | undefined;
+    getOriginalEntity(): PackageVariantTypeEntity;
+}
+export interface AnonymousVariantTypeEntity extends IVariantTypeEntity {
+    readonly subkind: 'anonymous';
+    getContainingPackage(): PackageEntity;
+    getTranslation(): Translation | undefined;
+    getOriginalEntity(): AnonymousVariantTypeEntity;
+}
+export type VariantTypeEntityDefinition = {
+    kind: DefinitionKind.Source;
+    node: tree.PackageVariantTypeDeclaration | tree.AnonymousVariantTypeDeclaration;
+} | {
+    kind: DefinitionKind.TypeScript;
+};
+export {};

package/build/types/entities/interfaces/index.d.ts

@@ -0,0 +1,18 @@
+export * from './AliasTypeEntity.js';
+export * from './ConstructorEntity.js';
+export * from './DereferenceOperatorEntity.js';
+export * from './DestructorEntity.js';
+export * from './FunctionEntity.js';
+export * from './FunctionTypeEntity.js';
+export * from './GetterEntity.js';
+export * from './IndexerEntity.js';
+export * from './OperatorEntity.js';
+export * from './PackageAliasEntity.js';
+export * from './PackageEntity.js';
+export * from './SetterEntity.js';
+export * from './StructuredTypeEntity.js';
+export * from './TextTranslationEntity.js';
+export * from './TypeExtensionEntity.js';
+export * from './TypeParameterEntity.js';
+export * from './VariableEntity.js';
+export * from './VariantTypeEntity.js';