@artel/artc 0.6.26017 → 0.6.26019

package/build/types/ts-interop/TypeEntities.d.ts

@@ -0,0 +1,359 @@
+import ts from 'typescript';
+import { Name } from '../common/Name.js';
+import { PackageDialect } from '../common/PackageDialect.js';
+import { PackageLocale } from '../common/PackageLocale.js';
+import { BaseAspectTypes } from '../entities/BaseAspectTypes.js';
+import { BaseObjectType } from '../entities/BaseObjectType.js';
+import { EntityHidingLevel } from '../entities/EntityHiding.js';
+import { EntityKind } from '../entities/EntityKind.js';
+import { EntityNaming } from '../entities/EntityNaming.js';
+import { AliasTypeEntity, AliasTypeEntityDefinition, AliasedType, AnonymousFunctionTypeEntity, AnonymousStructuredTypeEntity, FunctionTypeEntityDefinition, PackageEntity, PackageStructuredTypeEntity, PackageVariantTypeEntity, ParameterEntity, StructuredTypeEntityDefinition, StructuredTypeKind, TypeParameterEntity, VariantTypeEntityDefinition } from '../entities/index.js';
+import { SubstitutionApplicationMode } from '../entities/SubstitutionApplicationMode.js';
+import { Tag } from '../entities/Tag.js';
+import { Translation } from '../entities/Translation.js';
+import { TypeEntityKind } from '../entities/TypeEntity.js';
+import { TypeEntityMembers } from '../entities/TypeEntityMembers.js';
+import * as tree from '../tree/a/index.js';
+import * as types from '../types/index.js';
+import { TsInteropContext } from './TsInteropContext.js';
+/**
+ * Сущность, представляющая классы и интерфейсы.
+ *
+ * Типы в .d.ts файлах могут быть объявлены следующим образом:
+ *
+ * ```
+ * interface Array<T> {
+ *   length: number
+ *   // ...
+ * }
+ *
+ * interface ArrayConstructor {
+ *   new (arrayLength?: number): any[]
+ *
+ *   from<T>(iterable: Iterable<T> | ArrayLike<T>): T[]
+ * }
+ *
+ * declare var Array: ArrayConstructor
+ * ```
+ *
+ * Когда тип используется для указания типа переменной, в нём доступны поля, объявленные в интерфейсе:
+ * ```
+ * let a: Array<number>
+ * a.length // Ок.
+ * a.from   // Ошибка, поле from не найдено.
+ * ```
+ *
+ * Когда тип используется в качестве значения, в т.ч. при вызове конструктора, в нём доступны поля из типа переменной,
+ * название которой совпадает с названием типа (в данном примере `declare var Array: ArrayConstructor`).
+ * ```
+ * new Array(1)    // Ок.
+ * Array.from([1]) // Ок.
+ * Array.length    // Ошибка, поле length не найдено.
+ * ```
+ *
+ * В Артель такие объявления объединяются в один ссылочный объект (StructuredTypeEntity). В него добавляются конструкторы,
+ * объявленные в тип переменной, а также все остальные члены типа (переменные, операции, индексаторы). Они становятся
+ * всеобщими, поскольку доступны через имя типа.
+ */
+export declare class TsGlobalClassOrInterfaceEntity implements PackageStructuredTypeEntity {
+    private readonly tsctx;
+    private readonly symbol;
+    private readonly isDefaultExport;
+    private readonly containingPackage;
+    private readonly forceHiddenInPackage;
+    readonly kind = EntityKind.Type;
+    readonly typeEntityKind = TypeEntityKind.Structured;
+    readonly subkind = "package";
+    private readonly name;
+    private readonly typeParameters;
+    private readonly members;
+    private readonly baseObjectType;
+    private readonly baseAspectTypes;
+    private readonly hiding;
+    constructor(tsctx: TsInteropContext, symbol: ts.Symbol, isDefaultExport: boolean, containingPackage: PackageEntity, forceHiddenInPackage: boolean);
+    getNaming(): EntityNaming;
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getMembers(): TypeEntityMembers;
+    getDefinition(): StructuredTypeEntityDefinition;
+    markedBasic(): boolean;
+    isAbstract(): boolean;
+    getStructuredTypeKind(): StructuredTypeKind;
+    getArity(): number;
+    getBaseObjectType(): BaseObjectType;
+    getBaseAspectTypes(): BaseAspectTypes;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): PackageStructuredTypeEntity;
+    private getDeclaration;
+    private isClassOrInterfaceAndVariableMerge;
+}
+export declare class SourceAndTsGlobalClassOrInterfaceMergeEntity implements PackageStructuredTypeEntity {
+    private readonly tsctx;
+    private readonly symbol;
+    private readonly isDefaultExport;
+    private readonly node;
+    readonly kind = EntityKind.Type;
+    readonly typeEntityKind = TypeEntityKind.Structured;
+    readonly subkind = "package";
+    private readonly sourceData;
+    private readonly members;
+    constructor(tsctx: TsInteropContext, symbol: ts.Symbol, isDefaultExport: boolean, node: tree.PackageStructuredTypeDeclaration);
+    getNaming(): EntityNaming;
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getMembers(): TypeEntityMembers;
+    getDefinition(): StructuredTypeEntityDefinition;
+    markedBasic(): boolean;
+    isAbstract(): boolean;
+    getStructuredTypeKind(): StructuredTypeKind;
+    getArity(): number;
+    getBaseObjectType(): BaseObjectType;
+    getBaseAspectTypes(): BaseAspectTypes;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): PackageStructuredTypeEntity;
+}
+export declare class TsTypeLiteralEntity implements AnonymousStructuredTypeEntity {
+    private readonly tsctx;
+    private readonly symbol;
+    private readonly containingPackage;
+    readonly kind = EntityKind.Type;
+    readonly typeEntityKind = TypeEntityKind.Structured;
+    readonly subkind = "anonymous";
+    private readonly baseObjectType;
+    private readonly baseAspectTypes;
+    private readonly members;
+    constructor(tsctx: TsInteropContext, symbol: ts.Symbol, containingPackage: PackageEntity);
+    getNaming(): EntityNaming;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getMembers(): TypeEntityMembers;
+    getDefinition(): StructuredTypeEntityDefinition;
+    markedBasic(): boolean;
+    isAbstract(): boolean;
+    getStructuredTypeKind(): StructuredTypeKind;
+    getArity(): number;
+    getBaseObjectType(): BaseObjectType;
+    getBaseAspectTypes(): BaseAspectTypes;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getContainingPackage(): PackageEntity;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): AnonymousStructuredTypeEntity;
+}
+export declare class TsNamedTypeLiteralEntity implements PackageStructuredTypeEntity {
+    private readonly tsctx;
+    private readonly symbol;
+    private readonly owningNamedSymbol;
+    private readonly isDefaultExport;
+    private readonly owningDeclarationWithTypeParameters;
+    private readonly containingPackage;
+    private readonly forceHiddenInPackage;
+    readonly kind = EntityKind.Type;
+    readonly typeEntityKind = TypeEntityKind.Structured;
+    readonly subkind = "package";
+    private readonly name;
+    private readonly typeParameters;
+    private readonly baseObjectType;
+    private readonly baseAspectTypes;
+    private readonly members;
+    private readonly hiding;
+    constructor(tsctx: TsInteropContext, symbol: ts.Symbol, owningNamedSymbol: ts.Symbol, isDefaultExport: boolean, owningDeclarationWithTypeParameters: ts.DeclarationWithTypeParameterChildren, containingPackage: PackageEntity, forceHiddenInPackage: boolean);
+    getNaming(): EntityNaming;
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getMembers(): TypeEntityMembers;
+    getDefinition(): StructuredTypeEntityDefinition;
+    markedBasic(): boolean;
+    isAbstract(): boolean;
+    getStructuredTypeKind(): StructuredTypeKind;
+    getArity(): number;
+    getBaseObjectType(): BaseObjectType;
+    getBaseAspectTypes(): BaseAspectTypes;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): PackageStructuredTypeEntity;
+}
+export declare class SourceAndTsNamedTypeLiteralMergeEntity implements PackageStructuredTypeEntity {
+    private readonly tsctx;
+    private readonly symbol;
+    private readonly isDefaultExport;
+    private readonly node;
+    readonly kind = EntityKind.Type;
+    readonly typeEntityKind = TypeEntityKind.Structured;
+    readonly subkind = "package";
+    private readonly sourceData;
+    private readonly members;
+    constructor(tsctx: TsInteropContext, symbol: ts.Symbol, isDefaultExport: boolean, node: tree.PackageStructuredTypeDeclaration);
+    getNaming(): EntityNaming;
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getMembers(): TypeEntityMembers;
+    getDefinition(): StructuredTypeEntityDefinition;
+    markedBasic(): boolean;
+    isAbstract(): boolean;
+    getStructuredTypeKind(): StructuredTypeKind;
+    getArity(): number;
+    getBaseObjectType(): BaseObjectType;
+    getBaseAspectTypes(): BaseAspectTypes;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): PackageStructuredTypeEntity;
+}
+export declare class TsTypeAliasEntity implements AliasTypeEntity {
+    private readonly tsctx;
+    private readonly symbol;
+    private readonly isDefaultExport;
+    private readonly containingPackage;
+    readonly kind = EntityKind.Type;
+    readonly typeEntityKind = TypeEntityKind.Alias;
+    private readonly name;
+    private readonly aliasedType;
+    private readonly typeParameters;
+    constructor(tsctx: TsInteropContext, symbol: ts.Symbol, isDefaultExport: boolean, containingPackage: PackageEntity);
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getAliasedType(): AliasedType;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getDefinition(): AliasTypeEntityDefinition;
+    getMembers(): TypeEntityMembers;
+    getArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): AliasTypeEntity;
+    private getDeclaration;
+}
+export declare class TsAnonymousFunctionTypeEntity implements AnonymousFunctionTypeEntity {
+    private readonly tsctx;
+    private readonly symbol;
+    private readonly declaration;
+    private readonly containingPackage;
+    readonly kind = EntityKind.Type;
+    readonly typeEntityKind = TypeEntityKind.Function;
+    readonly subkind = "anonymous";
+    private readonly parameters;
+    private readonly returnType;
+    private readonly members;
+    private readonly baseObjectType;
+    constructor(tsctx: TsInteropContext, symbol: ts.Symbol, declaration: ts.CallSignatureDeclaration | ts.FunctionTypeNode, containingPackage: PackageEntity);
+    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;
+    getContainingPackage(): PackageEntity;
+    getBaseObjectType(): BaseObjectType;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): AnonymousFunctionTypeEntity;
+}
+/**
+ * Представляет объявления следующего вида:
+ *
+ * ```
+ * interface MyType { (): number } // интерфейс с единственным членом - сигнатурой вызова
+ *
+ * type MyType = () => number // псевдоним функционального типа
+ *
+ * type MyType = { (): number } // псевдоним типа с единственным членом - сигнатурой вызова
+ * ```
+ */
+export declare class TsNamedFunctionTypeEntity implements AliasTypeEntity {
+    private readonly tsctx;
+    private readonly signatureSymbol;
+    private readonly signatureDeclaration;
+    private readonly owningNamedSymbol;
+    private readonly isDefaultExport;
+    private readonly owningDeclarationWithTypeParameters;
+    private readonly containingPackage;
+    private readonly forceHiddenInPackage;
+    readonly kind = EntityKind.Type;
+    readonly typeEntityKind = TypeEntityKind.Alias;
+    readonly subkind = "package";
+    private readonly name;
+    private readonly typeParameters;
+    private readonly aliasedType;
+    private readonly members;
+    private readonly baseObjectType;
+    private readonly hiding;
+    constructor(tsctx: TsInteropContext, signatureSymbol: ts.Symbol, signatureDeclaration: ts.CallSignatureDeclaration | ts.FunctionTypeNode, owningNamedSymbol: ts.Symbol, isDefaultExport: boolean, owningDeclarationWithTypeParameters: ts.DeclarationWithTypeParameterChildren, containingPackage: PackageEntity, forceHiddenInPackage: boolean);
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getAliasedType(): AliasedType;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getMembers(): TypeEntityMembers;
+    getDefinition(): AliasTypeEntityDefinition;
+    getArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getBaseObjectType(): BaseObjectType;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): AliasTypeEntity;
+}
+export declare class TsEnumEntity implements PackageVariantTypeEntity {
+    private readonly tsctx;
+    private readonly symbol;
+    private readonly isDefaultExport;
+    private readonly containingPackage;
+    readonly kind = EntityKind.Type;
+    readonly typeEntityKind = TypeEntityKind.Variant;
+    readonly subkind = "package";
+    private readonly name;
+    private readonly members;
+    private readonly underlyingType;
+    private readonly baseObjectType;
+    constructor(tsctx: TsInteropContext, symbol: ts.Symbol, isDefaultExport: boolean, containingPackage: PackageEntity);
+    getNaming(): EntityNaming;
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getMembers(): TypeEntityMembers;
+    getUnderlyingType(): types.Type;
+    getDefinition(): VariantTypeEntityDefinition;
+    getArity(): number;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getBaseObjectType(): BaseObjectType;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): PackageVariantTypeEntity;
+}

package/build/types/ts-interop/Utils.d.ts

@@ -1,4 +1,4 @@
-import { TsInteropInputs } from '../analysis/index.js';
+import { TsInteropInputs } from '../analysis/TsInteropInputs.js';
 import { Compilation, JavaScriptImplementationConfig, PackageName, ProgramPackage } from '../project/index.js';
 import { TypeScriptLibrariesProvider } from './TsLibrariesProvider.js';
 export declare function createTsInteropInputsForCompilation(compilation: Compilation, librariesProvider: TypeScriptLibrariesProvider): TsInteropInputs;

package/build/types/types/AliasType.d.ts

@@ -1,14 +1,13 @@
-import { Analyzer } from '../analysis/index.js';
+import { Analyzer } from '../analysis/Analyzer.js';
 import { AliasTypeEntity, TypeParameterEntity } from '../entities/index.js';
-import { IType, Substitutions, Type } from './index.js';
-export declare class AliasType implements IType {
-    private readonly analyzer;
+import { Substitutions } from './Substitutions.js';
+import { BaseType, Type } from './Type.js';
+export declare class AliasType extends BaseType {
+    readonly kind = "alias";
     private readonly entity;
     private readonly substitutions;
-    readonly kind = "alias";
     private readonly aliasedType;
-    get isNullType(): boolean;
-    get debuggerDisplay(): string;
+    protected get asType(): Type;
     constructor(analyzer: Analyzer, entity: AliasTypeEntity, substitutions: Substitutions);
     getAliasedType(): Type;
     getTypeParameters(): readonly TypeParameterEntity[];
@@ -16,5 +15,4 @@ export declare class AliasType implements IType {
     applySubstitutions(substitutions: Substitutions): Type;
     equals(other: Type, considerLocale?: boolean): boolean;
     getEntity(): AliasTypeEntity;
-    toString(): string;
 }

package/build/types/types/FunctionType.d.ts

@@ -1,14 +1,14 @@
-import { Analyzer } from '../analysis/index.js';
+import { Analyzer } from '../analysis/Analyzer.js';
 import { FunctionTypeEntity, TypeParameterEntity } from '../entities/index.js';
-import { IType, Parameter, Substitutions, Type } from './index.js';
-export declare class FunctionType implements IType {
-    private readonly analyzer;
+import { Substitutions } from './Substitutions.js';
+import { BaseType, Type } from './Type.js';
+import { Parameter } from './TypeMembers.js';
+export declare class FunctionType extends BaseType {
+    readonly kind = "function";
     private readonly entity;
     private readonly substitutions;
-    readonly kind = "function";
     private readonly parameters;
-    get isNullType(): boolean;
-    get debuggerDisplay(): string;
+    protected get asType(): Type;
     constructor(analyzer: Analyzer, entity: FunctionTypeEntity, substitutions: Substitutions);
     getTypeParameters(): readonly TypeParameterEntity[];
     getSubstitutions(): Substitutions;
@@ -19,5 +19,4 @@ export declare class FunctionType implements IType {
     getReturnType(): Type;
     getParameters(): readonly Parameter[];
     getBaseType(): Type | undefined;
-    toString(): string;
 }

package/build/types/types/IntersectionType.d.ts

@@ -1,20 +1,17 @@
-import { Analyzer } from '../analysis/index.js';
+import { Analyzer } from '../analysis/Analyzer.js';
 import { TypeEntity } from '../entities/index.js';
 import { Substitutions } from './Substitutions.js';
-import { IType, Type } from './index.js';
-export declare class IntersectionType implements IType {
+import { BaseType, Type } from './Type.js';
+export declare class IntersectionType extends BaseType {
     readonly kind = "intersection";
     readonly originalTypes: readonly Type[];
-    private readonly analyzer;
     private readonly unaliasedFlattenedTypes_;
-    get isNullType(): boolean;
     get unaliasedFlattenedTypes(): readonly Type[];
-    get debuggerDisplay(): string;
+    protected get asType(): Type;
     constructor(analyzer: Analyzer, originalTypes: readonly Type[]);
     equals(other: Type, considerLocale?: boolean): boolean;
     getSubstitutions(): Substitutions;
     applySubstitutions(substitutions: Substitutions): Type;
     getEntity(): TypeEntity | undefined;
-    toString(): string;
     private unaliasAndFlattenTypes;
 }

package/build/types/types/ParameterType.d.ts

@@ -1,22 +1,20 @@
-import { Analyzer } from '../analysis/index.js';
+import { Analyzer } from '../analysis/Analyzer.js';
 import { TypeParameterEntity } from '../entities/index.js';
-import { IType, Substitutions, Type } from './index.js';
-export declare class ParameterType implements IType {
-    private readonly analyzer;
-    private readonly entity;
-    readonly isNullExcluded: boolean;
+import { Substitutions } from './Substitutions.js';
+import { BaseType, Type } from './Type.js';
+export declare class ParameterType extends BaseType {
     readonly kind = "parameter";
+    readonly isNullExcluded: boolean;
+    private readonly entity;
     private readonly constraint_;
-    get isNullType(): boolean;
     /**
      * Ограничение параметра типа с учётом флага {@link isNullExcluded}.
      */
     get constraint(): Type | undefined;
-    get debuggerDisplay(): string;
+    protected get asType(): Type;
     constructor(analyzer: Analyzer, entity: TypeParameterEntity, isNullExcluded: boolean);
     getSubstitutions(): Substitutions;
     getEntity(): TypeParameterEntity;
     applySubstitutions(substitutions: Substitutions): Type;
     equals(other: Type, considerLocale?: boolean): boolean;
-    toString(): string;
 }

package/build/types/types/ReducedType.d.ts

@@ -1,16 +1,15 @@
-import { Analyzer } from '../analysis/index.js';
+import { Analyzer } from '../analysis/Analyzer.js';
 import { ReducedTypeEntity, TypeParameterEntity } from '../entities/index.js';
-import { IType, Substitutions, Type } from './index.js';
-export declare class ReducedType implements IType {
-    private readonly analyzer;
+import { Substitutions } from './Substitutions.js';
+import { BaseType, Type } from './Type.js';
+export declare class ReducedType extends BaseType {
+    readonly kind = "reduced";
     private readonly entity;
     private readonly substitutions;
-    readonly kind = "reduced";
     private readonly reductionSource;
     private readonly baseObjectType;
     private readonly baseAspectTypes;
-    get isNullType(): boolean;
-    get debuggerDisplay(): string;
+    protected get asType(): Type;
     constructor(analyzer: Analyzer, entity: ReducedTypeEntity, substitutions: Substitutions);
     getReductionSource(): Type;
     getBaseObjectType(): Type | undefined;
@@ -20,5 +19,4 @@ export declare class ReducedType implements IType {
     applySubstitutions(substitutions: Substitutions): Type;
     equals(other: Type, considerLocale?: boolean): boolean;
     getEntity(): ReducedTypeEntity;
-    toString(): string;
 }

package/build/types/types/StandardTypes.d.ts

@@ -1,5 +1,7 @@
-import { Analyzer, WellKnownDeclarations } from '../analysis/index.js';
-import { StructuredType, UnresolvedType } from './index.js';
+import { Analyzer } from '../analysis/Analyzer.js';
+import { WellKnownDeclarations } from '../analysis/WellKnownDeclarations.js';
+import { StructuredType } from './StructuredType.js';
+import { UnresolvedType } from './UnresolvedType.js';
 export declare class StandardTypes {
     private readonly analyzer;
     private readonly wellKnownDeclarations;

package/build/types/types/StructuredType.d.ts

@@ -1,15 +1,15 @@
-import { Analyzer } from '../analysis/index.js';
+import { Analyzer } from '../analysis/Analyzer.js';
 import { StructuredTypeEntity, StructuredTypeKind, TypeParameterEntity } from '../entities/index.js';
-import { IType, Substitutions, Type } from './index.js';
-export declare class StructuredType implements IType {
-    private readonly analyzer;
+import { Substitutions } from './Substitutions.js';
+import { BaseType, Type } from './Type.js';
+export declare class StructuredType extends BaseType {
+    readonly kind = "structured";
     private readonly entity;
     private readonly substitutions;
-    readonly kind = "structured";
     private readonly baseObjectType;
     private readonly baseAspectTypes;
     get isNullType(): boolean;
-    get debuggerDisplay(): string;
+    protected get asType(): Type;
     constructor(analyzer: Analyzer, entity: StructuredTypeEntity, substitutions: Substitutions);
     getSubstitutions(): Substitutions;
     getTypeParameters(): readonly TypeParameterEntity[];
@@ -21,5 +21,4 @@ export declare class StructuredType implements IType {
     getEntity(): StructuredTypeEntity;
     getBaseObjectType(): Type | undefined;
     getBaseAspectTypes(): readonly Type[];
-    toString(): string;
 }

package/build/types/types/SubstitutionStubType.d.ts

@@ -1,21 +1,18 @@
-import { Analyzer } from '../analysis/index.js';
+import { Analyzer } from '../analysis/Analyzer.js';
 import { TypeEntity } from '../entities/index.js';
 import { Substitutions } from './Substitutions.js';
-import { IType, Type } from './Type.js';
+import { BaseType, Type } from './Type.js';
 /**
  * Специальный тип, используемый при сравнении заголовков функций, имеющих параметры типа. При сравнении заголовков
  * параметры типа считаются равными, если они находятся на одинаковых позициях.
  */
-export declare class SubstitutionStubType implements IType {
-    private readonly analyzer;
-    readonly index: number;
+export declare class SubstitutionStubType extends BaseType {
     readonly kind = "substitution-stub";
-    get isNullType(): boolean;
-    get debuggerDisplay(): string;
+    readonly index: number;
+    protected get asType(): Type;
     constructor(analyzer: Analyzer, index: number);
     equals(other: Type, _considerLocale?: boolean): boolean;
     getSubstitutions(): Substitutions;
     applySubstitutions(_substitutions: Substitutions): Type;
     getEntity(): TypeEntity | undefined;
-    toString(): string;
 }

package/build/types/types/Substitutions.d.ts

@@ -1,4 +1,4 @@
-import { Analyzer } from '../analysis/index.js';
+import { Analyzer } from '../analysis/Analyzer.js';
 import { TypeParameterEntity } from '../entities/index.js';
 import { Type } from './index.js';
 export declare class Substitutions {

package/build/types/types/Type.d.ts

@@ -1,3 +1,4 @@
+import { Analyzer } from '../analysis/Analyzer.js';
 import { TypeEntity } from '../entities/index.js';
 import { AliasType } from './AliasType.js';
 import { FunctionType } from './FunctionType.js';
@@ -11,13 +12,18 @@ import { UnionType } from './UnionType.js';
 import { UnresolvedType } from './UnresolvedType.js';
 import { VariantType } from './VariantType.js';
 export type Type = StructuredType | VariantType | FunctionType | AliasType | UnresolvedType | ParameterType | UnionType | IntersectionType | SubstitutionStubType | ReducedType;
-export declare namespace Type {
-    function isPossiblyAliasedOrReducedStructure(type: Type): boolean;
-}
-export interface IType {
-    readonly isNullType: boolean;
-    getSubstitutions(): Substitutions;
-    applySubstitutions(substitutions: Substitutions): Type;
-    equals(other: Type, considerLocale: boolean): boolean;
-    getEntity(): TypeEntity | undefined;
+export declare abstract class BaseType {
+    protected abstract asType: Type;
+    protected readonly analyzer: Analyzer;
+    get isNullType(): boolean;
+    get debuggerDisplay(): string;
+    constructor(analyzer: Analyzer);
+    abstract getSubstitutions(): Substitutions;
+    abstract applySubstitutions(substitutions: Substitutions): Type;
+    abstract equals(other: Type, considerLocale: boolean): boolean;
+    abstract getEntity(): TypeEntity | undefined;
+    unalias(): Type;
+    unaliasAndGetReductionSource(): Type;
+    isPossiblyAliasedOrReducedStructure(): boolean;
+    toString(): string;
 }

package/build/types/types/TypeFactory.d.ts

@@ -1,6 +1,15 @@
-import { Analyzer } from '../analysis/index.js';
+import { Analyzer } from '../analysis/Analyzer.js';
 import { AliasTypeEntity, FunctionTypeEntity, ReducedTypeEntity, StructuredTypeEntity, TypeParameterEntity, VariantTypeEntity } from '../entities/index.js';
-import { AliasType, FunctionType, ParameterType, ReducedType, StructuredType, Substitutions, SubstitutionStubType, Type, UnresolvedType, VariantType } from './index.js';
+import { AliasType } from './AliasType.js';
+import { FunctionType } from './FunctionType.js';
+import { ParameterType } from './ParameterType.js';
+import { ReducedType } from './ReducedType.js';
+import { StructuredType } from './StructuredType.js';
+import { Substitutions } from './Substitutions.js';
+import { SubstitutionStubType } from './SubstitutionStubType.js';
+import { Type } from './Type.js';
+import { UnresolvedType } from './UnresolvedType.js';
+import { VariantType } from './VariantType.js';
 export declare class TypeFactory {
     readonly analyzer: Analyzer;
     constructor(analyzer: Analyzer);

package/build/types/types/TypeMembers.d.ts

@@ -1,10 +1,13 @@
-import { Analyzer } from '../analysis/index.js';
+import { Analyzer } from '../analysis/Analyzer.js';
 import { Name } from '../common/index.js';
-import { ConstructorEntity, DereferenceOperatorEntity, DestructorEntity, EntityHidingLevel, FieldEntity, IndexerEntity, MethodEntity, OperatorKind, ParameterEntity, TypeParameterEntity } from '../entities/index.js';
+import type { ConstructorEntity, DereferenceOperatorEntity, DestructorEntity, EntityHidingLevel, FieldEntity, IndexerEntity, MethodEntity, OperatorKind, ParameterEntity, TypeParameterEntity } from '../entities/index.js';
 import { FunctionType } from './FunctionType.js';
 import { Substitutions } from './Substitutions.js';
 import { Type } from './Type.js';
 export type TypeMember = Field | Method | Constructor | Destructor | Indexer | DereferenceOperator;
+export declare namespace TypeMember {
+    function getTypeOrReturnType(analyzer: Analyzer, member: TypeMember): Type;
+}
 export type NamedTypeMember = Field | Method;
 export declare function isNamedTypeMember(member: TypeMember): member is NamedTypeMember;
 export type AnonymousTypeMember = Exclude<TypeMember, NamedTypeMember>;